行为型模式(11种):解释器模式、责任链模式、命令模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、访问者模式、模板方法模式
https://www.bilibili.com/video/BV19541167cn?spm_id_from=333.999.0.0
1、责任链模式
- 责任链模式
- 内容:使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系
将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止 - 角色:
- 抽象处理者
- 具体处理者
- 客户端
- 适用场景
- 有多个对象可以处理一个请求,哪个对象处理由运行时决定
- 在不明确接收者的情况下,向多个对象中的一个提交一个请求
- 优点
- 降低耦合度,一个对象无需知道是其他哪一个对象处理其请求
- 内容:使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系
from abc import ABCMeta,abstractmethod
class Handler(metaclass=ABCMeta):
@abstractmethod
def handle_leave(self, day):
pass
class GeneralManager(Handler):
def handle_leave(self, day):
if day <= 10:
print("总经理准假%d天" % day)
else:
print("你辞职吧")
class DepartmentManager(Handler):
def __init__(self):
self.next = GeneralManager()
def handle_leave(self, day):
if day <=5:
print("部门经理准假%d天" % day)
else:
print("部门经理职权不足")
class ProjectManager(Handler):
def __init__(self):
self.next = DepartmentManager()
def handle_leave(self, day):
if day <= 3:
print("项目主管准假%d天" % day)
else:
print("项目主管职权不足")
self.next.handle_leave(day)
day = 4
h = ProjectManager()
h.handle_leave(day)
2、观察者模式
- 观察者模式
- 内容:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知
并被自动更新,观察者模式又称“发布-订阅”模式 - 角色:
- 抽象主题
- 具体主题
- 抽象观察者
- 具体观察者
- 内容:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知
from abc import ABCMeta, abstractmethod
class Observer(metaclass=ABCMeta): # 抽象订阅者
@abstractmethod
def update(self, notice): # notice是一个Notice类的对象
pass
class Notice: # 抽象发布者
def __init__(self):
self.observers = []
def attach(self, obs):
self.observers.append(obs)
def detach(self, obs):
self.observers.reverse(obs)
def notify(self):
for obs in self.observers:
obs.update(self)
class StaffNotice(Notice): # 具体发布者
def __init__(self, company_info=None):
super().__init__()
self.__company_info = company_info
@property
def company_info(self):
return self.__company_info
@company_info.setter
def company_info(self, info):
self.__company_info = info
self.notify() # 推送
class Staff(Observer):
def __init__(self):
self.company_info = None
def update(self, notice):
self.company_info = notice.company_info
# client
notice = StaffNotice("初始公司信息")
s1 = Staff()
s2 = Staff()
notice.attach(s1)
notice.attach(s2)
notice.company_info = "公司。。。号"
print(s1.company_info)
print(s2.company_info)
3、策略者模式
- 策略者模式
- 内容:定义一系列的算法,把他们一个个封装起来,并且使他们可相互替换,本模式使得算法可独立于使用他的客户而变化
- 角色:
- 抽象策略
- 具体策略
- 上下文
from abc import ABCMeta, abstractmethod
class Strategy(metaclass=ABCMeta):
@abstractmethod
def 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.strategy = strategy
self.data = data
def set_strategy(self, strategy):
self.strategy = strategy
def do_strategy(self):
self.strategy.execute(self.data)
# client
data = "[...]"
s1 = FastStrategy()
s2 = SlowStrategy()
context = Context(s1, data)
context.do_strategy()
context.set_strategy(s2)
context.do_strategy()
4、模板方法模式
- 模板方法模式
- 内容:定义一个操作中的算法的骨架,而将一些步骤延迟到子类中,模板方法使得子类可以不改变
一个算法的结构即可重定义该算法的某些特定步骤 - 角色:
- 抽象类:定义抽象的原子操作;实现一个模板方法作为算法的骨架
- 具体类:实现原子操作
- 内容:定义一个操作中的算法的骨架,而将一些步骤延迟到子类中,模板方法使得子类可以不改变
from abc import ABCMeta, abstractmethod
from time import sleep
class Window(metaclass=ABCMeta):
@abstractmethod
def start(self):
pass
@abstractmethod
def repaint(self):
pass
@abstractmethod
def stop(self): # 原子操作/钩子操作
pass
def run(self): # 模板方法
self.start()
while True:
try:
self.repaint()
sleep(1)
except KeyboardInterrupt:
break
self.stop()
class MyWindow(Window):
def __init__(self, msg):
self.msg = msg
def start(self):
print("窗口开始运行")
def stop(self):
print("窗口结束运行")
def repaint(self):
print(self.msg)
MyWindow("Hello...").run()