6个常见的Python设计模式及应用场景

在软件开发中，设计模式是解决特定问题的成熟模板。它们可以帮助我们写出更加模块化、可复用和易于维护的代码。本文将介绍6个常见的Python设计模式，并通过示例代码展示它们的使用场景。

1. 单例模式（Singleton）

使用场景：需要确保一个类只有一个实例，并提供一个全局访问点。

示例代码：

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

# 使用
singleton1 = Singleton()
singleton2 = Singleton()
assert singleton1 is singleton2  # 两者是同一个实例

2. 工厂模式（Factory Method）

使用场景：创建对象时，不指定具体类，而是提供一个接口让子类决定实例化哪一个类。

示例代码：

class Dog:
    def speak(self):
        return "Woof!"

class Cat:
    def speak(self):
        return "Meow!"

class AnimalFactory:
    def create(self, animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            return None

# 使用
factory = AnimalFactory()
dog = factory.create("dog")
print(dog.speak())  # Woof!

3. 策略模式（Strategy）

使用场景：需要在运行时选择算法或行为时。

示例代码：

from functools import wraps

def strategy(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        strategy = kwargs.pop('strategy', 'default')
        if strategy == 'default':
            return func(*args, **kwargs)
        elif strategy == 'advanced':
            return func(*args, **kwargs) * 2
        else:
            raise ValueError("Unknown strategy")
    return wrapper

@strategy
def compute(x, y):
    return x + y

# 使用
print(compute(5, 3))  # 默认策略
print(compute(5, 3, strategy='advanced'))  # 高级策略

4. 观察者模式（Observer）

使用场景：对象间的一对多依赖关系，当一个对象状态改变时，所有依赖于它的对象都得到通知并自动更新。

示例代码：

class Observer:
    def update(self, message):
        raise NotImplementedError

class ConcreteObserver(Observer):
    def update(self, message):
        print(f"Received message: {message}")

class Subject:
    def __init__(self):
        self._observers = []

    def attach(self, observer):
        self._observers.append(observer)

    def notify(self, message):
        for observer in self._observers:
            observer.update(message)

# 使用
subject = Subject()
observer = ConcreteObserver()
subject.attach(observer)
subject.notify("Hello, World!")

5. 装饰器模式（Decorator）

使用场景：动态地给一个对象添加额外的职责。

示例代码：

class Coffee:
    def cost(self):
        return 1

    def __str__(self):
        return "Coffee"

class Milk:
    def __init__(self, beverage):
        self.beverage = beverage

    def cost(self):
        return self.beverage.cost() + 0.5

    def __str__(self):
        return f"{self.beverage} with milk"

# 使用
coffee = Coffee()
milk_coffee = Milk(coffee)
print(milk_coffee.cost())  # 1.5
print(milk_coffee)  # Coffee with milk

6. 代理模式（Proxy）

使用场景：控制对原始对象的访问，提供额外的安全检查或延迟初始化。

示例代码：

class Proxy:
    def __init__(self, real_subject):
        self._real_subject = None
        self.set_real_subject(real_subject)

    def set_real_subject(self, real):
        self._real_subject = real

    def __getattr__(self, name):
        return getattr(self._real_subject, name)

class RealSubject:
    def request(self):
        return "Request successfully made."

# 使用
real_subject = RealSubject()
proxy = Proxy(real_subject)
print(proxy.request())  # 通过代理访问

结语

设计模式是软件工程中的宝贵工具，它们提供了解决常见问题的通用方法。理解并掌握这些设计模式，可以帮助我们写出更加优雅和高效的代码。希望本文能够帮助你更好地理解和应用这些设计模式。