Python常见设计模式3: 行为型模式

责任链模式

• 内容：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
• 角色
  • 抽象处理者（Handler）
  • 具体处理者（ConcreteHandler）
  • 客户端（Client）

from abc import ABCMeta, abstractmethodclass Handler(metaclass=ABCMeta):@abstractmethoddef handle_leave(self,day):passclass GeneralManager(Handler):def handle_leave(self,day):if day > 10:print("GM: You are fired")else:print("GM: OK, enjoy yourself for %d days"% day)class ProjectManager(Handler):def __init__(self):self.next=Nonedef setNext(self,handler):self.next=handlerdef handle_leave(self, day):if day <= 5:print("PM: OK, enjoy yourself for %d days"% day)else:print("PM: I can't decide")self.next.handle_leave(day)class DirectManager(Handler):def __init__(self):self.next=Nonedef setNext(self,handler):self.next=handlerdef handle_leave(self, day):if day <= 1:print("DM: OK, enjoy yourself for %d days"% day)else:print("DM: I can't decide")self.next.handle_leave(day)dm=DirectManager()
pm=ProjectManager()
gm=GeneralManager()dm.setNext(pm)
pm.setNext(gm)dm.handle_leave(8)

观察者模式

• 内容：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。观察者模式又称“发布-订阅”模式
• 角色：
  • 抽象主题（Subject）
  • 具体主题（ConcreteSubject）——发布者
  • 抽象观察者（Observer）
  • 具体观察者（Concretebserver）——订阅者

from abc import abstractmethod, ABCMetaclass Subscriber(metaclass=ABCMeta):@abstractmethoddef update(self, publisher):passclass Publisher:def __init__(self):self.subscriber=[]def addSubscriber(self, sub):self.subscriber.append(sub)def removeSubscriber(self,sub):self.subscriber.remove(sub)def notify(self):for sub in self.subscriber:sub.update(self)class StaffPublisher(Publisher):def __init__(self, company_info=None):super().__init__()self.__company_info=company_info@propertydef company_info(self):return self.__company_info@company_info.setterdef company_info(self,info):self.__company_info=infoself.notify()class StaffSubcriber(Subscriber):def __init__(self):self.company_info=Nonedef update(self, publisher):self.company_info=publisher.company_infoprint("update val as: %s"% self.company_info)staffPub=StaffPublisher("initial info")
print("---------initial------------")
print(staffPub.company_info)
staffSub=StaffSubcriber()
staffPub.addSubscriber(staffSub)
print("---------change info----------")
staffPub.company_info="go to work"
staffPub.company_info="you are good"
staffPub.company_info="but i will fire you"

策略模式

• 内容：定义一系列的算法，把他们一个个封装起来，并且使他们可以相互替换。本模式使得算法可以独立于使用他的客户而变化。
• 角色：
  • 抽象策略（Strategy）
  • 具体策略（ConcreteStrategy）
  • 上下文（Context）

from abc import ABCMeta, abstractmethod# 抽象策略类
class Strategy(metaclass=ABCMeta):@abstractmethoddef execute(self, data):pass# 具体策略类：快速策略
class FastStrategy(Strategy):def execute(self, data):print("用较快的策略处理%s", data)# 具体策略类：慢速策略
class SlowStrategy(Strategy):def execute(self, data):print("用较慢的策略处理%s", data)# 上下文类，用于管理策略
class Context:def __init__(self, strategy, data):self.data = dataself.strategy = strategydef set_strategy(self, strategy):self.strategy = strategydef do_strategy(self):self.strategy.execute(self.data)# 客户端调用逻辑
if __name__ == "__main__":data = "[...]"  s1 = FastStrategy()  s2 = SlowStrategy()  # 初始化上下文并执行快速策略context = Context(s1, data)context.do_strategy()# 切换策略为慢速策略并执行context.set_strategy(s2)context.do_strategy()

模板模式

• 内容：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
• 角色
  • 抽象类（AbstractClass）：定义抽象的原子操作（钩子操作）；实现一个模板方法作为算法的骨架。
  • 具体类（ConcreteClass）：实现原子操作 。

from abc import ABCMeta, abstractmethod
from time import sleep, timeclass Window(metaclass=ABCMeta):@abstractmethoddef start(self):pass@abstractmethoddef repaint(self):pass@abstractmethoddef stop(self):passdef run(self, duration=10):  # 新增参数，控制运行时长，默认10秒self.start()start_time = time()  # 记录开始时间while True:# 检查是否已超过指定运行时间if time() - start_time >= duration:break  # 超过时间则退出循环self.repaint()sleep(1)self.stop()  # 时间到后执行停止操作class MyWindow(Window):def __init__(self, msg):self.msg = msgdef start(self):print("窗口开始运行")def stop(self):print("窗口结束运行")def repaint(self):print(f"Hello...")if __name__ == "__main__":win = MyWindow("Hello")win.run(3)  # 运行，默认10秒后关闭# 可通过参数调整时长，例如：win.run(3) 表示3秒后关闭