Python中的设计模式：23种创意解锁高效编程之道_python设计模式

*设计模式是解决特定问题的经验丰富的通用解决方案，它们是在软件设计中反复出现的问题的可重用设计。以下是23种经典的设计模式，以Python语言的代码示例呈现： *

1.创建型模式（Creational Patterns）:

工厂方法模式（Factory Method）:

工厂方法模式是一种创建型设计模式，它提供了一个接口来创建对象，但允许子类决定要实例化的类。这种模式使一个类的实例化延迟到其子类。

结构

1. 抽象产品（Product）：定义产品的接口，是工厂方法创建的对象的超类型。
2. 具体产品（Concrete Product）：实现抽象产品接口的具体类。
3. 抽象工厂（Creator）：声明工厂方法，该方法返回一个抽象产品类型的对象。抽象工厂可以包含一些默认的实现，但通常工厂方法是抽象的，由子类实现。
4. 具体工厂（Concrete Creator）：实现抽象工厂中的工厂方法，返回具体产品的实例。

from abc import ABC, abstractmethod

class Creator(ABC):
    @abstractmethod
    def factory_method(self):
        pass

    def some_operation(self):
        product = self.factory_method()
        result = f"Creator: The same creator's code has just worked with {product.operation()}"
        return result

class ConcreteCreator1(Creator):
    def factory_method(self):
        return ConcreteProduct1()

class ConcreteCreator2(Creator):
    def factory_method(self):
        return ConcreteProduct2()

class Product(ABC):
    @abstractmethod
    def operation(self):
        pass

class ConcreteProduct1(Product):
    def operation(self):
        return "{Result of ConcreteProduct1}"

class ConcreteProduct2(Product):
    def operation(self):
        return "{Result of ConcreteProduct2}"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

抽象工厂模式（Abstract Factory）:

抽象工厂模式是一种创建型设计模式，它提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定它们的具体类。这种模式通过提供一组接口来创建产品家族，使得客户端代码与实际创建的具体类解耦。

结构

1. 抽象工厂（Abstract Factory）：声明创建抽象产品对象的接口。
2. 具体工厂（Concrete Factory）：实现抽象工厂接口，返回一个产品家族的具体产品。
3. 抽象产品（Abstract Product）：声明一个创建产品对象的接口。
4. 具体产品（Concrete Product）：实现抽象产品接口，属于某个产品家族。

from abc import ABC, abstractmethod

class AbstractFactory(ABC):
    @abstractmethod
    def create_product_a(self):
        pass

    @abstractmethod
    def create_product_b(self):
        pass

class ConcreteFactory1(AbstractFactory):
    def create_product_a(self):
        return ConcreteProductA1()

    def create_product_b(self):
        return ConcreteProductB1()

class ConcreteFactory2(AbstractFactory):
    def create_product_a(self):
        return ConcreteProductA2()

    def create_product_b(self):
        return ConcreteProductB2()

class AbstractProductA(ABC):
    @abstractmethod
    def useful_function_a(self):
        pass

class ConcreteProductA1(AbstractProductA):
    def useful_function_a(self):
        return "The result of the product A1."

# Similar classes for ConcreteProductA2, ConcreteProductB1, ConcreteProductB2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

建造者模式（Builder）:

建造者模式是一种创建型设计模式，它允许你创建一个复杂对象的表示，而无需直接实例化该对象。建造者模式主要用于通过一个指挥者类指导整个构建过程，将构建过程与表示分离，使得相同的构建过程可以创建不同的表示。

结构

1. 产品（Product）：表示正在构建的复杂对象。
2. 抽象建造者（Builder）：声明创建产品部件的方法，并返回一个构建好的产品。
3. 具体建造者（Concrete Builder）：实现抽象建造者接口，具体定义产品部件的创建和装配方法。
4. 指挥者（Director）：负责使用建造者对象构建产品，不关心具体部件的创建过程。

class Director:
    def __init__(self):
        self.builder = None

    def construct(self, builder):
        self.builder = builder
        self.builder.build_part_a()
        self.builder.build_part_b()

class Builder:
    @abstractmethod
    def build_part_a(self):
        pass

    @abstractmethod
    def build_part_b(self):
        pass

    @abstractmethod
    def get_result(self):
        pass

class ConcreteBuilder1(Builder):
    def __init__(self):
        self.product = Product1()

    def build_part_a(self):
        self.product.add("PartA1")

    def build_part_b(self):
        self.product.add("PartB1")

    def get_result(self):
        return self.product

class ConcreteBuilder2(Builder):
    # Similar to ConcreteBuilder1
    ```

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

原型模式（Prototype）:

原型模式是一种创建型设计模式，其核心思想是通过复制（克隆）一个现有对象来创建新的对象，而不是通过实例化进行创建。这种模式适用于对象的创建成本较高，但复制的成本较低的情况。

结构

1. 原型接口（Prototype）：声明克隆方法的接口。
2. 具体原型类（Concrete Prototype）：实现原型接口，负责具体对象的克隆。
3. 客户端（Client）：使用原型接口来复制新的对象。

import copy

class Prototype:
    def clone(self):
        return copy.deepcopy(self)

class ConcretePrototype(Prototype):
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return f"ConcretePrototype: {self.value}"

1
2
3
4
5
6
7
8
9
10
11
12
13

单例模式（Singleton）:

单例模式是一种创建型设计模式，其目的是确保一个类只有一个实例，并提供一个全局访问点。

结构

1. 单例类（Singleton）：定义一个静态方法来返回唯一的实例。
2. 客户端（Client）：通过调用单例类的静态方法来获取实例。

使用场景

1. 当只允许类有一个实例，而且客户端需要一个访问点来访问该实例时。
2. 当实例化操作很昂贵，而且只需要一个实例来共享时。

特点

1. 全局唯一性：确保系统中只有一个实例。
2. 延迟实例化：实例只在需要时创建。
3. 全局访问点：提供一个全局访问的方法。

实现要点

1. 私有构造函数：确保无法通过外部直接实例化该类。
2. 私有静态实例：保存实例的引用。
3. 公有静态方法：提供获取实例的方式，如果实例不存在则创建。

class Singleton:
    _instance = None

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

1
2
3
4
5
6
7
8

2.结构型模式（Structural Patterns）:

适配器模式（Adapter）:

适配器模式是一种结构型设计模式，它允许将一个类的接口转换成客户端期望的另一个接口。这种模式允许原本由于接口不兼容而不能一起工作的类能够一起工作。

结构

1. 目标接口（Target）：定义客户端使用的特定接口。
2. 适配器（Adapter）：实现目标接口，并包装一个需要适配的类。
3. 被适配者（Adaptee）：包含需要被适配的类。

class Target:
    def request(self):
        return "Target: The default target's behavior."

class Adaptee:
    def specific_request(self):
        return ".eetpadA eht fo roivaheb laicepS"

class Adapter(Target, Adaptee):
    def request(self):
        return f"Adapter: (TRANSLATED) {self.specific_request()[::-1]}"

1
2
3
4
5
6
7
8
9
10
11
12

桥接模式（Bridge）:

桥接模式是一种结构型设计模式，它将一个抽象部分与其实现部分分离，使它们可以独立地变化。这种模式通过将继承关系转化为组合关系，从而降低了抽象和实现两个层次的耦合度。

结构

1. 抽象类（Abstraction）：定义抽象部分的接口，并维护一个指向实现部分的引用。
2. 扩充抽象类（Refined Abstraction）：扩展抽象部分的接口。
3. 实现类接口（Implementor）：定义实现部分的接口，供抽象类调用。
4. 具体实现类（Concrete Implementor）：实现实现类接口的具体类。

class Abstraction:
    def __init__(self, implementation):
        self.implementation = implementation

    def operation(self):
        return f"Abstraction: Base operation with:\n{self.implementation.operation_implementation()}"

class ExtendedAbstraction(Abstraction):
    def operation(self):
        return f"ExtendedAbstraction: Extended operation with:\n{self.implementation.operation_implementation()}"

class Implementation:
    def operation_implementation(self):
        pass

class ConcreteImplementationA(Implementation):
    def operation_implementation(self):
        return "ConcreteImplementationA: Here's the result on the platform A."

# Similar class ConcreteImplementationB

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

组合模式（Composite）:

组合模式是一种结构型设计模式，它允许将对象组合成树形结构以表示部分-整体的层次结构。通过使用组合模式，客户端可以统一对待单个对象和组合对象。

结构

1. 组件（Component）：定义抽象接口，可以包含子组件的操作。
2. 叶子（Leaf）：实现组件接口的具体类，表示叶子节点。
3. 容器（Composite）：实现组件接口的具体类，可以包含子组件。

class Component(ABC):
    @abstractmethod
    def operation(self):
        pass

class Leaf(Component):
    def operation(self):
        return "Leaf"

class Composite(Component):
    def __init__(self):
        self.children = []

    def add(self, component):
        self.children.append(component)

    def remove(self, component):
        self.children.remove(component)

    def operation(self):
        results = []
        for child in self.children:
            results.append(child.operation())
        return f"Branch({', '.join(results)})"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

装饰器模式（Decorator）:

装饰器模式是一种结构型设计模式，它允许向对象动态添加新功能，通过将对象包装在一个装饰器类的实例中，这个装饰器类可以添加额外的行为而不改变原始类的结构。

结构

1. 组件（Component）：定义一个接口，为具体组件和装饰器提供一致的接口。
2. 具体组件（Concrete Component）：实现组件接口，是被装饰的对象。
3. 装饰器（Decorator）：继承或实现组件接口，并包含一个对组件的引用，用于动态地添加新的行为。
4. 具体装饰器（Concrete Decorator）：扩展装饰器类，实现新的行为。

class Component(ABC):
    @abstractmethod
    def operation(self):
        pass

class ConcreteComponent(Component):
    def operation(self):
        return "ConcreteComponent"

class Decorator(Component):
    def __init__(self, component):
        self._component = component

    def operation(self):
        return f"Decorator({self._component.operation()})"

class ConcreteDecoratorA(Decorator):
    def operation(self):
        return f"ConcreteDecoratorA({self._component.operation()})"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

外观模式（Facade）:

外观模式是一种结构型设计模式，它为一个复杂系统提供一个简化的接口，使得系统更容易使用。外观模式通过将系统的一组接口封装在一个高层接口中，为客户端提供一个简单而一致的入口点。

结构

1. 外观（Facade）：提供简化接口的类，将客户端和系统之间的复杂性隔离开。
2. 子系统（Subsystem）：包含一组相互关联的类，负责实现子系统的功能。

class Subsystem1:
    def operation1(self):
        return "Subsystem1: Ready!"

    def operation_n(self):
        return "Subsystem1: Go!"

class Subsystem2:
    def operation1(self):
        return "Subsystem2: Get ready!"

    def operation_z(self):
        return "Subsystem2: Fire!"

class Facade:
    def __init__(self, subsystem1, subsystem2):
        self._subsystem1 = subsystem1
        self._subsystem2 = subsystem2

    def operation(self):
        results = []
        results.append(self._subsystem1.operation1())
        results.append(self._subsystem2.operation1())
        results.append(self._subsystem1.operation_n())
        results.append(self._subsystem2.operation_z())
        return "\n".join(results)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

享元模式（Flyweight）:

享元模式是一种结构型设计模式，它旨在通过共享尽可能多的对象来有效支持大量小颗粒度的对象。这种模式适用于需要创建大量相似对象的情况，以减少内存占用和提高性能。

结构

1. 享元工厂（Flyweight Factory）：维护和管理共享的享元对象，确保它们被正确地共享和重用。
2. 享元接口（Flyweight）：定义享元对象的接口。
3. 具体享元类（Concrete Flyweight）：实现享元接口，包含内部状态。
4. 非共享具体享元类（Unshared Concrete Flyweight）：并非所有享元对象都需要被共享的情况下，实现享元接口。
5. 客户端（Client）：维护享元对象的引用，如果需要，维护非共享的外部状态。

class Flyweight:
    def operation(self, extrinsic_state):
        pass

class ConcreteFlyweight(Flyweight):
    def operation(self, extrinsic_state):
        return f"ConcreteFlyweight: {extrinsic_state}"

class UnsharedConcreteFlyweight(Flyweight):
    def operation(self, extrinsic_state):
        return f"UnsharedConcreteFlyweight: {extrinsic_state}"

1
2
3
4
5
6
7
8
9
10
11
12

代理模式（Proxy）:

代理模式是一种结构型设计模式，它提供了一个代理对象，控制对其他对象的访问。代理对象充当另一个对象的接口，以控制对该对象的访问。

结构

1. 主题接口（Subject）：定义真实主题和代理的共同接口。
2. 真实主题（Real Subject）：实现主题接口，是代理所代表的真实对象。
3. 代理（Proxy）：实现主题接口，包含对真实主题的引用，并可以在需要时代替真实主题。
4. 客户端（Client）：使用代理对象的对象。

class Subject(ABC):
    @abstractmethod
    def request(self):
        pass

class RealSubject(Subject):
    def request(self):
        return "RealSubject: Handling request."

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

    def request(self):
        if self.check_access():
            return self._real_subject.request()
        else:
            return "Proxy: Access denied."

    def check_access(self):
        # Some logic to check access
        return True

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.行为型模式（Behavioral Patterns）:

责任链模式（Chain of Responsibility）:

责任链模式是一种行为型设计模式，它允许你将请求沿着处理者链传递。每个处理者决定是否处理请求或将其传递给链中的下一个处理者。

结构

1. 处理者接口（Handler）：定义处理请求的接口，通常包含一个指向下一个处理者的引用。
2. 具体处理者（Concrete Handler）：实现处理者接口，负责处理请求或将请求传递给下一个处理者。
3. 客户端（Client）：向处理者链提交请求。

class Handler(ABC):
    @abstractmethod
    def set_next(self, handler):
        pass

    @abstractmethod
    def handle_request(self, request):
        pass

class ConcreteHandler(Handler):
    def __init__(self):
        self._next_handler = None

    def set_next(self, handler):
        self._next_handler = handler
        return handler

    def handle_request(self, request):
        if self._next_handler:
            return self._next_handler.handle_request(request)
        else:
            return None

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

命令模式（Command）:

命令模式是一种行为型设计模式，它将请求封装成一个对象，使得可以参数化客户端对象，队列中的对象，或者日志中的对象，并支持撤销操作。

结构

1. 命令接口（Command）：声明执行命令的方法。
2. 具体命令类（Concrete Command）：实现命令接口，负责具体的命令操作。
3. 调用者（Invoker）：要求命令执行请求的对象，通常持有一个命令对象的引用。
4. 接收者（Receiver）：知道如何执行一个请求，实际执行操作的对象。
5. 客户端（Client）：创建命令对象并设置其接收者，将命令对象传递给调用者。

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

class ConcreteCommand(Command):
    def __init__(self, receiver):
        self._receiver = receiver

    def execute(self):
        self._receiver.action()

class Receiver:
    def action(self):
        pass

class Invoker:
    def __init__(self):
        self._command = None

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

    def execute_command(self):
        self._command.execute()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

解释器模式（Interpreter）:

解释器模式是一种行为型设计模式，它定义了一个语言的文法，并且用一个解释器来解释这个语言中的句子。

结构

1. 抽象表达式（Abstract Expression）：声明一个抽象的解释操作，是所有具体表达式的共同父类。
2. 终结符表达式（Terminal Expression）：实现了抽象表达式的解释操作，通常一个句子中的一个词。
3. 非终结符表达式（Non-terminal Expression）：实现了抽象表达式的解释操作，通常是文法中的一个复杂的规则。
4. 环境类（Context）：包含解释器之外的一些全局信息。
5. 客户端（Client）：构建表示该语言的抽象语法树，然后调用解释器解释。

class Context:
    def __init__(self):
        self._input = None
        self._output = None

class AbstractExpression(ABC):
    @abstractmethod
    def interpret(self, context):
        pass

class TerminalExpression(AbstractExpression):
    def interpret(self, context):
        pass

class NonterminalExpression(AbstractExpression):
    def interpret(self, context):
        pass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

迭代器模式（Iterator）:

迭代器模式是一种行为型设计模式，它提供一种方法顺序访问一个聚合对象中的各个元素，而不暴露其内部表示。

结构

1. 迭代器接口（Iterator）：声明访问和遍历元素的方法。
2. 具体迭代器（Concrete Iterator）：实现迭代器接口，负责追踪遍历的当前位置。
3. 可迭代对象接口（Iterable）：声明创建迭代器的方法。
4. 具体可迭代对象（Concrete Iterable）：实现可迭代对象接口，返回一个具体的迭代器。

class Iterator(ABC):
    @abstractmethod
    def first(self):
        pass

    @abstractmethod
    def next(self):
        pass

    @abstractmethod
    def is_done(self):
        pass

    @abstractmethod
    def current_item(self):
        pass

class ConcreteIterator(Iterator):
    def first(self):
        pass

    def next(self):
        pass

    def is_done(self):
        pass

    def current_item(self):
        pass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

中介者模式（Mediator）:

中介者模式是一种行为型设计模式，它定义了一个封装一组对象之间交互的中介者对象，使对象之间不直接相互通信，而是通过中介者进行通信。

结构

1. 中介者接口（Mediator）：定义一个接口用于与各同事对象通信。
2. 具体中介者（Concrete Mediator）：实现中介者接口，负责协调各同事对象的交互。
3. 同事接口（Colleague）：定义一个接口，用于与中介者进行通信。
4. 具体同事类（Concrete Colleague）：实现同事接口，每个同事类都知道中介者，并通过中介者与其他同事对象通信。

class Mediator(ABC):
    @abstractmethod
    def notify(self, colleague, event):
        pass

class ConcreteMediator(Mediator):
    def __init__(self, colleague1, colleague2):
        self._colleague1 = colleague1
        self._colleague2 = colleague2

    def notify(self, colleague, event):
        if event == "A":
            self._colleague2.handle_notification(event)
        elif event == "B":
            self._colleague1.handle_notification(event)

class Colleague(ABC):
    def __init__(self, mediator):
        self._mediator = mediator

    @abstractmethod
    def handle_notification(self, event):
        pass

class ConcreteColleague1(Colleague):
    def handle_notification(self, event):
        pass

class ConcreteColleague2(Colleague):
    def handle_notification(self, event):
        pass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

备忘录模式（Memento）:

备忘录模式是一种行为型设计模式，它允许在不暴露对象内部状态的情况下捕获并恢复对象之前的状态。这种模式通常用于需要在不破坏封装性的前提下保存和恢复对象状态的场景。

结构

1. 发起人（Originator）：负责创建备忘录，并可以使用备忘录恢复其内部状态。
2. 备忘录（Memento）：存储发起人对象的内部状态。
3. 负责人（Caretaker）：负责保存备忘录，但不能修改备忘录的内容。

class Memento:
    def __init__(self, state):
        self._state = state

    def get_state(self):
        return self._state

class Originator:
    def __init__(self, state):
        self._state = state

    def create_memento(self):
        return Memento(self._state)

    def restore(self, memento):
        self._state = memento.get_state()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

观察者模式（Observer）:

察者模式是一种行为型设计模式，它定义了对象之间的一对多依赖关系，使得当一个对象状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。

结构

1. 主题（Subject）：维护一组观察者对象，提供方法用于添加和删除观察者。
2. 具体主题（Concrete Subject）：实现主题接口，负责维护当前状态，并在状态变化时通知观察者。
3. 观察者（Observer）：定义一个更新接口，用于在主题状态变化时接收通知。
4. 具体观察者（Concrete Observer）：实现观察者接口，以便在接收到主题通知时更新自己的状态。

class Subject(ABC):
    @abstractmethod
    def attach(self, observer):
        pass

    @abstractmethod
    def detach(self, observer):
        pass

    @abstractmethod
    def notify(self):
        pass

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

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

    def detach(self, observer):
        self._observers.remove(observer)

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

class Observer(ABC):
    @abstractmethod
    def update(self):
        pass

class ConcreteObserver(Observer):
    def update(self):
        pass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

状态模式（State）:

状态模式（State Pattern）是一种行为设计模式，它允许对象在内部状态改变时改变其行为，使对象看起来好像修改了其类。这种模式属于行为型模式。

在状态模式中，一个对象可以在其内部状态发生变化时改变其行为，而客户端代码在使用对象时可以无需关心其内部状态的变化。这通过定义一系列表示不同状态的类来实现，然后将这些状态的对象委托给主对象。主对象在运行时可以切换当前状态，从而改变其行为。

结构:

1. Context（上下文）： 它维护一个对抽象状态类的引用，这个状态代表了Context的当前状态。Context可以通过将请求委托给当前状态对象来改变其内部状态。
2. State（状态）： 它是一个接口或抽象类，定义了一个特定状态下的行为。
3. ConcreteState（具体状态）： 它是State接口的具体实现，每个具体状态都提供了一种与Context关联的行为。

通过使用状态模式，可以使得一个对象在不同的状态下表现出不同的行为，而且可以较为灵活地添加新的状态，而不需要修改已有的代码。这有助于将复杂的状态机逻辑分割成小块，使系统更易于理解和维护。

class State(ABC):
    @abstractmethod
    def handle(self):
        pass

class ConcreteStateA(State):
    def handle(self):
        pass

class ConcreteStateB(State):
    def handle(self):
        pass

class Context:
    def __init__(self, state):
        self._state = state

    def request(self):
        self._state.handle()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

策略模式（Strategy）:

策略模式（Strategy Pattern）是一种行为设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以互相替换，使得客户端代码可以独立于具体的算法而变化。这种模式属于行为型模式。

在策略模式中，算法被封装成一个个的策略类，这些策略类都实现了一个共同的接口或继承自一个共同的抽象类。然后，客户端可以在运行时选择使用哪个策略，使得算法的选择可以动态变化。

结构:

1. Context（上下文）： 它包含一个对策略对象的引用，可以在运行时切换不同的策略。
2. Strategy（策略）： 它是一个接口或抽象类，定义了一个算法族，可以在Context中被使用。
3. ConcreteStrategy（具体策略）： 它是Strategy接口的具体实现，实现了具体的算法。

通过使用策略模式，可以使得算法独立于其使用者，且易于扩展。客户端代码可以根据需要选择不同的策略，而不需要修改原有的代码。

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

class ConcreteStrategyA(Strategy):
    def execute(self):
        pass

class ConcreteStrategyB(Strategy):
    def execute(self):
        pass

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

    def execute_strategy(self):
        self._strategy.execute()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

模板方法模式（Template Method）:

模板方法模式（Template Method Pattern）是一种行为设计模式，它定义了一个算法的骨架，但将一些步骤的具体实现延迟到子类。这种模式属于行为型模式。

在模板方法模式中，定义一个算法的骨架，将一些具体步骤的实现交给子类。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

结构：

1. AbstractClass（抽象类）： 它定义了一个算法的骨架，其中包含了一些具体步骤，但这些具体步骤的实现可以由子类延迟实现。
2. ConcreteClass（具体类）： 它是AbstractClass的子类，负责实现AbstractClass中的抽象方法，完成算法中具体的步骤。

通过使用模板方法模式，可以在不改变算法整体结构的情况下，让子类提供算法中某些步骤的具体实现。这使得代码更具灵活性和可维护性。

class AbstractClass(ABC):
    @abstractmethod
    def primitive_operation1(self):
        pass

    @abstractmethod
    def primitive_operation2(self):
        pass

    def template_method(self):
        self.primitive_operation1()
        self.primitive_operation2()

class ConcreteClassA(AbstractClass):
    def primitive_operation1(self):
        pass

    def primitive_operation2(self):
        pass

class ConcreteClassB(AbstractClass):
    def primitive_operation1(self):
        pass

    def primitive

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

访问者模式（Visitor Pattern）:

访问者模式（Visitor Pattern）是一种行为设计模式，它允许定义在不改变元素类的前提下定义新操作。这种模式属于行为型模式。

在访问者模式中，将算法与数据结构分离。定义一个访问者类，该访问者类封装了对元素的一些操作，而元素类中则有一个接受访问者的方法。这样，在不修改元素类的前提下，可以通过创建不同的访问者来实现不同的操作。

结构：

1. Visitor（访问者）： 它是一个接口或抽象类，定义了对各种元素的访问操作，具体的访问者类实现了这些操作。
2. ConcreteVisitor（具体访问者）： 它是Visitor接口的具体实现，实现了对具体元素的访问操作。
3. Element（元素）： 它是一个接口或抽象类，定义了接受访问者的方法，具体的元素类实现了这个方法。
4. ConcreteElement（具体元素）： 它是Element接口的具体实现，实现了接受访问者的方法。
5. ObjectStructure（对象结构）： 它是元素的集合，提供一个接口让访问者访问它的元素。这可以是一个集合，列表，树等。

通过使用访问者模式，可以在不改变元素类的情况下定义新的操作，而且可以轻松地添加新的访问者，以实现不同的操作。

from abc import ABC, abstractmethod

# Element接口
class Element(ABC):
    @abstractmethod
    def accept(self, visitor):
        pass

# 具体元素A
class ConcreteElementA(Element):
    def accept(self, visitor):
        visitor.visit_concrete_element_a(self)

# 具体元素B
class ConcreteElementB(Element):
    def accept(self, visitor):
        visitor.visit_concrete_element_b(self)

# Visitor接口
class Visitor(ABC):
    @abstractmethod
    def visit_concrete_element_a(self, element):
        pass

    @abstractmethod
    def visit_concrete_element_b(self, element):
        pass

# 具体访问者1
class ConcreteVisitor1(Visitor):
    def visit_concrete_element_a(self, element):
        print("ConcreteVisitor1 visiting ConcreteElementA")

    def visit_concrete_element_b(self, element):
        print("ConcreteVisitor1 visiting ConcreteElementB")

# 具体访问者2
class ConcreteVisitor2(Visitor):
    def visit_concrete_element_a(self, element):
        print("ConcreteVisitor2 visiting ConcreteElementA")

    def visit_concrete_element_b(self, element):
        print("ConcreteVisitor2 visiting ConcreteElementB")

# 对象结构，包含元素的集合
class ObjectStructure:
    def __init__(self):
        self.elements = []

    def attach(self, element):
        self.elements.append(element)

    def accept(self, visitor):
        for element in self.elements:
            element.accept(visitor)

# 使用
element_a = ConcreteElementA()
element_b = ConcreteElementB()

object_structure = ObjectStructure()
object_structure.attach(element_a)
object_structure.attach(element_b)

visitor1 = ConcreteVisitor1()
visitor2 = ConcreteVisitor2()

object_structure.accept(visitor1)
object_structure.accept(visitor2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

---------------------------END---------------------------

题外话

感谢你能看到最后，给大家准备了一些福利！

感兴趣的小伙伴，赠送全套Python学习资料，包含面试题、简历资料等具体看下方。