1. 单例模式（Singleton Pattern）：保证一个类只有一个实例，并提供一个全局的访问点。
2. 工厂模式（Factory Pattern）：定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。
3. 观察者模式（Observer Pattern）：定义对象之间的一对多依赖关系，使得当一个对象的状态发生改变时，所有依赖于它的对象都会被自动通知并更新。
4. 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责，而不会影响到其他对象。
5. 策略模式（Strategy Pattern）：定义一系列的算法，将每个算法封装起来，并使它们可以相互替换。
6. 命令模式（Command Pattern）：将请求封装成一个对象，从而使用户可以用不同的请求对客户进行参数化。
7. 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的类能够一起工作。
8. 外观模式（Facade Pattern）：为子系统中的一组接口提供一个统一的接口，从而使得子系统更加容易使用。
9. 状态模式（State Pattern）：允许一个对象在其内部状态改变时改变其行为。
10. 模板方法模式（Template Method Pattern）：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中实现。
这些是Python中常用的设计模式，通过使用这些设计模式可以提高代码的可读性、可维护性和重用性。
?
观察者模式是一种行为设计模式，它定义了一种一对多的关系，使得当一个对象的状态发生改变时，所有依赖于它的对象都能够得到通知并自动更新。在观察者模式中，有两个主要角色：主题（Subject）和观察者（Observer）。
主题（Subject）： 负责维护一组观察者对象，以及通知它们状态变化的方法。
观察者（Observer）： 定义一个更新接口，以便在主题状态变化时得到通知并进行相应的操作。
第一种模板
import abc
class AbstractSubject(metaclass=abc.ABCMeta):
"""
抽象主题（抽象目标类）:
定义增加、删除观察者的方法
通知观察者的抽象方法
"""
def __init__(self):
self.observers = []
def add(self, observer):
if observer not in self.observers:
self.observers.append(observer)
else:
print("%s observer is exist, add failed" % observer)
def remove(self, observer):
if observer in self.observers:
self.observers.remove(observer)
else:
print("%s observer is not exist, remove failed" % observer)
@abc.abstractmethod
def notify(self):
pass
class Subject(AbstractSubject):
"""具体主题（具体目标类）"""
def __init__(self, name):
super().__init__()
self.name = name
self._data = None
@property
def data(self):
return self._data
@data.setter
def data(self, new_data):
"""当数据更新时，去通知观察者"""
self._data = new_data
self.notify()
def notify(self):
"""通知观察者的具体方法"""
for obs in self.observers:
obs.notify(self._data)
class AbstractObserver(metaclass=abc.ABCMeta):
"""抽象观察者"""
@abc.abstractmethod
def notify(self, data, *args, **kwargs):
pass
class Observer1(AbstractObserver):
"""具体观察者-1"""
def notify(self, data, *args, **kwargs):
print("发布的消息是：%s" % data)
class Observer2(AbstractObserver):
"""具体观察者-2"""
def notify(self, data, *args, **kwargs):
print("发布的消息是：%s" % data)
# 具体主题(消息发布者)
sub = Subject("ming")
# 具体观察者
obs1 = Observer1()
obs2 = Observer2()
# 添加观察者
sub.add(obs1)
sub.add(obs2)
# 发布消息后，观察者得到消息
sub.data = "号外号外！"第二种模板?
# 主题
class Subject:
def __init__(self):
self._observers = []
def add_observer(self, observer):
if observer not in self._observers:
self._observers.append(observer)
def remove_observer(self, observer):
self._observers.remove(observer)
def notify_observers(self, message):
for observer in self._observers:
observer.update(message)
# 观察者
class Observer:
def update(self, message):
pass
# 具体观察者
class ConcreteObserver(Observer):
def update(self, message):
print(f"Received message: {message}")
# 使用观察者模式
subject = Subject()
observer1 = ConcreteObserver()
observer2 = ConcreteObserver()
subject.add_observer(observer1)
subject.add_observer(observer2)
subject.notify_observers("Hello, observers!")
它实现了松耦合，主题和观察者相互独立，可以轻松添加或删除观察者，而不会影响到主题或其他观察者。这使得代码更加灵活、可维护。
参考链接