Python 从基础到进阶 03： 常见设计模式及应用场景

当你在使用Python编写软件时，设计模式可以帮助你更好地组织和结构化你的代码，以应对各种问题和需求。下面是一些常见的Python设计模式，每个模式都附带了具体的应用场景和对应的示例代码。

1. 单例模式（Singleton Pattern）

应用场景

单例模式用于确保一个类只有一个实例，并提供一个全局访问点。它常用于管理共享资源，如数据库连接池或配置对象。

示例代码

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()
print(singleton1 is singleton2)  # 输出True，两个变量引用同一个实例

2. 工厂模式（Factory Pattern）

应用场景

工厂模式用于创建对象，将对象的创建与使用分离，以便根据需要创建不同类型的对象。

示例代码

class Animal:
    def speak(self):
        pass

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

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

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

# 使用工厂模式
factory = AnimalFactory()
dog = factory.create_animal("dog")
cat = factory.create_animal("cat")
print(dog.speak())  # 输出 "Woof!"
print(cat.speak())  # 输出 "Meow!"

3. 观察者模式（Observer Pattern）

应用场景

观察者模式用于实现发布-订阅机制，其中一个对象（主题）维护一组观察者对象，当主题的状态发生变化时，通知所有观察者。

示例代码

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

    def add_observer(self, observer):
        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!")

4. 策略模式（Strategy Pattern）

应用场景

策略模式用于定义一组算法，并使这些算法可以相互替换，使得客户端可以灵活地选择要使用的算法。

示例代码

class PaymentStrategy:
    def pay(self, amount):
        pass

class CreditCardPayment(PaymentStrategy):
    def pay(self, amount):
        print(f"Paid ${amount} with credit card")

class PayPalPayment(PaymentStrategy):
    def pay(self, amount):
        print(f"Paid ${amount} with PayPal")

class ShoppingCart:
    def __init__(self, payment_strategy):
        self._items = []
        self._payment_strategy = payment_strategy

    def add_item(self, item):
        self._items.append(item)

    def checkout(self):
        total_amount = sum(item['price'] for item in self._items)
        self._payment_strategy.pay(total_amount)

# 使用策略模式
credit_card_payment = CreditCardPayment()
shopping_cart1 = ShoppingCart(credit_card_payment)
shopping_cart1.add_item({'item': 'Laptop', 'price': 1000})
shopping_cart1.add_item({'item': 'Mouse', 'price': 20})
shopping_cart1.checkout()  # 输出 "Paid $1020 with credit card"

paypal_payment = PayPalPayment()
shopping_cart2 = ShoppingCart(paypal_payment)
shopping_cart2.add_item({'item': 'Headphones', 'price': 50})
shopping_cart2.checkout()  # 输出 "Paid $50 with PayPal"

5. 适配器模式（Adapter Pattern）

应用场景

适配器模式用于将一个类的接口转换成另一个类的接口，以便使两者能够协同工作，通常用于旧代码的重用或集成新组件。

示例代码

class OldSystem:
    def legacy_method(self):
        return "Legacy Method"

class NewSystem:
    def modern_method(self):
        return "Modern Method"

class Adapter:
    def __init__(self, old_system):
        self.old_system = old_system

    def modern_method(self):
        return self.old_system.legacy_method()

# 使用适配器模式
old_system = OldSystem()
adapter = Adapter(old_system)
print(adapter.modern_method())  # 输出 "Legacy Method"

6. 命令模式（Command Pattern）

应用场景

命令模式用于将请求封装成一个对象，以便可以将请求排队、记录日志、撤销等。它常用于实现撤销/恢复功能。

示例代码

from abc import ABC, abstractmethod

class Command(ABC):
    @abstractmethod
    def execute(self):
        pass

class Light:
    def on(self):
        print("Light is on")

    def off(self):
        print("Light is off")

class LightOnCommand(Command):
    def __init__(self, light):
        self.light = light

    def execute(self):
        self.light.on()

class LightOffCommand(Command):
    def __init__(self, light):
        self.light = light

    def execute(self):
        self.light.off()

class RemoteControl:
    def __init__(self):
        self.command = None

    def set_command(self, command):
        self.command = command

    def press_button(self):
        self.command.execute()

# 使用命令模式
light = Light()
light_on = LightOnCommand(light)
light_off = LightOffCommand(light)

remote = RemoteControl()
remote.set_command(light_on)
remote.press_button()  # 输出 "Light is on"
remote.set_command(light_off)
remote.press_button()  # 输出 "Light is off"

7. 装饰器模式（Decorator Pattern）

应用场景

装饰器模式用于动态地给对象添加额外的职责，而不需要修改其源代码。它常用于扩展类的功能，例如日志记录、验证等。

示例代码

from functools import wraps

def log_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with args: {args}, kwargs: {kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned: {result}")
        return result
    return wrapper

@log_decorator
def add(a, b):
    return a + b

result = add(3, 5)

这些是一些常见的Python设计模式以及它们的应用场景和示例代码。设计模式是一种有助于提高代码可维护性和可扩展性的重要工具，可以根据具体需求选择合适的模式来应对不同的问题。