模板方法模式

"""案例：写简历内容：最近有个招聘会，可以带上简历去应聘了。但是，其中有一家公司不接受简历，而是给应聘者发了两张公司自己定制的简历表，分别是A类型的简历表和B类型的简历表这两张表上面都有差不多的内容：基本信息、教育背景、工作经历，让应聘者选择其中一种类型的简历表，按照要求填写完整。每个人拿到这份表格后，就开始填写。如果用程序实现这个过程，该如何做呢？一种方案就是用模板方法模式：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
"""from abc import ABC, abstractmethod# 简历表（抽象类）
class ResumeTable(ABC):@abstractmethoddef _write_basic_info(self):  # 写基本信息（抽象）pass@abstractmethoddef _write_education(self):  # 写教育背景（抽象）pass@abstractmethoddef _write_work_experience(self):  # 写工作经历（抽象）pass# 填写简历的全过程（模板）def fill_resume(self):self._write_basic_info()  # 先写基本信息self._write_education()  # 再写教育背景self._write_work_experience()  # 然后写工作经历# A类型的简历表
class ResumeTableA(ResumeTable):def _write_basic_info(self):print("简历A: 基本信息, ", end="")def _write_education(self):print("教育背景, ", end="")def _write_work_experience(self):print("工作经验 (越简单越好).")# B类型的简历表
class ResumeTableB(ResumeTable):def _write_basic_info(self):print("简历B: 基本信息, ", end="")def _write_education(self):print("教育背景, ", end="")def _write_work_experience(self):print("工作经验 (越详细越好).")if __name__ == '__main__':# 填写类型A的简历表a = ResumeTableA()a.fill_resume()# 填写类型B的简历表b = ResumeTableB()b.fill_resume()

命令模式

"""案例：客人点餐1. 客人发出命令，让厨师做饭2. 客人发出命令，让厨师取消做饭3. 客人发出命令，让厨师煮面4. 客人发出命令，让厨师取消煮面
"""from abc import ABC, abstractmethod# 厨师（具体类）
class Chef:  # 厨师有以下四种能力# 做饭def make_meals(self):print("做饭")# 取消做饭def cancel_meals(self):print("取消做饭")# 煮面def make_noodles(self):print("煮面")# 取消煮面def cancel_noodles(self):print("取消煮面")# 命令（抽象类）
class Command(ABC):def __init__(self):self.__chef = None  # 存放（维护）一个厨师对象@abstractmethoddef execute_command(self):  # 执行命令（抽象）pass@abstractmethoddef cancel_command(self):  # 取消执行命令（抽象）pass# 关于做饭的命令（具体类）
class AboutMealsCommand(Command):def __init__(self, chef: Chef):super().__init__()self.__chef = chefdef execute_command(self):print("快点去给我", end="")self.__chef.make_meals()def cancel_command(self):print("我不要了，", end="")self.__chef.cancel_meals()# 关于煮面的命令（具体类）
class AboutNoodlesCommand(Command):def __init__(self, chef: Chef):super().__init__()self.__chef = chefdef execute_command(self):print("快点去给我", end="")self.__chef.make_noodles()def cancel_command(self):print("我不要了，", end="")self.__chef.cancel_noodles()# 客人（具体类）
class Customer:# 客人想一些命令def think_command(self, command: Command):self.__command = command# 客人说话（发出命令），说想要吃def speak_to_eat(self):self.__command.execute_command()# 客人说话（发出命令），说不想吃了def speak_to_cancel(self):self.__command.cancel_command()if __name__ == '__main__':# 招聘一个厨师chef = Chef()# 与厨师约定好"做饭"和"煮面"相关的命令about_meals_command = AboutMealsCommand(chef)about_noodles_command = AboutNoodlesCommand(chef)# 来了一位顾客customer = Customer()# 顾客思考一些关于煮饭的命令customer.think_command(about_meals_command)# 思考完毕，下达命令customer.speak_to_eat()  # 说自己想吃（饭）customer.speak_to_cancel()  # 说自己不想吃（饭）了# 顾客思考一些关于煮面的命令customer.think_command(about_noodles_command)# 思考完毕，下达命令customer.speak_to_eat()  # 说自己想吃（面）"""
运行结果：快点去给我做饭我不要了，取消做饭快点去给我煮面
"""

责任链模式

"""案例：员工请假内容：当员工申请请假1天以内，由组长批准即可（处理者为组长）当员工申请请假超过3天，需要由经理批准（处理者为经理）当员工申请请假超过7天，需要由老板批准（处理者为老板）
"""from abc import ABC, abstractmethod# 处理者（抽象类）
class Handler(ABC):def __init__(self):self._next_handler = None  # 用于存放下一个处理者# 设置下一个处理者是谁def set_next_handler(self, next_handler):self._next_handler = next_handler# 处理请求（先尝试自己的处理，如果处理不了，会将请求交给下一个处理者进行处理）@abstractmethoddef handle_request(self, days):pass# 组长（具体类）
class GroupLeader(Handler):def handle_request(self, days: int):print("组长：", end="")if days <= 3:print("同意请假！")else:print("请假太久了，你去找经理请假。")if self._next_handler:self._next_handler.handle_request(days)# 经理（具体类）
class Manager(Handler):def handle_request(self, days: int):print("经理：", end="")if days <= 7:print("同意请假！")else:print("请假太久了，你去找老板请假。")if self._next_handler:self._next_handler.handle_request(days)# 老板（具体类）
class Boss(Handler):def handle_request(self, days: int):print("老板：", end="")if days <= 10:print("同意请假！")else:print("请假太久了，不同意请假")if self._next_handler:self._next_handler.handle_request(days)if __name__ == '__main__':# 实例化一个组长、一个经理、一个老板group_leader = GroupLeader()manager = Manager()boss = Boss()# 组装链group_leader.set_next_handler(manager)manager.set_next_handler(boss)# -------------------- 请假 --------------------day = 3print(f"我：想要请假{day}天")group_leader.handle_request(day)print("-----------------------")day = 7print(f"我：想要请假{day}天")group_leader.handle_request(day)print("-----------------------")day = 10print(f"我：想要请假{day}天")group_leader.handle_request(day)print("-----------------------")day = 30print(f"我：想要请假{day}天")group_leader.handle_request(day)print("-----------------------")

策略模式

from abc import ABC, abstractmethod# 策略（抽象类）
class Strategy(ABC):@abstractmethoddef execute(self, left: int, right: int):  # 执行策略pass# 加法策略（具体类）
class AddStrategy(Strategy):def execute(self, left: int, right: int):return left + right# 减法策略（具体类）
class SubStrategy(Strategy):def execute(self, left: int, right: int):return left - right# 乘法策略（具体类）
class MulStrategy(Strategy):def execute(self, left: int, right: int):return left * right# 除法策略（具体类）
class DivStrategy(Strategy):def execute(self, left: int, right: int):if right == 0:raise "除数不能为零！"return left / right# 策略容器（具体类）
class Container:def __init__(self):self.__strategy = None  # 用来保存（维护）一个策略对象# 设置策略def set_strategy(self, strategy: Strategy):self.__strategy = strategy# 执行某策略的功能def execute_strategy(self, left: int, right: int):return self.__strategy.execute(left, right)if __name__ == '__main__':# 实例化一个策略容器container = Container()# 符号处理的前期准备symbol_list = ("+", "-", "*", "/")  # 符号列表index = 0  # 符号所在位置的索引（下标）while True:# 获取用户输入expression = input("(Count) >>> ")# 解析用户输入# 1.符号处理（获取符号索引位置）for symbol in symbol_list:if symbol in expression:  # 如果当前符号在表达式里面index = expression.index(symbol)  # 记录符号在表达式中的索引位置break# 2.获取左右值（例如 5 + 7 中的左值为5，右值为7）left = int(expression[0: index: 1].strip())right = int(expression[index + 1: len(expression): 1].strip())# 3.根据用户选择，向策略容器里面添加合适的策略match expression[index]:case "+":container.set_strategy(AddStrategy())  # 实例化一个策略，并添加到策略容器中case "-":container.set_strategy(SubStrategy())  # 实例化一个策略，并添加到策略容器中case "*":container.set_strategy(MulStrategy())  # 实例化一个策略，并添加到策略容器中case "/":container.set_strategy(DivStrategy())  # 实例化一个策略，并添加到策略容器中case _:raise "符号错误！"# 4.执行策略容器里面的策略print(container.execute_strategy(left, right))

观察者模式

"""
案例：员工摸鱼
通过老板的动作信息（是否出现在公司），员工做出不同的反应（摸鱼或努力工作）
"""from abc import ABC, abstractmethod# 实现一个员工类（具体类）
class Employee:def __init__(self, name):self.__name = name  # 存放员工自己的姓名# 结合来自外部的通知信息，更新员工自己的工作状态（摸鱼或认真工作）def update(self, info):print(f"{self.__name}收到情报：{info}，", end="")if info == "老板来了":print("开启工作模式。")elif info == "老板走了":print("开启摸鱼模式。")# 实现一个老板类（具体类）
class Boss:def __init__(self):self.__employee_list = []  # 存放老板手下的员工对象self.__action_plan = ""  # 存放老板的行动计划# 老板招聘员工def add_employee(self, employee: Employee):self.__employee_list.append(employee)# 老板设置自己的行动计划def set_action_plan(self, plan):self.__action_plan = planself._notify(plan)  # 泄密# 发出通知def _notify(self, plan):# 根据老板的计划，设置泄密信息的内容info = ""if plan == "去巡查一下他们有没有好好工作":info = "老板来了"elif plan == "坐飞机出个差":info = "老板走了"# 通知每个员工for employee in self.__employee_list:employee.update(info)if __name__ == '__main__':# 实例化一个老板（被观察者）boss = Boss()# 实例化一些员工（观察者）emp_1 = Employee("小明")emp_2 = Employee("老张")emp_3 = Employee("老李")# 老板去招聘上面这些员工（建立关联）boss.add_employee(emp_1)boss.add_employee(emp_2)boss.add_employee(emp_3)# 老板设置行动计划boss.set_action_plan("去巡查一下他们有没有好好工作")print("-----------")boss.set_action_plan("坐飞机出个差")print("-----------")

访问者模式

"""案例：这里实现一个不同职业的人去医院和餐厅的例子来说明访问者模式在小镇上有一个医院和一个餐厅，每天都会有不同的人访问这两个地方，由于访问者不同到这两个地方要做的事也有区别。医生去医院是为了工作给病人看病，厨师去医院是为了检查身体，医生去餐厅是为了吃饭，厨师去餐厅是为了工作给客人烹饪菜肴。
"""from abc import ABC, abstractmethod# 地方（抽象类）
class Place(ABC):def __init__(self, name: str):self._place_name = name  # 维护（存放）一个地方名字@propertydef name(self):return self._place_name@abstractmethoddef accept(self, visitor):  # 接待访问者的功能（抽象）pass# 医院（具体类）
class Hospital(Place):# 接待访问者的功能（实现）def accept(self, visitor):if visitor.__class__ is Doctor:print(f"医院热情的接待他，因为他能帮助医院救人！")elif visitor.__class__ is Chef:print("医院快速的接待他，因为他来看病！")# 餐馆（具体类）
class Restaurant(Place):# 接待访问者的功能（实现）def accept(self, visitor):if visitor.__class__ is Doctor:print(f"餐厅热情的接待他，因为他是顾客！")elif visitor.__class__ is Chef:print("餐厅快速的接待他，因为他要炒菜！")# 访问者（抽象类）
class Visitor(ABC):@abstractmethoddef visit(self, place):  # 访问一个地方（抽象）pass# 医生（具体类）
class Doctor(Visitor):# 访问一个地方的能力def visit(self, place):print(f"医生尝试访问{place.name}，", end="")place.accept(self)  # 这个地方是否接收当前对象的访问# 厨师（具体类）
class Chef(Visitor):# 访问一个地方的能力def visit(self, place):print(f"厨师尝试访问{place.name}，", end="")place.accept(self)  # 这个地方是否接收当前对象的访问if __name__ == '__main__':# 实例化一个医院hospital = Hospital("蟒蛇市第一人民医院")# 实例化一个餐馆restaurant = Restaurant("幸福餐馆")# 实例化一个医生（访问者）doctor = Doctor()# 实例化一个厨师（访问者）chef = Chef()# ------------------ 访问 ------------------doctor.visit(hospital)  # 医生访问医院doctor.visit(restaurant)  # 医生访问餐馆chef.visit(hospital)  # 厨师访问医院chef.visit(restaurant)  # 厨师访问餐馆"""
运行结果：医生尝试访问蟒蛇市第一人民医院，医院热情的接待他，因为他能帮助医院救人！医生尝试访问幸福餐馆，餐厅热情的接待他，因为他是顾客！厨师尝试访问蟒蛇市第一人民医院，医院快速的接待他，因为他来看病！厨师尝试访问幸福餐馆，餐厅快速的接待他，因为他要炒菜！
"""

中介者模式

from abc import ABC, abstractmethod# 中介者（抽象类）
class Mediator(ABC):def __init__(self):self._hr = Noneself._student = Nonedef set_hr(self, hr):self._hr = hrdef set_student(self, student):self._student = student@abstractmethoddef match(self):pass# 角色（抽象类）
class Role(ABC):def __init__(self, name: str, offer: str, mediator: Mediator):self._name = nameself._offer = offerself._mediator = mediator@propertydef name(self):return self._name@propertydef offer(self):return self._offer@abstractmethoddef match(self, role):  # 和哪个人进行匹配？pass# 学生（具体类）
class Student(Role):def match(self, role):self._mediator.set_student(self)  # 在"中介"里面，设置好自己的学生信息self._mediator.set_hr(role)  # 在"中介"里面，设置好自己想要应聘的HRself._mediator.match()  # 设置完毕后，运行"中介"的匹配功能# 人事HR（具体类）
class HR(Role):def match(self, role):self._mediator.set_hr(self)  # 在"中介"里面，设置好自己的HR信息self._mediator.set_student(role)  # 在"中介"里面，设置好自己想要招聘的学生self._mediator.match()  # 设置完毕后，运行"中介"的匹配功能# 猎聘App（具体类）
class LiePinApp(Mediator):def match(self):print("--------------- 欢迎使用猎聘App ---------------")print(f"HR：{self._hr.name}\t|\t想要招聘：{self._hr.offer}")print(f"学生：{self._student.name}\t|\t想要应聘：{self._student.offer}")if self._hr.offer == self._student.offer:print(">>> 配对成功")else:print(">>> 配对失败")print("---------------------------------------------", end="\n\n")if __name__ == '__main__':# 实例化一个中介 ———— 猎聘Appapp = LiePinApp()# 实例化一个HRhr = HR("花儿姐", "软件工程师", app)# 实例化两个学生stu_1 = Student("小明", "软件工程师", app)stu_2 = Student("小王", "硬件工程师", app)# HR 通过 app 尝试匹配 stu_1hr.match(stu_1)hr.match(stu_2)

备忘录模式

"""备忘录模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。案例：比如我们打游戏时分，如果在打大BOSS之前存档，此时就需要将对应的游戏场景，任务信息，人物信息等等状态存储起来；当赢得大BOSS之后，覆盖之前的存档时，就将之前的存档丢弃，新建立一个存档，保存当前的状态信息；如果打输了，恢复存档，就将之前的存档信息读取出来，还原到打大BOSS之前的游戏场景，重新开始打大BOSS。这里面就是使用的备忘录模式。一个备忘录是一个对象，它存储另一个对象在某个瞬间的内部状态，而后者称为备忘录的原发器。当需要设置原发器的检查点时，取消操作机制会向原发器请求一个备忘录。原发器用描述当前状态的信息初始化该备忘录。只有原发器可以向备忘录中存取信息，备忘录中的信息对其他的对象是“不可见”的。
"""
from abc import ABC, abstractmethod# 备忘录（具体类）
class Memorandum:def __init__(self, blood, attack, defense):self.__blood = bloodself.__attack = attackself.__defense = defense@propertydef blood(self):return self.__blood@propertydef attack(self):return self.__attack@propertydef defense(self):return self.__defense# 原发器：记录当前时刻的内部状态
class GameRole:# 创建游戏角色时，默认的血量def __init__(self, ):self.__blood = 100self.__attack = 100self.__defense = 100# 展示游戏角色的状态def show_state(self):print(f"当前角色：[生命力：{self.__blood}] [攻击力：{self.__attack}] [防御力：{self.__defense}]")# 让游戏角色进行战斗def fight(self):self.__blood -= 40self.__attack -= 16self.__defense -= 32print("遭受敌人攻击！生命力-40，攻击力-16，防御力-32...")if self.__blood <= 0:print("您已阵亡！")# 存档：保存当前的数据到备忘录对象中def save_state(self):print("存档成功！")return Memorandum(self.__blood, self.__attack, self.__defense)# 恢复存档：从备忘录对象里面获取所需的数据def recovery_state(self, memorandum: Memorandum):self.__blood = memorandum.bloodself.__attack = memorandum.attackself.__defense = memorandum.defenseprint("恢复存档成功")if __name__ == '__main__':# 创建一个游戏角色role = GameRole()# 查看当前"游戏角色"的状态role.show_state()# 玩游戏（去战斗）role.fight()# 存档record = role.save_state()# 继续玩游戏（去战斗）role.fight()role.fight()# 挑战Boss失败，就读档，恢复原来的状态role.recovery_state(record)# 继续玩游戏（去战斗）role.fight()

状态模式

from abc import ABC, abstractmethod# 状态（抽象类）
class State(ABC):@abstractmethoddef handle(self):pass# "None"状态类（具体类）
class NoneState(State):def handle(self):return "没有上下文..."# "Exist"状态类（具体类）
class ExistState(State):def handle(self):return "存在上下文..."# 上下文（具体类）
class Context:def __init__(self, state: State):self.__state = state  # 存放一个状态对象# 请求上下文def request(self):if self.__state:print(f"内容：[{self.__state.handle()}]")# 改变状态def change_state(self, new_state):self.__state = new_stateif __name__ == '__main__':# 实例化两种状态none_state = NoneState()exist_state = ExistState()# 实例化一个上下文context = Context(none_state)# 请求内容context.request()# 切换为 noneState 状态后，再次请求内容context.change_state(exist_state)context.request()

迭代器模式

from abc import ABC, abstractmethod# 简单迭代器（具体类）
class SimpleIterator:# 初始化操作def __init__(self, lst):self.__lst = lst  # 记录要被迭代的列表self.__index = 0  # 记录当前迭代位置的索引(下标)，初始化时，设置为0# 重新定义 __iter__ ，防止用官方的 __iter__ 污染了自己要实现的迭代器def __iter__(self):return self# 重新定义 __next__，实现自定义功能def __next__(self):if self.__index < len(self.__lst):  # 索引（下标）合法element = self.__lst[self.__index]self.__index += 1return elementelse:  # 索引（下标）不合法raise StopIterationif __name__ == '__main__':my_list = [5, 4, 3, 2, 1]my_iter = SimpleIterator(my_list)try:while True:print(next(my_iter))except StopIteration:pass

解释器模式

"""实现原理：原材料：1.表达式(计算规则)：	a@b#c	（需要解释成a+b-c的运算过程和结果）2.数据对应关系(变量)：var_map = {"a": 30,"b": 20,"c": 25}产品：a@b#c ==》 变量解释器1 @ 变量解释器2 # 变量解释器3==》 栈 【 => 变量解释器1 => 变量解释器2 => 变量解释器3 => 】 与 【=> @符号对象 => #符号对象】
"""from abc import ABC, abstractmethod# 解释器（抽象类）
class Interpreter(ABC):@abstractmethoddef parse(self, var_map: dict):  # 执行解析pass# 变量解释器（具体类）
# 一个变量解释器对象只能解释一个变量字符
class VarInterpreter(Interpreter):def __init__(self, var: str):self.__var = var  # 用来记录待解析的变量字符def parse(self, var_map: dict) -> int:  # 函数返回值 int 类型return var_map[self.__var]# 运算符解释器
# 1.抽象父类
class SymbolInterpreter(Interpreter):def __init__(self, left: VarInterpreter, right: VarInterpreter):self._left = left  # 用来记录"变量解释器对象"self._right = right  # 用来记录"变量解释器对象"@propertydef left(self):  # 提供接口，让外界可以读取return self._left@propertydef right(self):  # 提供接口，让外界可以读取return self._right@abstractmethoddef parse(self, var_map: dict):pass# 2.具体子类
# 2.1 加法解释器（具体类）
class AddInterpreter(SymbolInterpreter):def parse(self, var_map: dict) -> int:return self._left.parse(var_map) + self._right.parse(var_map)# 2.2 减法解释器（具体类）
class SubInterpreter(SymbolInterpreter):def parse(self, var_map: dict) -> int:return self._left.parse(var_map) - self._right.parse(var_map)# 封装一个解析者类，统一调用上面的接口
class Parser:def __init__(self, expression: str):self.__final_interpreter = None  # 存放（维护）一个最终解释器对象interpreter_stack = []  # 自定义栈，用来临时存放"解释器对象"的栈# 解析字符串 a@b#ci = 0while i < len(expression):# ---------------- 循环要做的事情 -----------------match expression[i]:case "@":  # 匹配到+这个符号，执行加法解释# 从栈顶中读取解释器对象left = interpreter_stack.pop()# 从文法字符串中，构建解释器对象right = VarInterpreter(expression[i + 1])# 传入解释器对象，构建新的解释器对象，将其存入栈中interpreter_stack.append(AddInterpreter(left, right))# 因为 right 那里是提前构建了对象，所有我们需要跳过下一字符的匹配i += 1case "#":  # 匹配到-这个符号，执行减法解释# 从栈中取出解释器对象left = interpreter_stack.pop()# 从文法字符串中，构建解释器对象right = VarInterpreter(expression[i + 1])# 传入解释器对象，构建新的解释器对象，将其存入栈中interpreter_stack.append(SubInterpreter(left, right))# 因为 right 那里是提前构建了对象，所有我们需要跳过下一字符的匹配i += 1case _:interpreter_stack.append(VarInterpreter(expression[i]))# ---------------- 循环要做的事情 -----------------i += 1  # 循环自增# 保存最终解释对象if interpreter_stack:  # 如果栈不为空self.__final_interpreter = interpreter_stack.pop()  # 栈顶中保存的就是最终语法树的根# 执行解析def execute(self, var_map: dict) -> int:# self.__final_interpreter.parse(var_map) 的调用过程有点类似于递归，可以自己画图分析# 解析结果：res = -1 if (self.__final_interpreter is None) else self.__final_interpreter.parse(var_map)return resif __name__ == '__main__':#  要解析的表达式expression = "a@b#c"# 符号与数据之间的映射关系————变量————法则var_map = {"a": 30,"b": 20,"c": 25}# 实例化一个解析者，解析上面的表达式parser = Parser(expression)# 执行解释res = parser.execute(var_map)  # 30@20#25 == 30+20-25 == 25print(res)