Python学习笔记（5）Python的创建型设计模式

创建型设计模式（Creational Design Patterns），主要关注对象的创建机制。这类模式可以使得系统更加独立于如何创建、组合和表示其对象。通过将这些职责分离出来，创建型设计模式有助于提高代码的灵活性和复用性。

本书的范例代码已经放在我的资源库里——pipbook

1 抽象工厂模式

用于创建复杂的对象，这种对象由许多小对象组成，而这些对象都属于某个特定的系列

例如，在GUI系统中可以设计一个“抽象控件工厂”，然后在下面设计三个“具体子类工厂”，如下图所示：

它们都提供同一种对象的方法（例如都提供创建按钮的方法等），但是可以创建适应不同的平台的方法。

抽象工厂模式的结构：

1. 抽象工厂（Abstract Factory）：定义了创建一系列相关产品对象的方法（例如，createProductA()、createProductB()等）。
2. 具体工厂（Concrete Factory）：实现了抽象工厂中定义的方法，负责实例化具体的产品对象。
3. 抽象产品（Abstract Product）：定义了产品的接口，可以是一个产品家族的抽象基类。
4. 具体产品（Concrete Product）：实现了抽象产品的接口，代表某一具体产品的实现。

假设有一个图形应用，支持创建不同风格的按钮和文本框。不同风格的按钮和文本框属于不同的产品族，例如，Windows风格和Mac风格，代码结构如下：

# 抽象工厂，创建按钮和文本框
class GUIFactory:
    def create_button(self):
        pass
    
    def create_textbox(self):
        pass

# 具体工厂，创建win或者mac的按钮和文本框
class WindowsFactory(GUIFactory):
    def create_button(self):
        return WindowsButton()
    
    def create_textbox(self):
        return WindowsTextBox()

class MacFactory(GUIFactory):
    def create_button(self):
        return MacButton()
    
    def create_textbox(self):
        return MacTextBox()

# 抽象产品，定义按钮和文本框
class Button:
    def render(self):
        pass

class TextBox:
    def render(self):
        pass

# 具体产品，定义按钮和文本框的风格类型
class WindowsButton(Button):
    def render(self): # 重写render()
        print("Rendering Windows button")

class MacButton(Button):
    def render(self):# 重写render()
        print("Rendering Mac button")

class WindowsTextBox(TextBox):
    def render(self):# 重写render()
        print("Rendering Windows text box")

class MacTextBox(TextBox):
    def render(self):# 重写render()
        print("Rendering Mac text box")


# 客户端，factory 必须是 GUIFactory 类型或其子类
def client_code(factory: GUIFactory):
    '''
    功能：创建对象

    如果传入WindowsFactory()，则实际上调用：
    
    def create_button(self):
        return WindowsButton()
    
    def create_textbox(self):
        return WindowsTextBox()
    '''
    button = factory.create_button()
    textbox = factory.create_textbox()

    # 使用对象
    button.render()
    textbox.render()

# 使用不同的工厂
windows_factory = WindowsFactory()
client_code(windows_factory)

mac_factory = MacFactory()
client_code(mac_factory)

优点

• 解耦：客户端不需要依赖具体的产品类，只需要依赖抽象工厂接口，可以轻松切换不同的产品族。
• 可扩展性：可以轻松添加新的产品族，只需增加新的具体工厂和产品类（抽象产品），而不需要修改现有的代码。

1.1 经典的抽象工厂模式

我们通过生成简单的“示意图”来进行演示，这段程序定义了两个工厂：一个生成纯文本格式的示意图，一个生成SVG格式的示意图。

同时此程序采用了两种写法：

• diagram1.py按照传统方式来运用抽象工厂模式
• diagram2.py借助了python的特性，使得写出来的程序更短小清晰

下面是diagram1.py的代码结构：

代码主要结构的解释如下：

1. 有一个create_diagram()的抽象工厂，输入参数是具体工厂
2. 有两个具体工厂类，既是基类，也定义了抽象接口(创建图、创建矩形、创建文本)
3. 有三个抽象产品，Diagram、Rectangle、Text，定义了图形、矩阵、文本的具体行为
4. 有六个具体产品：
   Diagram（ASCII 格式图形）
   SvgDiagram（SVG 格式图形）
   Rectangle（ASCII 格式矩形）
   SvgRectangle（SVG 格式矩形）
   Text（ASCII 格式文本）
   SvgText（SVG 格式文本）
   具体产品是抽象产品的实现类，是工厂具体生产出来的产品，不过由于设置了限制，不同系列的产品不能进行混搭。

这样，如果想扩展的具体的产品，可以直接增加具体产品就行；如果想增加新的组建，则增加新的抽象产品和具体产品，而不用再去修改抽象工厂和具体工厂。

1.2 Python风格的抽象工厂模式

上面的写法演示了传统的抽象工厂模式，但是也有几个缺点：

1. SvgDiagramFactory和DiagramFactory的代码几乎一样，有很多重复代码
2. 两个具体工厂都没有需要初始化的变量，所以根本不需要创建实例
3. 六个具体产品都放在了“顶级命名空间”中，所以为了导致名称冲突，只得加上前缀，但实际上可以不这样做

下面是diagram1.py的代码结构，使用了一些Python的特性，让代码变得更简洁:

通过使用@classmethod装饰器定义类方法，可以来解决这些问题：

如上图所示，我们把创建图、矩形、文本的方法都嵌套到DiagramFactory中，并定义为类方法，这样：

1. SvgDiagramFactory只需要继承DiagramFactory即可，不需要再去实现那三个方法，提升代码简洁性。
2. 由于使用了类方法，可以直接通过DiagramFactory.make_diagram()来调用，不需要再创建一个实例。
3. 在SvgDiagramFactory和DiagramFactory中，我们都可以使用Diagram、Text、Rectangle去定义类，因为他们分别属于SvgDiagramFactory和DiagramFactory下面，所以不需要再添加前缀，此时“顶级命名空间”中只剩下了create_Ddagram()、DiagramFactory、SvgDiagramFactory

2 建造者模式

也叫生成器模式、构建者模式，与抽象工厂类似，都可以创建由其他对象组合而成的复杂对象，但建造者模式还会保存复杂对象里各个部分的细节。

建造者模式分步骤构造复杂的对象。这种模式的主要目的是将一个复杂对象的构建与其表示分离，使得相同的构建过程可以创建不同的表示。建造者模式通常用于需要根据不同的参数组合来创建不同配置的对象场景。

建造者模式的结构：

1. 抽象建造者： 定义了一个接口，规定了所有具体建造者必须实现的方法。
2. 具体建造者： 继承自 AbstractFormBuilder，并提供了具体的实现,每个具体建造者负责构建特定类型的产品
3. 导演类: 负责指导构建过程。它接收一个建造者实例，并调用建造者的各个方法以逐步构建最终产品，它不关心具体是如何构建产品的，只负责按照一定的规则或流程调用建造者的方法。

这里通过“表单生成程序“来演示，这段程序可以生成一个HTML的表单和一个Tkinter的GUI表单，代码文件是formbuilder.py:

1. 有一个抽象建造者AbstractFormBuilder，定义了如 add_title(), form(), add_label(), add_entry(), 和 add_button() 方法，这些方法定义了构建过程中的步骤。
2. 有两个具体建造HtmlFormBuilder 和 TkFormBuilder，分别是继承自AbstractFormBuilder，并且根据各自的场景，对方法进行了重写。
3. 有一个导演类create_login_form，指出了构造流程，如下：
   builder参数是指HtmlFormBuilder()或者TkFormBuilder()，main()函数也只负责“指挥”导演类进行搭建

优点：

• 灵活性与可扩展性: 建造者模式使得代码更加灵活和易于扩展。如果需要添加新的表单类型，只需要创建一个新的具体建造者类，然后在main()中选择使用它即可。
• 控制复杂性: 它隐藏了对象创建的具体细节，使main()代码更加简洁，可以更改产品的内部结构而不影响其他代码

3 工厂方法模式

这个模式的核心思想是定义一个用于创建对象的接口，但由子类决定实例化哪一个类。这样，工厂方法让类的实例化推迟到子类。这种模式的主要优点是它遵循了开闭原则（Open/Closed Principle），即软件实体对扩展开放，对修改关闭。通过使用工厂方法模式，你可以在不修改现有代码的情况下引入新的产品类型。

工厂方法模式的结构：

1. Product（产品接口）： 定义所有具体产品类的公共接口。客户端代码使用这个接口来操作具体的对象，而无需关心具体的实现细节。
2. Concrete Product（具体产品）： 实现了Product接口的具体类。每个具体产品代表一个可以被创建的对象。
3. Creator（创建者/抽象工厂）： 包含了一个或多个工厂方法，用于声明创建Product对象的接口。它通常是一个抽象类，定义了工厂方法但没有实现它
4. Concrete Creator（具体创建者/具体工厂）： 继承自Creator，并实现了工厂方法以返回一个特定类型的Concrete Product实例。

以gameboard4.py为例：

1. 产品接口是Piece类

2. 具体产品是通过 exec 动态创建的类，继承自 Piece 类。如下图代码：
   

3. LAbstractBoard 类是创建者，它定义了 populate_board() 抽象方法，子类需要实现此方法来创建具体的棋子。

4. heckersBoard 和 ChessBoard 类分别是具体创建者，它们继承自 AbstractBoard，并且实现了 populate_board() 方法来具体创建棋子并将其放置到棋盘上。

优点：

• 提高代码可扩展性： 例如，在这段代码中，若想增加新的棋子类型（如“象棋”中的“炮”棋子），只需要新增一个新的棋子类和相应的创建方法，而不需要修改棋盘类的其他部分。
• 提供了灵活的产品替换机制： 比如，如果要从国际象棋变更为跳棋，只需要在 CheckersBoard 类中调整 populate_board 方法，而不需要修改整个代码结构。
• 符合开放封闭原则： 例如，假如我们要添加一个新的棋类游戏（如围棋），我们只需要新建一个围棋棋盘类，并实现相关的工厂方法来生成围棋棋子，而现有的国际象棋和跳棋代码不会受到影响。

4 原型模式

原型模式通过复制现有的对象来创建新对象，而不是通过构造函数来直接创建新对象。它的核心思想是使用“原型”对象作为模板，复制它来创建新的对象，这种方式可以提高性能，尤其是在创建复杂对象时，避免了重复的初始化工作。

关键概念：

• 原型（Prototype）： 一个可以被复制的对象，它包含了创建其他相似对象的能力。
• 克隆（Clone）： 通过复制原型对象来创建新的对象。通常，原型类提供一个 clone() 方法来完成这个任务。
• 浅拷贝与深拷贝：
  浅拷贝： 仅复制对象的基本类型属性，复杂类型的属性（如列表、对象等）仍然指向原对象中的同一引用。
  深拷贝： 复制对象及其所有子对象，完全独立于原对象。

原型模式的结构：

1. Prototype（原型）： 声明一个 clone() 方法，用于复制当前对象。
2. ConcretePrototype（具体原型）： 实现 clone() 方法，复制当前对象的所有属性并返回一个新的对象实例。
3. Client（客户端）： 使用原型对象，通过调用 clone() 方法来获得新的对象。

示例代码：

import copy

# 1. 原型类，提供 clone 方法
class Prototype:
    def clone(self):
        # 默认浅拷贝
        return copy.copy(self)

# 2. 具体原型类
class ConcretePrototype(Prototype):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"{self.name}, {self.age}"

    def clone(self):
        # 这里进行深拷贝
        return copy.deepcopy(self)

# 3. 客户端代码
def main():
    original = ConcretePrototype("Alice", 30)
    print("Original:", original)

    # 使用原型模式创建副本
    clone1 = original.clone()
    print("Clone1:", clone1)

    # 修改副本的属性，确保原型不受影响
    clone1.name = "Bob"
    clone1.age = 25
    print("Modified Clone1:", clone1)
    print("Original after modifying Clone1:", original)

if __name__ == "__main__":
    main()

• Prototype 类是一个抽象类，定义了 clone() 方法，具体的原型类需要实现这个方法来复制对象。
• 在 ConcretePrototype 中，clone() 方法使用了 copy.deepcopy() 来实现深拷贝，这样我们得到的副本对象与原始对象完全独立，不会相互影响。

优点：

1. 如果某些对象的创建过程比较复杂，且多个地方需要相似的对象，可以通过原型模式来减少重复工作。
2. 如果需要在运行时创建大量相似的对象，可以通过原型模式来提高性能。
3. 如果产品有多种不同变体，但这些变体之间有相似的结构，可以通过原型模式来共享公共部分。

5 单例模式

单例模式确保一个类只有一个实例，并提供全局访问点来获取这个实例。该模式主要用于限制类的实例化次数，保证系统中某个类始终只有一个实例，适用于那些只需要一个共享资源或全局配置的场景。

关键特性：

1. 唯一性： 确保类只有一个实例。
2. 全局访问点： 提供全局访问该实例的方式。
3. 懒加载： 实例仅在第一次使用时创建，而不是一开始就创建。

6 总结

介绍了5种创建型设计模式，其中：

• 单例模式可以用Python的模块来实现，没有特别的地方。
• 由于Python可以动态的访问类对象，所以原型模式也什么意义（python提供了内置的copy方法）
• 所以最有用的是抽象工厂模式、工厂方法模式、建造者模式