python-patterns：Python 设计模式大全

news2024/10/3 2:14:07

点关注开车不迷路

python-patterns 是一个开源的 Python 项目，它提供了各种经典的设计模式的 Python 实现。设计模式是一种针对常见软件设计问题的可复用解决方案，通过使用设计模式，开发者可以编写出结构更加合理、易于维护和扩展的代码。

Python 是一门动态语言，很多经典的面向对象设计模式（如工厂模式、单例模式等）都可以通过 Python 的独特特性进行简洁的实现。python-patterns 项目不仅展示了这些设计模式的实现方式，还解释了它们在不同场景中的应用，是学习设计模式和优化代码结构的理想资源。

本文将介绍 python-patterns 项目的主要内容、常见设计模式的 Python 实现，以及如何在实际项目中应用这些模式。

在这里插入图片描述

华丽的分割线

➰缘起

💯 设计模式简介
💯 常见设计模式的 Python 实现
1. 单例模式（Singleton）
2. 工厂模式（Factory Method）
3. 观察者模式（Observer）
4. 装饰器模式（Decorator）
5. 策略模式（Strategy）

💯 在实际项目中的应用
📥 下载地址
💬 结语
📒 参考文献

标题1

💯 设计模式简介

设计模式是一系列经过验证的解决方案，用于解决软件开发过程中遇到的常见问题。这些模式通常分为以下三类：

创建型模式：主要用于对象的创建，旨在简化对象创建过程并隐藏创建的复杂性。常见的创建型模式包括单例模式、工厂模式、建造者模式等。
结构型模式：主要用于简化类和对象之间的关系，帮助构建灵活且可扩展的架构。常见的结构型模式有装饰器模式、代理模式、适配器模式等。
行为型模式：用于管理对象之间的通信，优化对象的行为交互。常见的行为型模式包括观察者模式、策略模式、责任链模式等。

标题2

💯 常见设计模式的 Python 实现

以下是 python-patterns 项目中一些常见设计模式的 Python 实现，展示了如何利用 Python 的特性简洁地实现这些模式。

1. 单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供一个全局访问点。它通常用于需要共享状态或资源的场景，比如日志系统、数据库连接池等。

Python 实现：

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

在这个实现中，__new__ 方法确保每次创建新实例时都会返回同一个对象实例。这是一种通过 Python 内置机制实现的简单单例模式。

2. 工厂模式（Factory Method）

工厂模式是一种创建型模式，用于将对象的创建逻辑与使用者解耦。通过工厂方法，用户无需知道具体对象的构造细节，只需要调用工厂函数来获取对象实例。

Python 实现：

class Animal:
    def speak(self):
        raise NotImplementedError

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

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

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

# 测试
animal = AnimalFactory.get_animal("dog")
print(animal.speak())  # 输出: Woof!

在这个实现中，AnimalFactory 类通过静态方法 get_animal 创建不同类型的动物实例，而不需要调用者知道具体的类名或创建细节。

3. 观察者模式（Observer）

观察者模式是一种行为型模式，它定义了对象之间的一对多依赖关系。当一个对象的状态发生改变时，所有依赖于它的对象都会自动收到通知并更新。这个模式常用于事件处理系统中，如 GUI 应用中的按钮点击事件等。

Python 实现：

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

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

    def notify_all(self, *args, **kwargs):
        for observer in self._observers:
            observer.update(*args, **kwargs)

class Observer:
    def update(self, *args, **kwargs):
        pass

# 定义具体的观察者
class ConcreteObserver(Observer):
    def update(self, message):
        print(f"Received message: {message}")

# 测试
subject = Subject()
observer1 = ConcreteObserver()
observer2 = ConcreteObserver()

subject.register(observer1)
subject.register(observer2)

subject.notify_all("Hello Observers!")  # 输出两次: Received message: Hello Observers!

在这个示例中，Subject 对象维护一个观察者列表，并在其状态发生变化时调用 notify_all 方法通知所有注册的观察者。

4. 装饰器模式（Decorator）

装饰器模式是一种结构型模式，允许在不改变对象自身的情况下动态地为对象添加行为。Python 本身支持装饰器语法，这使得装饰器模式在 Python 中的实现非常方便。

Python 实现：

class Coffee:
    def cost(self):
        return 5

class MilkDecorator:
    def __init__(self, coffee):
        self._coffee = coffee

    def cost(self):
        return self._coffee.cost() + 2

class SugarDecorator:
    def __init__(self, coffee):
        self._coffee = coffee

    def cost(self):
        return self._coffee.cost() + 1

# 测试
coffee = Coffee()
coffee_with_milk = MilkDecorator(coffee)
coffee_with_milk_and_sugar = SugarDecorator(coffee_with_milk)

print(coffee_with_milk_and_sugar.cost())  # 输出: 8

在这个例子中，MilkDecorator 和 SugarDecorator 为原始 Coffee 对象动态地添加了额外的功能（即增加了牛奶和糖的价格）。

5. 策略模式（Strategy）

策略模式是一种行为型模式，它允许在运行时选择不同的算法或策略，而不需要修改使用策略的客户端代码。这种模式经常用于处理可替换的行为逻辑，如支付系统、排序算法等。

Python 实现：

class Strategy:
    def execute(self, a, b):
        pass

class AddStrategy(Strategy):
    def execute(self, a, b):
        return a + b

class SubtractStrategy(Strategy):
    def execute(self, a, b):
        return a - b

class Context:
    def __init__(self, strategy):
        self._strategy = strategy

    def set_strategy(self, strategy):
        self._strategy = strategy

    def execute_strategy(self, a, b):
        return self._strategy.execute(a, b)

# 测试
context = Context(AddStrategy())
print(context.execute_strategy(5, 3))  # 输出: 8

context.set_strategy(SubtractStrategy())
print(context.execute_strategy(5, 3))  # 输出: 2