宠物临时寄养双向匹配系统，核心功能，寄养人发布空间与收费，宠物主人发需求，系统匹配靠谱寄养人，支持实时监控与押金担保，应用场景，解决宠物主人出差，旅游无人照顾的痛点。

以下是一个基于Python的宠物临时寄养双向匹配系统，采用模块化设计，包含核心匹配算法、押金担保和监控功能。系统遵循PEP8规范，添加详细注释，支持新手友好操作。

"""

宠物临时寄养双向匹配系统

核心功能：寄养人发布空间与收费、宠物主人发需求、智能匹配、实时监控、押金担保

技术栈：Python 3.8+（无第三方依赖，纯标准库实现）

"""

import json

from datetime import datetime, timedelta

from typing import List, Dict, Optional, Tuple

# ------------------------------

# 数据模型定义（实体类）

# ------------------------------

class User:

"""用户基类"""

def __init__(self, user_id: str, name: str, phone: str, location: str):

self.user_id = user_id # 唯一标识

self.name = name

self.phone = phone

self.location = location # 城市/区域

self.rating = 5.0 # 初始评分（5星制）

self.reviews = [] # 评价记录

class Sitter(User):

"""寄养人：提供寄养服务"""

def __init__(self, user_id: str, name: str, phone: str, location: str,

space_desc: str, price: float, max_pets: int, accepted_types: List[str]):

super().__init__(user_id, name, phone, location)

self.space_desc = space_desc # 空间描述（如"独立阳台+空调房"）

self.price = price # 每日收费（元）

self.max_pets = max_pets # 最大寄养数量

self.accepted_types = accepted_types # 接受的宠物类型（如["猫", "小型犬"]）

self.available_dates = [] # 可寄养日期范围（(start, end)元组列表）

class PetOwner(User):

"""宠物主人：发布寄养需求"""

def __init__(self, user_id: str, name: str, phone: str, location: str,

pet_type: str, pet_size: str, special_needs: str = ""):

super().__init__(user_id, name, phone, location)

self.pet_type = pet_type # 宠物类型（如"布偶猫"）

self.pet_size = pet_size # 体型（小型/中型/大型）

self.special_needs = special_needs # 特殊需求（如"需喂药"）

class Listing:

"""寄养信息发布"""

def __init__(self, sitter: Sitter, start_date: str, end_date: str):

self.listing_id = f"L{datetime.now().strftime('%Y%m%d%H%M%S')}"

self.sitter = sitter

self.start_date = start_date # 格式"YYYY-MM-DD"

self.end_date = end_date

self.posted_time = datetime.now()

class Request:

"""寄养需求发布"""

def __init__(self, owner: PetOwner, pet_name: str, start_date: str,

end_date: str, budget: float, description: str = ""):

self.request_id = f"R{datetime.now().strftime('%Y%m%d%H%M%S')}"

self.owner = owner

self.pet_name = pet_name

self.start_date = start_date

self.end_date = end_date

self.budget = budget # 最高预算（元/天）

self.description = description # 额外说明

self.posted_time = datetime.now()

class Match:

"""匹配记录"""

def __init__(self, listing: Listing, request: Request, deposit: float):

self.match_id = f"M{datetime.now().strftime('%Y%m%d%H%M%S')}"

self.listing = listing

self.request = request

self.deposit = deposit # 押金（元）

self.status = "pending" # pending/confirmed/completed/cancelled

self.monitor_logs = [] # 监控日志（时间, 内容）

# ------------------------------

# 核心系统逻辑

# ------------------------------

class PetSittingSystem:

def __init__(self):

self.sitters: List[Sitter] = [] # 寄养人列表

self.owners: List[PetOwner] = [] # 宠物主人列表

self.listings: List[Listing] = [] # 寄养信息发布

self.requests: List[Request] = [] # 寄养需求发布

self.matches: List[Match] = [] # 匹配记录

self.deposit_pool = {} # 押金池 {match_id: amount}

def register_sitter(self, name: str, phone: str, location: str,

space_desc: str, price: float, max_pets: int,

accepted_types: List[str]) -> Sitter:

"""注册寄养人"""

sitter_id = f"S{len(self.sitters)+1}"

sitter = Sitter(sitter_id, name, phone, location, space_desc,

price, max_pets, accepted_types)

self.sitters.append(sitter)

return sitter

def register_owner(self, name: str, phone: str, location: str,

pet_type: str, pet_size: str, special_needs: str = "") -> PetOwner:

"""注册宠物主人"""

owner_id = f"O{len(self.owners)+1}"

owner = PetOwner(owner_id, name, phone, location, pet_type,

pet_size, special_needs)

self.owners.append(owner)

return owner

def post_listing(self, sitter: Sitter, start_date: str, end_date: str) -> Listing:

"""寄养人发布寄养信息"""

# 校验日期格式

try:

datetime.strptime(start_date, "%Y-%m-%d")

datetime.strptime(end_date, "%Y-%m-%d")

except ValueError:

raise ValueError("日期格式错误，请使用YYYY-MM-DD")

listing = Listing(sitter, start_date, end_date)

self.listings.append(listing)

return listing

def post_request(self, owner: PetOwner, pet_name: str, start_date: str,

end_date: str, budget: float, description: str = "") -> Request:

"""宠物主人发布寄养需求"""

try:

datetime.strptime(start_date, "%Y-%m-%d")

datetime.strptime(end_date, "%Y-%m-%d")

except ValueError:

raise ValueError("日期格式错误，请使用YYYY-MM-DD")

request = Request(owner, pet_name, start_date, end_date, budget, description)

self.requests.append(request)

return request

def _date_overlap(self, s1: str, e1: str, s2: str, e2: str) -> bool:

"""检查两个日期区间是否重叠"""

s1_dt, e1_dt = datetime.strptime(s1, "%Y-%m-%d"), datetime.strptime(e1, "%Y-%m-%d")

s2_dt, e2_dt = datetime.strptime(s2, "%Y-%m-%d"), datetime.strptime(e2, "%Y-%m-%d")

return s1_dt <= e2_dt and s2_dt <= e1_dt

def match_sitter(self, request: Request) -> List[Tuple[Listing, float]]:

"""核心匹配算法：返回按匹配度排序的寄养信息列表"""

matched = []

for listing in self.listings:

sitter = listing.sitter

# 基本条件过滤

if not (self._date_overlap(listing.start_date, listing.end_date,

request.start_date, request.end_date) and

sitter.location == request.owner.location and

request.pet_type.split()[0] in sitter.accepted_types and # 匹配宠物大类

listing.sitter.price <= request.budget and

sitter.max_pets > 0): # 简化：假设寄养人有空位

continue

# 计算匹配度（综合评分、价格、距离等因素）

price_score = 1 - (listing.sitter.price / request.budget) # 价格越低分越高

rating_score = sitter.rating / 5.0 # 评分越高分越高

match_score = 0.6 * rating_score + 0.4 * price_score # 权重分配

matched.append((listing, round(match_score, 2)))

# 按匹配度降序排序

return sorted(matched, key=lambda x: x[1], reverse=True)

def create_match(self, listing: Listing, request: Request, deposit: float) -> Match:

"""创建匹配记录（含押金担保）"""

if deposit < listing.sitter.price * 2: # 押金至少为2天费用

raise ValueError("押金不足，需至少为2天寄养费用")

match = Match(listing, request, deposit)

self.matches.append(match)

self.deposit_pool[match.match_id] = deposit # 存入押金池

listing.sitter.max_pets -= 1 # 占用寄养名额

return match

def add_monitor_log(self, match: Match, content: str):

"""添加实时监控日志（如宠物状态更新）"""

log_entry = (datetime.now().strftime("%Y-%m-%d %H:%M"), content)

match.monitor_logs.append(log_entry)

def complete_match(self, match: Match, is_successful: bool):

"""完成寄养，处理押金"""

if is_successful:

# 成功：退还押金给寄养人（简化处理，实际应转账）

print(f"押金{self.deposit_pool[match.match_id]}元已退还给寄养人{match.listing.sitter.name}")

else:

# 失败：扣除押金（示例逻辑）

penalty = self.deposit_pool[match.match_id] * 0.3 # 扣30%作为违约金

print(f"因寄养问题，扣除押金{penalty}元，剩余{self.deposit_pool[match.match_id]-penalty}元退还")

del self.deposit_pool[match.match_id]

match.listing.sitter.max_pets += 1 # 释放名额

match.status = "completed"

# ------------------------------

# 示例使用与测试

# ------------------------------

def demo():

"""系统功能演示"""

system = PetSittingSystem()

# 1. 注册用户

sitter1 = system.register_sitter(

name="李阿姨", phone="13800138000", location="北京市朝阳区",

space_desc="独立阳光房，带猫爬架和玩具", price=80, max_pets=2,

accepted_types=["猫", "小型犬"]

)

owner1 = system.register_owner(

name="张先生", phone="13900139000", location="北京市朝阳区",

pet_type="布偶猫", pet_size="小型", special_needs="需每日梳毛"

)

# 2. 发布寄养信息&需求

listing1 = system.post_listing(

sitter=sitter1, start_date="2024-08-01", end_date="2024-08-07"

)

request1 = system.post_request(

owner=owner1, pet_name="雪球", start_date="2024-08-01", end_date="2024-08-07",

budget=100, description="猫咪性格温顺，已绝育"

)

# 3. 智能匹配

matches = system.match_sitter(request1)

if not matches:

print("未找到匹配的寄养人")

return

best_listing, score = matches[0]

print(f"\n找到最佳匹配：{best_listing.sitter.name}，匹配度{score*100}%")

print(f"收费：{best_listing.sitter.price}元/天，空间：{best_listing.sitter.space_desc}")

# 4. 创建匹配（押金200元）

try:

match1 = system.create_match(best_listing, request1, deposit=200)

print(f"\n匹配成功！匹配ID：{match1.match_id}，押金已托管")

except ValueError as e:

print(f"匹配失败：{e}")

return

# 5. 实时监控（寄养期间更新）

system.add_monitor_log(match1, "雪球已适应新环境，进食正常")

system.add_monitor_log(match1, "今日梳毛完成，状态良好")

print("\n监控日志：")

for log in match1.monitor_logs:

print(f"{log[0]}：{log[1]}")

# 6. 完成寄养（模拟成功）

system.complete_match(match1, is_successful=True)

print(f"\n寄养完成，最终状态：{match1.status}")

if __name__ == "__main__":

demo()

系统核心功能说明

1. 双向匹配机制

- 寄养人侧：发布空间描述、收费标准、可寄养日期、接受宠物类型

- 需求侧：提交宠物信息（类型/体型）、寄养时间、预算、特殊需求

- 匹配算法：综合考量时间重叠、地理位置、价格预算、宠物兼容性、寄养人评分，按匹配度排序（示例权重：评分60%+价格40%）

2. 押金担保体系

- 押金规则：至少预付2天费用（防违约）

- 资金托管：系统暂存押金至

"deposit_pool"

- 结算逻辑：寄养成功后全额退还，失败时按比例扣除违约金（示例扣30%）

3. 实时监控功能

- 寄养人可添加图文日志（时间+内容）

- 宠物主人随时查看寄养状态（示例中通过

"add_monitor_log"实现）

4. 扩展能力

- 用户评价：通过

"reviews"列表记录，影响后续匹配评分

- 多宠物支持：

"max_pets"控制寄养容量，

"special_needs"满足个性化需求

- 数据持久化：可添加JSON/SQLite存储（示例中预留

"json"导入）

使用指南

1. 环境准备：Python 3.8+，无需额外安装库

2. 操作流程：

- 注册寄养人/宠物主人

- 发布寄养信息（寄养人）或需求（宠物主人）

- 系统自动匹配并返回推荐列表

- 确认匹配后支付押金，开始寄养

- 寄养期间更新监控日志

- 结束后结算押金，完成评价

技术优势

- 轻量化设计：纯标准库实现，无外部依赖，适合新手部署

- 模块化架构：实体类与业务逻辑分离，便于扩展（如添加支付接口）

- 鲁棒性处理：日期校验、参数合法性检查、异常捕获（如押金不足提示）

- 透明化匹配：返回匹配度分数，帮助用户理解推荐理由

该系统可有效解决宠物主人短期出行时的寄养难题，通过标准化流程和信用保障机制提升双方信任度。如需扩展Web界面，可基于Flask/Django框架对接本核心逻辑。

欢迎关注我，有更多编程干货等着你！