Python23种设计模式精要：让你的代码更简洁、易读、易扩展

有追求的开发者
245 阅读12分钟

一、概述

设计模式（Design Pattern）是一套被广泛接受的、可重复使用的软件设计解决方案。它们是在软件开发过程中对常见问题的反复实践和总结得出的经验和思想的表现。

1995 年，GoF（Gang of Four，四人组/四人帮）合作出版了《设计模式：可复用面向对象软件的基础》一书，共收录了 23 种设计模式，从此树立了软件设计模式领域的里程碑，人称「GoF设计模式」。

设计模式是一种解决特定问题的经过测试和验证的通用解决方案，它们被广泛应用于软件工程和计算机科学中。下面列出了常见的23种设计模式：

  1. 工厂模式（Factory Pattern） ：定义一个创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
  2. 抽象工厂模式（Abstract Factory Pattern） ：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。
  3. 单例模式（Singleton Pattern） ：确保一个类只有一个实例，并提供对该实例的全局访问点。
  4. 建造者模式（Builder Pattern） ：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
  5. 原型模式（Prototype Pattern） ：通过复制现有的实例来创建新的对象，而不是使用构造函数。
  6. 适配器模式（Adapter Pattern） ：将一个类的接口转换成客户希望的另一个接口。适配器模式可以让原本由于接口不兼容而不能在一起工作的类可以一起工作。
  7. 桥接模式（Bridge Pattern） ：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
  8. 组合模式（Composite Pattern） ：将对象组合成树形结构以表示部分-整体的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
  9. 装饰器模式（Decorator Pattern） ：动态地将责任附加到对象上。装饰器模式提供了一种灵活的替代继承的方式。
  10. 外观模式（Facade Pattern） ：为子系统中的一组接口提供一个一致的界面，使得子系统更容易使用。
  11. 享元模式（Flyweight Pattern） ：运用共享技术来有效地支持大量细粒度对象的复用。
  12. 代理模式（Proxy Pattern） ：为其他对象提供一种代理以控制对这个对象的访问。代理对象可以在被代理对象执行操作前后进行一些预处理和后处理。
  13. 责任链模式（Chain of Responsibility Pattern） ：为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。
  14. 命令模式（Command Pattern） ：将请求封装成一个对象，从而使你可以用不同的请求对客户进行参数化。命令模式也支持撤销操作。
  15. 解释器模式（Interpreter Pattern） ：是一种行为型设计模式，它提供了一种方法，可以在运行时解释语言文法中的表达式，并执行相应的操作。
  16. 迭代器模式（Iterator Pattern） ：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。
  17. 中介者模式（Mediator Pattern） ：用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显式地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
  18. 备忘录模式（Memento Pattern） ：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。备忘录模式可以在需要时将对象恢复到先前的状态。
  19. 观察者模式（Observer Pattern） ：定义对象间的一种一对多的依赖关系，使得每当一个对象状态发生改变时，所有依赖它的对象都会得到通知并自动更新。
  20. 状态模式（State Pattern） ：允许对象在其内部状态发生改变时改变它的行为。对象看起来似乎修改了它的类。
  21. 策略模式（Strategy Pattern） ：定义一系列算法，将每个算法都封装起来，并使它们之间可以互换。策略模式使得算法可以独立于使用它的客户而变化。
  22. 模板方法模式 (Template Method Pattern) ：定义一个算法框架，并将一些步骤延迟到子类中实现，以便在不改变算法结构的情况下，允许子类重定义算法的某些步骤。
  23. 访问者模式（Visitor Pattern） ：是一种行为型设计模式，它可以让你在不修改对象结构的前提下，定义作用于这些对象元素的新操作。

这些设计模式可以被分为三个类别：

  • 创建型模式：这些模式涉及对象的创建机制，并提供了一种将对象的创建和使用分离的方式。工厂模式、抽象工厂模式、单例模式、建造者模式和原型模式都属于这一类别。
  • 结构型模式：这些模式涉及将类或对象组合在一起形成更大的结构，并提供了一种简化设计的方式。适配器模式、桥接模式、组合模式、装饰器模式、外观模式、享元模式和代理模式都属于这一类别。
  • 行为型模式：这些模式涉及对象之间的通信和算法的分配，并提供了一种实现松散耦合的方式。责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式和访问者模式都属于这一类别。

23种设计模式

image.png

设计模式原则

image.png

设计模式的七种原则通常被称为“SOLID原则”，是面向对象设计中的基本原则，能够帮助开发人员编写出更加灵活、可扩展、可维护的代码。这七个原则分别是：

  • 单一职责原则（Single Responsibility Principle，SRP） ：一个类只负责一个职责或一个功能。这个原则强调的是高内聚、低耦合，可以降低类的复杂度，提高代码的可读性、可维护性和可重用性。
  • 开闭原则（Open-Closed Principle，OCP） ：一个类的行为应该是可扩展的，但是不可修改。这个原则强调的是代码的可维护性和可扩展性，通过抽象化来避免修改已有代码的风险，从而降低软件维护的成本。
  • 里氏替换原则（Liskov Substitution Principle，LSP） ：子类应该可以替换其父类并且不会影响程序的正确性。这个原则强调的是面向对象的继承和多态特性，通过保证子类的行为和父类一致，从而提高代码的可维护性和可扩展性。
  • 接口隔离原则（Interface Segregation Principle，ISP） ：一个类不应该依赖它不需要的接口，即一个类对其它类的依赖应该建立在最小的接口上。这个原则强调的是接口设计的合理性，避免不必要的接口导致类之间的耦合性过高，从而提高代码的灵活性和可维护性。
  • 依赖倒置原则（Dependency Inversion Principle，DIP） ：依赖于抽象而不是依赖于具体实现。这个原则强调的是代码的可扩展性和可维护性，通过抽象化来减少组件之间的耦合性，从而使得代码更加灵活、易于维护和扩展。
  • 迪米特法则（Law of Demeter，LoD） ：也叫最少知识原则（Least Knowledge Principle，LKP），一个对象应当对其他对象有尽可能少的了解，不需要了解的内容尽量不要去了解。这个原则强调的是组件之间的松耦合，通过减少组件之间的依赖关系，提高代码的可维护性和可重用性。
  • 组合/聚合复用原则（Composite/Aggregate Reuse Principle，CARP） ：尽量使用组合或聚合关系，而不是继承关系来达到代码复用的目的。这个原则强调的是通过组合和聚合的方式来实现代码复用，避免继承带来的一些问题，如父类和子类之间的强耦合性，从而提高代码的灵活性和可维护性。

三、设计模式示例讲解

1）创建型模式

1、工厂模式（Factory Method）

工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。可分为简单工厂模式、工厂方法模式。以下分别对两种模式进行介绍。

【1】简单工厂模式（不属于GOF设计模式之一）

简单工厂模式属于创建型模式，又叫做静态工厂方法（Static Factory Method） 。简单工厂模式是由一个工厂对象决定创建哪一种产品类实例。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为不同工厂模式的一个特殊实现。

值得注意的是，简单工厂模式并不属于GOF设计模式之一。但是他说抽象工厂模式，工厂方法模式的基础，并且有广泛得应用。

  • 在简单工厂模式中，有一个工厂类负责创建多个不同类型的对象。该工厂类通常包含一个公共的静态方法，该方法接受一个参数，用于指示要创建的对象类型，然后根据该参数创建相应的对象并返回给客户端。
  • 简单工厂模式可以隐藏对象创建的复杂性，并使客户端代码更加简洁和易于维护。但它也有一些缺点，例如如果需要添加新的对象类型，则必须修改工厂类的代码。同时，该模式也可能破坏了单一职责原则，因为工厂类不仅负责对象的创建，还负责了判断要创建哪个对象的逻辑。
  • 简单工厂模式通常被用于创建具有相似特征的对象，例如不同类型的图形对象、不同类型的数据库连接对象等。

下面是一个简单工厂模式的 Python 实现示例：

class Product:    def operation(self):        passclass ConcreteProductA(Product):    def operation(self):        return "ConcreteProductA"class ConcreteProductB(Product):    def operation(self):        return "ConcreteProductB"class SimpleFactory:    @staticmethod    def create_product(product_type):        if product_type == "A":            return ConcreteProductA()        elif product_type == "B":            return ConcreteProductB()        else:            raise ValueError("Invalid product type")if __name__ == "__main__":    # 客户端代码    product_a = SimpleFactory.create_product("A")    product_b = SimpleFactory.create_product("B")    print(product_a.operation())  # 输出：ConcreteProductA    print(product_b.operation())  # 输出：ConcreteProductB

实现解释：

  • 上述代码中，Product 是产品类的基类，ConcreteProductA 和 ConcreteProductB 是具体的产品类，它们都继承自 Product，并实现了 operation 方法。
  • SimpleFactory 是工厂类，它包含一个 create_product 静态方法，用于根据客户端传入的产品类型创建相应的产品对象。
  • 在客户端代码中，我们通过调用 SimpleFactory.create_product 方法来创建不同类型的产品对象，并调用其 operation 方法。在此示例中，我们分别创建了一个 ConcreteProductA 和一个 ConcreteProductB 对象，并输出它们的操作结果。

【2】工厂方法模式

工厂方法模式（Factory Method） 是一种创建型设计模式，它提供了一种将对象的创建过程委托给子类的方式。

通常情况下，工厂方法模式使用一个接口或抽象类来表示创建对象的工厂，然后将具体的创建逻辑委托给子类来实现。这样可以使代码更加灵活，因为在运行时可以选择要实例化的对象类型。

以下是工厂方法模式的基本原理：

  1. 定义一个接口或抽象类来表示要创建的对象。
  2. 创建一个工厂类，该类包含一个工厂方法，该方法根据需要创建对象并返回该对象。
  3. 创建一个或多个具体的子类，实现工厂接口并实现工厂方法来创建对象。

工厂模式的优点：

  • 这种方法可以使代码更加灵活，因为在运行时可以选择要实例化的对象类型。例如，可以轻松地添加新的子类来创建不同的对象类型，而无需更改现有的代码。
  • 工厂方法模式还提供了一种解耦的方式，因为它将对象的创建逻辑与其使用代码分离。这可以使代码更加可维护和可测试，因为可以独立地测试和修改对象的创建逻辑和使用代码。
  • 工厂方法模式常用于框架和库中，因为它可以使用户扩展框架或库的功能，而无需更改框架或库的源代码。
from abc import ABC, abstractmethod
# 定义抽象产品类
class Product(ABC):    
    @abstractmethod    
    def use(self):        
    pass
# 定义具体产品类 A
class ConcreteProductA(Product):    
    def use(self):        
        print("Using product A")
# 定义具体产品类 B
class ConcreteProductB(Product):    
    def use(self):        
        print("Using product B")
# 定义工厂类
class Creator(ABC):    
    @abstractmethod    
    def factory_method(self):        
        pass    
    def some_operation(self):        
        product = self.factory_method()        
        product.use()
# 定义具体工厂类 A
class ConcreteCreatorA(Creator):    
    def factory_method(self):        
        return ConcreteProductA()
# 定义具体工厂类 B
class ConcreteCreatorB(Creator):    
    def factory_method(self):        
        return ConcreteProductB()
 # 客户端代码
 if __name__ == "__main__":    
     creator_a = ConcreteCreatorA()   
     creator_a.some_operation()    
     creator_b = ConcreteCreatorB()   
     creator_b.some_operation()
avatar
文章
阅读
粉丝