经典Python常用设计模式总结详细举例

经典Python设计模式是指在Python编程中广泛应用的一系列软件设计模式，这些模式是针对在特定上下文中反复出现的设计问题而提出的可重用解决方案。设计模式并非Python语言特有的，而是源自软件工程领域的普遍实践，但它们可以通过Python语言的特性以优雅且高效的方式实现。以下是一些在Python中常见的经典设计模式：

1. 单例模式（Singleton）

○ 确保一个类只有一个实例，并提供一个全局访问点。在Python中，可以使用模块级别的变量、__new__方法重写或者借助元类来实现。

class Singleton:
    _instance = None

    @classmethod
    def get_instance(cls):
        if not cls._instance:
            cls._instance = cls()
        return cls._instance

    def __init__(self):
        if Singleton._instance is not None:
            raise Exception("This class is a singleton!")
        # 初始化逻辑...使用
singleton_obj = Singleton.get_instance()

在这个例子中，Singleton类通过get_instance类方法确保只创建一个实例。初次调用时会创建并保存实例，后续调用则直接返回已存在的实例。构造函数被保护起来，防止外部直接实例化。

2. 工厂方法模式（Factory Method）

○ 定义一个用于创建对象的接口，让子类决定实例化哪一个类。Python中的抽象基类（Abstract Base Classes, ABCs）和工厂函数可以帮助实现这一模式。

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

class Cat(Animal):
    def make_sound(self):
        return "Meow!"

class AnimalFactory:
    @staticmethod
    def create_animal(animal_type):
        if animal_type == 'dog':
            return Dog()
        elif animal_type == 'cat':
            return Cat()
        else:
            raise ValueError(f"Unknown animal type: {animal_type}")

# 使用
factory = AnimalFactory()
dog = factory.create_animal('dog')
print(dog.make_sound())  # 输出: Woof!

这里，AnimalFactory提供了一个静态方法create_animal，根据传入的类型字符串返回对应的动物实例。实际的动物类（如Dog和Cat）实现了抽象基类Animal的接口，确保了它们具有make_sound方法。

3. 装饰器模式（Decorator）

○ 动态地给对象添加额外职责。Python中的函数装饰器和类装饰器机制为实现这一模式提供了直接支持。

class Coffee:
    def __init__(self, description, cost):
        self.description = description
        self.cost = cost

    def get_cost(self):
        return self.cost

class CoffeeDecorator(Coffee):
    def __init__(self, coffee):
        self.coffee = coffee

    def get_cost(self):
        return self.coffee.get_cost()

class Milk(CoffeeDecorator):
    def __init__(self, coffee):
        super().__init__(coffee)
        self.description = coffee.description + ', with milk'
        self.cost += 0.5

class Mocha(CoffeeDecorator):
    def __init__(self, coffee):
        super().__init__(coffee)
        self.description = coffee.description + ', with mocha'
        self.cost += 1.0

# 使用
base_coffee = Coffee('Espresso', 2.0)
decorated_coffee = Mocha(Milk(base_coffee))

print(decorated_coffee.description)  # 输出: Espresso, with milk, with mocha
print(decorated_coffee.get_cost())   # 输出: 3.5

在这个例子中，CoffeeDecorator作为基类，Milk和Mocha类分别实现了给咖啡添加牛奶和摩卡的装饰。装饰后的咖啡不仅成本增加，描述也相应变化。通过嵌套装饰器，可以灵活地组合不同的配料。

4. 观察者模式（Observer）

import abc
from typing import List

class Subject(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def register_observer(self, observer: 'Observer'):
        pass

    @abc.abstractmethod
    def remove_observer(self, observer: 'Observer'):
        pass

    @abc.abstractmethod
    def notify_observers(self):
        pass

class Observer(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def update(self, temperature: float, humidity: float):
        pass

class WeatherData(Subject):
    def __init__(self):
        self._observers: List[Observer] = []
        self._temperature = 0.0
        self._humidity = 0.0

    def register_observer(self, observer: Observer):
        self._observers.append(observer)

    def remove_observer(self, observer: Observer):
        self._observers.remove(observer)

    def notify_observers(self):
        for observer in self._observers:
            observer.update(self._temperature, self._humidity)

    def measurements_changed(self, temperature: float, humidity: float):
        self._temperature = temperature
        self._humidity = humidity
        self.notify_observers()

class DisplayElement(Observer):
    @abc.abstractmethod
    def display(self):
        pass

class CurrentConditionsDisplay(DisplayElement):
    def __init__(self, weather_data: WeatherData):
        self._weather_data = weather_data
        self._temperature = 0.0
        self._humidity = 0.0
        self._weather_data.register_observer(self)

    def update(self, temperature: float, humidity: float):
        self._temperature = temperature
        self._humidity = humidity
        self.display()

    def display(self):
        print(f"Current conditions: {self._temperature}°F, {self._humidity}% humidity")

# 使用
weather_data = WeatherData()
current_display = CurrentConditionsDisplay(weather_data)
weather_data.measurements_changed(80.0, 65.0)  # 输出: Current conditions: 80.0°F, 65.0% humidity

在这个例子中，WeatherData作为被观察的主题，维护了一组观察者（Observer）。当气象数据发生变化时，它通过notify_observers方法通知所有注册的观察者。CurrentConditionsDisplay实现了观察者的接口，当接收到更新时，会在屏幕上显示当前的温度和湿度。

5.抽象工厂模式（Abstract Factory）

抽象工厂模式是一种创建型设计模式，它为创建一组相关或相互依赖的对象提供了一个接口，而无需指定它们的具体类。这样，客户端代码只需与抽象工厂接口交互，就可以获得所需产品家族的实例，而不必关心具体产品的创建细节。下面是一个在Python中实现抽象工厂模式的例子：

from abc import ABC, abstractmethod

# 定义抽象产品接口
class AbstractProductA(ABC):
    @abstractmethod
    def feature(self):
        pass

class AbstractProductB(ABC):
    @abstractmethod
    def feature(self):
        pass

# 定义具体产品（产品A系列）
class ConcreteProductA1(AbstractProductA):
    def feature(self):
        return "ConcreteProductA1's feature"

class ConcreteProductA2(AbstractProductA):
    def feature(self):
        return "ConcreteProductA2's feature"

# 定义具体产品（产品B系列）
class ConcreteProductB1(AbstractProductB):
    def feature(self):
        return "ConcreteProductB1's feature"

class ConcreteProductB2(AbstractProductB):
    def feature(self):
        return "ConcreteProductB2's feature"

# 定义抽象工厂接口
class AbstractFactory(ABC):
    @abstractmethod
    def create_product_a(self) -> AbstractProductA:
        pass

    @abstractmethod
    def create_product_b(self) -> AbstractProductB:
        pass

# 定义具体工厂（产品家族1）
class ConcreteFactory1(AbstractFactory):
    def create_product_a(self) -> AbstractProductA:
        return ConcreteProductA1()

    def create_product_b(self) -> AbstractProductB:
        return ConcreteProductB1()

# 定义具体工厂（产品家族2）
class ConcreteFactory2(AbstractFactory):
    def create_product_a(self) -> AbstractProductA:
        return ConcreteProductA2()

    def create_product_b(self) -> AbstractProductB:
        return ConcreteProductB2()

# 客户端代码
def client_code(factory: AbstractFactory):
    product_a = factory.create_product_a()
    product_b = factory.create_product_b()

    print(f"Product A's feature: {product_a.feature()}")
    print(f"Product B's feature: {product_b.feature()}")

if __name__ == "__main__":
    print("Client: Testing with Factory 1:")
    client_code(ConcreteFactory1())

    print("\nClient: Testing with Factory 2:")
    client_code(ConcreteFactory2())

在这个例子中：

● AbstractProductA和AbstractProductB是两个抽象产品接口，定义了产品A系列和产品B系列共有的特征方法。
● ConcreteProductA1、ConcreteProductA2、ConcreteProductB1和ConcreteProductB2是具体产品类，分别实现了抽象产品接口，代表了不同版本的产品。
● AbstractFactory是抽象工厂接口，定义了创建产品A和产品B的方法。
● ConcreteFactory1和ConcreteFactory2是具体工厂类，实现了抽象工厂接口，分别对应于两个不同产品家族的创建逻辑。
● client_code函数作为客户端代码，它接受一个抽象工厂实例，通过调用其create_product_a和create_product_b方法来获取产品实例，然后使用这些产品实例进行后续操作。客户端并不关心具体的产品或工厂实现，只与抽象接口交互。

运行上述代码，将看到客户端代码使用不同的具体工厂创建了不同产品家族的实例，并展示了它们各自的功能。这正是抽象工厂模式的作用：隔离了具体产品类的创建细节，使客户端能够以统一的方式处理不同的产品家族。

6.原型模式（Prototype）

原型模式是一种创建型设计模式，它通过复制现有的对象（即原型）来创建新对象，而不是每次都从头创建。这种模式在需要快速创建大量相似对象、避免重复初始化或对象创建成本较高时特别有用。在Python中，可以利用对象的复制或克隆功能实现原型模式。下面是一个使用Python实现原型模式的示例：

from copy import deepcopy

# 定义原型接口（可选，取决于是否需要统一复制行为）
class Prototype(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def clone(self) -> "Prototype":
        pass

# 定义具体原型类
class ConcretePrototype(Prototype):
    def __init__(self, attr1: str, attr2: int):
        self.attr1 = attr1
        self.attr2 = attr2

    def clone(self) -> "ConcretePrototype":
        return deepcopy(self)

    def __str__(self):
        return f"ConcretePrototype(attr1={self.attr1}, attr2={self.attr2})"

# 客户端代码
if __name__ == "__main__":
    # 创建原始原型对象
    original_prototype = ConcretePrototype("Original", 1)

    # 使用原型复制出新对象
    cloned_prototype = original_prototype.clone()

    # 修改复制出的对象的属性
    cloned_prototype.attr1 = "Cloned"

    print("Original prototype:", original_prototype)
    print("Cloned prototype:", cloned_prototype)

在这个例子中：

● Prototype是一个可选的抽象基类，用于定义所有原型对象都应具备的clone方法。如果不需要统一复制行为，可以直接在具体原型类中实现复制功能，省略此抽象类。
● ConcretePrototype是具体原型类，它实现了Prototype接口（如果有），并定义了自己的属性。clone方法通过deepcopy函数实现深度复制，确保复制出的新对象与原始对象完全独立，即使它们包含复杂的嵌套结构。
● 主程序中，首先创建了一个ConcretePrototype对象作为原始原型。然后调用其clone方法复制出一个新的原型对象，并修改了新对象的一个属性。最后，打印出原始原型和复制出的原型，以展示它们之间的独立性。

通过原型模式，客户端代码能够快速创建与已有对象相同或相似的新对象，且无需了解对象的具体创建过程。这种模式在需要大量生成相似对象、对象创建过程复杂或耗时的情况下非常实用。

7.适配器模式（Adapter）

适配器模式是一种结构型设计模式，它允许将一个类的接口转换成客户端期望的另一种接口，从而使原本不兼容的类可以协同工作。在Python中，适配器模式通常表现为一个新类（适配器），该类内部封装了一个已存在的类（适配者），并提供了与目标接口一致的方法，以便在不修改原有代码的基础上实现接口间的对接。下面是一个使用Python实现适配器模式的示例：

# 假设存在一个已有的第三方库提供的接口（适配者）
class ThirdPartyLibraryAPI:
    def specific_method(self, arg):
        return f"Third Party Library: {arg}"

# 定义目标接口（期望的接口）
class TargetInterface:
    def common_method(self, arg):
        pass

# 适配器类，继承或实现目标接口，并持有适配者对象
class Adapter(TargetInterface):
    def __init__(self):
        self.adaptee = ThirdPartyLibraryAPI()

    def common_method(self, arg):
        # 将适配者的方法调用转换为目标接口方法的实现
        return self.adaptee.specific_method(arg)

# 客户端代码
if __name__ == "__main__":
    adapter = Adapter()
    result = adapter.common_method("Hello, World!")
    print(result)

在这个例子中：

● ThirdPartyLibraryAPI代表了现有系统中无法直接更改的第三方库接口，即需要被适配的类。
● TargetInterface定义了客户端代码期望使用的通用接口，即目标接口。
● Adapter类实现了TargetInterface，并持有一个ThirdPartyLibraryAPI对象（适配者）。Adapter的common_method方法覆盖了目标接口中定义的方法，其内部调用了适配者类的specific_method方法，并做了必要的转换，使调用符合目标接口的约定。

客户端代码创建Adapter对象，并通过目标接口调用common_method。尽管实际执行的是ThirdPartyLibraryAPI的specific_method，但由于适配器的存在，客户端无需关心这一细节，只需与统一的TargetInterface交互即可。这样一来，即使第三方库的接口与项目需求不完全匹配，也可以通过适配器模式进行桥接，保证系统的松耦合与扩展性。

8.代理模式（Proxy）

代理模式是一种结构型设计模式，它为其他对象（被代理对象）提供一个代理对象，以便控制对原对象的访问。代理对象与被代理对象对外具有相同的接口，客户端可以透明地通过代理对象与被代理对象交互。代理模式常用于实现延迟加载、访问控制、日志记录、性能优化等功能。下面是一个使用Python实现代理模式的示例：

# 定义被代理接口
class Subject:
    @abstractmethod
    def request(self):
        pass

# 被代理对象（真实主题）
class RealSubject(Subject):
    def request(self):
        print("RealSubject: Processing the request...")
        return "RealSubject response"

# 代理对象
class Proxy(Subject):
    def __init__(self):
        self.real_subject = None

    def request(self):
        if self.real_subject is None:
            self.real_subject = RealSubject()
        print("Proxy: Forwarding the request to the real subject...")
        return self.real_subject.request()

# 客户端代码
if __name__ == "__main__":
    proxy = Proxy()
    response = proxy.request()
    print("Client received:", response)

在这个例子中：

● Subject定义了被代理的接口，包含一个request方法。
● RealSubject实现了Subject接口，是实际处理请求的真实主题。
● Proxy类同样实现了Subject接口，充当被代理对象的代理。在Proxy的request方法中，首先检查是否已经创建了RealSubject实例。如果没有，则创建之。接着，调用RealSubject的request方法处理请求，并返回结果。在此过程中，代理可能添加额外的行为，如预处理、后处理、权限检查等。

客户端代码仅与Proxy对象交互，调用其request方法。尽管实际工作由RealSubject完成，但客户端无需知道这一点，因为代理和真实主题对外提供的接口一致。在这个简单示例中，代理实现了延迟加载（即只有在真正需要时才创建RealSubject），但在实际应用中，代理还可以根据需要实现更多的控制逻辑。