Python 设计模式完全指南：创建型 / 结构型 / 行为型模式详解与实战

设计模式是解决特定问题的经典解决方案，是软件设计的最佳实践。Python 作为一门灵活的面向对象语言，提供了丰富的设计模式实现方式。本文全面讲解 23 种设计模式，每个模式提供完整代码示例和实际应用场景。

本文内容包括：

创建型模式（5 种）
结构型模式（7 种）
行为型模式（11 种）
设计模式选择指南
Python 设计模式最佳实践

一、创建型模式（Creational Patterns）#

创建型模式关注对象的创建过程，将对象的创建与使用分离。

1.1 单例模式（Singleton）#

确保类只有一个实例，并提供全局访问点。

1
# 方法1：使用 __new__
2
class Singleton:
3
    _instance = None
4

5
    def __new__(cls, *args, **kwargs):
6
        if cls._instance is None:
7
            cls._instance = super().__new__(cls)
8
        return cls._instance
9

10
# 方法2：线程安全单例
11
import threading
12

13
class ThreadSafeSingleton:
14
    _instance = None
15
    _lock = threading.Lock()
16

17
    def __new__(cls, *args, **kwargs):
18
        with cls._lock:
19
            if cls._instance is None:
20
                cls._instance = super().__new__(cls)
21
        return cls._instance
22

23
# 方法3：使用 metaclass
24
class SingletonMeta(type):
25
    _instances = {}
26

27
    def __call__(cls, *args, **kwargs):
28
        if cls not in cls._instances:
29
            cls._instances[cls] = super().__call__(*args, **kwargs)
30
        return cls._instances[cls]
31

32
class Logger(metaclass=SingletonMeta):
33
    def log(self, message):
34
        print(f"[LOG] {message}")
35

36
# 方法4：使用模块（Python 最简洁方式）
37
# logger.py
38
# logger = Logger()
39
# import logger; logger.log("hello")
40

41
# 使用
42
logger1 = Logger()
43
logger2 = Logger()
44
print(logger1 is logger2)  # True

应用场景：日志记录器、数据库连接池、配置管理器、全局缓存。

1.2 工厂模式（Factory）#

将对象创建封装在工厂类中，根据参数返回不同类型的对象。

1
from abc import ABC, abstractmethod
2

3
# 抽象产品
4
class Product(ABC):
5
    @abstractmethod
6
    def operation(self) -> str:
7
        pass
8

9
# 具体产品
10
class ConcreteProductA(Product):
11
    def operation(self) -> str:
12
        return "Result of ConcreteProductA"
13

14
class ConcreteProductB(Product):
15
    def operation(self) -> str:
16
        return "Result of ConcreteProductB"
17

18
# 工厂类
19
class Factory:
20
    def create(self, type: str) -> Product:
21
        if type == "A":
22
            return ConcreteProductA()
23
        elif type == "B":
24
            return ConcreteProductB()
25
        raise ValueError(f"Unknown type: {type}")
26

27
# 使用
28
factory = Factory()
29
product_a = factory.create("A")
30
product_b = factory.create("B")
31
print(product_a.operation())  # Result of ConcreteProductA

应用场景：数据库连接创建、文件解析器、UI 组件创建。

1.3 抽象工厂模式（Abstract Factory）#

提供创建一系列相关或依赖对象的接口，无需指定具体类。

1
from abc import ABC, abstractmethod
2

3
# 抽象工厂
4
class AbstractFactory(ABC):
5
    @abstractmethod
6
    def create_product_a(self):
7
        pass
8

9
    @abstractmethod
10
    def create_product_b(self):
11
        pass
12

13
# 具体工厂1
14
class ConcreteFactory1(AbstractFactory):
15
    def create_product_a(self):
16
        return ProductA1()
17

18
    def create_product_b(self):
19
        return ProductB1()
20

21
# 具体工厂2
22
class ConcreteFactory2(AbstractFactory):
23
    def create_product_a(self):
24
        return ProductA2()
25

26
    def create_product_b(self):
27
        return ProductB2()
28

29
# 产品族
30
class ProductA1:
31
    def interact(self, other):
32
        return f"A1 interacts with {other.__class__.__name__}"
33

34
class ProductB1:
35
    def interact(self, other):
36
        return f"B1 interacts with {other.__class__.__name__}"
37

38
class ProductA2:
39
    def interact(self, other):
40
        return f"A2 interacts with {other.__class__.__name__}"
41

42
class ProductB2:
43
    def interact(self, other):
44
        return f"B2 interacts with {other.__class__.__name__}"
45

46
# 使用
47
factory1 = ConcreteFactory1()
48
a1 = factory1.create_product_a()
49
b1 = factory1.create_product_b()
50
print(a1.interact(b1))  # A1 interacts with ProductB1

应用场景：跨平台 UI 组件、数据库驱动、主题系统。

1.4 建造者模式（Builder）#

将复杂对象的构建过程与表示分离，使同样的构建过程可以创建不同的表示。

1
from abc import ABC, abstractmethod
2

3
# 产品
4
class Computer:
5
    def __init__(self):
6
        self.cpu = None
7
        self.memory = None
8
        self.storage = None
9
        self.gpu = None
10

11
    def __str__(self):
12
        return f"Computer: CPU={self.cpu}, Memory={self.memory}, Storage={self.storage}, GPU={self.gpu}"
13

14
# 抽象建造者
15
class Builder(ABC):
16
    @abstractmethod
17
    def build_cpu(self):
18
        pass
19

20
    @abstractmethod
21
    def build_memory(self):
22
        pass
23

24
    @abstractmethod
25
    def build_storage(self):
26
        pass
27

28
    @abstractmethod
29
    def build_gpu(self):
30
        pass
31

32
    @abstractmethod
33
    def get_product(self) -> Computer:
34
        pass
35

36
# 具体建造者
37
class GamingBuilder(Builder):
38
    def __init__(self):
39
        self.computer = Computer()
40

41
    def build_cpu(self):
42
        self.computer.cpu = "Intel i9-14900K"
43

44
    def build_memory(self):
45
        self.computer.memory = "32GB DDR5"
46

47
    def build_storage(self):
48
        self.computer.storage = "2TB NVMe"
49

50
    def build_gpu(self):
51
        self.computer.gpu = "NVIDIA RTX 4090"
52

53
    def get_product(self):
54
        return self.computer
55

56
class OfficeBuilder(Builder):
57
    def __init__(self):
58
        self.computer = Computer()
59

60
    def build_cpu(self):
61
        self.computer.cpu = "Intel i5-14600K"
62

63
    def build_memory(self):
64
        self.computer.memory = "16GB DDR4"
65

66
    def build_storage(self):
67
        self.computer.storage = "512GB SSD"
68

69
    def build_gpu(self):
70
        self.computer.gpu = "Integrated"
71

72
    def get_product(self):
73
        return self.computer
74

75
# 指挥者
76
class Director:
77
    def __init__(self, builder: Builder):
78
        self.builder = builder
79

80
    def construct(self):
81
        self.builder.build_cpu()
82
        self.builder.build_memory()
83
        self.builder.build_storage()
84
        self.builder.build_gpu()
85

86
# 使用
87
gaming_builder = GamingBuilder()
88
director = Director(gaming_builder)
89
director.construct()
90
gaming_pc = gaming_builder.get_product()
91
print(gaming_pc)

应用场景：复杂对象构建（电脑、汽车、报表）、配置对象、API 请求构建。

1.5 原型模式（Prototype）#

通过复制现有对象创建新对象，避免重复初始化。

1
import copy
2

3
class Prototype:
4
    def clone(self):
5
        return copy.deepcopy(self)
6

7
class User(Prototype):
8
    def __init__(self, name, roles=None):
9
        self.name = name
10
        self.roles = roles or []
11

12
    def __str__(self):
13
        return f"User: {self.name}, Roles: {self.roles}"
14

15
# 使用
16
base_user = User("Admin", ["admin", "user"])
17
user1 = base_user.clone()
18
user1.name = "Alice"
19
user1.roles.append("editor")
20

21
user2 = base_user.clone()
22
user2.name = "Bob"
23

24
print(base_user)  # User: Admin, Roles: ['admin', 'user']
25
print(user1)      # User: Alice, Roles: ['admin', 'user', 'editor']
26
print(user2)      # User: Bob, Roles: ['admin', 'user']

应用场景：大量相似对象创建、对象初始化成本高、配置模板。

二、结构型模式（Structural Patterns）#

结构型模式关注类或对象的组合，形成更大的结构。

2.1 适配器模式（Adapter）#

将一个类的接口转换成客户希望的另一个接口。

1
# 目标接口
2
class Target:
3
    def request(self) -> str:
4
        return "Target: Default request"
5

6
# 适配者（被适配的类）
7
class Adaptee:
8
    def specific_request(self) -> str:
9
        return ".eetpadA eht fo esuac siht"
10

11
# 适配器
12
class Adapter(Target):
13
    def __init__(self, adaptee: Adaptee):
14
        self.adaptee = adaptee
15

16
    def request(self) -> str:
17
        return f"Adapter: {self.adaptee.specific_request()[::-1]}"
18

19
# 使用
20
adaptee = Adaptee()
21
adapter = Adapter(adaptee)
22
print(adapter.request())  # Adapter: This is the cause of the Adapter.

应用场景：旧代码兼容新接口、第三方库集成、接口转换。

2.2 装饰器模式（Decorator）#

动态地给对象添加额外功能。

1
from abc import ABC, abstractmethod
2

3
# 抽象组件
4
class Component(ABC):
5
    @abstractmethod
6
    def operation(self) -> str:
7
        pass
8

9
# 具体组件
10
class ConcreteComponent(Component):
11
    def operation(self) -> str:
12
        return "ConcreteComponent"
13

14
# 抽象装饰器
15
class Decorator(Component):
16
    def __init__(self, component: Component):
17
        self.component = component
18

19
    @abstractmethod
20
    def operation(self) -> str:
21
        return self.component.operation()
22

23
# 具体装饰器
24
class ConcreteDecoratorA(Decorator):
25
    def operation(self) -> str:
26
        return f"ConcreteDecoratorA({self.component.operation()})"
27

28
class ConcreteDecoratorB(Decorator):
29
    def operation(self) -> str:
30
        return f"ConcreteDecoratorB({self.component.operation()})"
31

32
# 使用
33
component = ConcreteComponent()
34
decorated = ConcreteDecoratorB(ConcreteDecoratorA(component))
35
print(decorated.operation())
36
# ConcreteDecoratorB(ConcreteDecoratorA(ConcreteComponent))
37

38
# Python 语法糖装饰器
39
def bold(func):
40
    def wrapper(*args, **kwargs):
41
        return f"<b>{func(*args, **kwargs)}</b>"
42
    return wrapper
43

44
def italic(func):
45
    def wrapper(*args, **kwargs):
46
        return f"<i>{func(*args, **kwargs)}</i>"
47
    return wrapper
48

49
@bold
50
@italic
51
def greet(name):
52
    return f"Hello, {name}"
53

54
print(greet("Alice"))  # <b><i>Hello, Alice</i></b>

应用场景：功能增强、日志记录、性能监控、权限验证。

2.3 代理模式（Proxy）#

为其他对象提供代理，控制对原对象的访问。

1
from abc import ABC, abstractmethod
2

3
# 抽象主题
4
class Subject(ABC):
5
    @abstractmethod
6
    def request(self):
7
        pass
8

9
# 真实主题
10
class RealSubject(Subject):
11
    def request(self):
12
        print("RealSubject: Handling request")
13

14
# 代理
15
class Proxy(Subject):
16
    def __init__(self, real_subject: RealSubject):
17
        self.real_subject = real_subject
18

19
    def request(self):
20
        if self.check_access():
21
            self.log_access()
22
            self.real_subject.request()
23

24
    def check_access(self) -> bool:
25
        print("Proxy: Checking access prior to firing a request.")
26
        return True
27

28
    def log_access(self):
29
        print("Proxy: Logging the time of request.")
30

31
# 使用
32
proxy = Proxy(RealSubject())
33
proxy.request()

应用场景：延迟加载、访问控制、缓存、日志记录、远程代理。

2.4 组合模式（Composite）#

将对象组合成树形结构，以表示”部分-整体”的层次结构。

1
from abc import ABC, abstractmethod
2
from typing import List
3

4
class Component(ABC):
5
    def __init__(self, name):
6
        self.name = name
7

8
    @abstractmethod
9
    def operation(self, depth=0):
10
        pass
11

12
    def add(self, component):
13
        pass
14

15
    def remove(self, component):
16
        pass
17

18
class Leaf(Component):
19
    def operation(self, depth=0):
20
        print("  " * depth + f"- Leaf: {self.name}")
21

22
class Composite(Component):
23
    def __init__(self, name):
24
        super().__init__(name)
25
        self.children: List[Component] = []
26

27
    def add(self, component: Component):
28
        self.children.append(component)
29

30
    def remove(self, component: Component):
31
        self.children.remove(component)
32

33
    def operation(self, depth=0):
34
        print("  " * depth + f"+ Composite: {self.name}")
35
        for child in self.children:
36
            child.operation(depth + 1)
37

38
# 使用
39
root = Composite("Root")
40
branch1 = Composite("Branch1")
41
branch2 = Composite("Branch2")
42

43
leaf1 = Leaf("Leaf1")
44
leaf2 = Leaf("Leaf2")
45
leaf3 = Leaf("Leaf3")
46

47
branch1.add(leaf1)
48
branch1.add(leaf2)
49
branch2.add(leaf3)
50
root.add(branch1)
51
root.add(branch2)
52

53
root.operation()
54
# + Composite: Root
55
#   + Composite: Branch1
56
#     - Leaf: Leaf1
57
#     - Leaf: Leaf2
58
#   + Composite: Branch2
59
#     - Leaf: Leaf3

应用场景：文件系统、UI 组件树、菜单系统、组织架构。

2.5 外观模式（Facade）#

为子系统中的一组接口提供一个统一的高层接口。

1
class SubsystemA:
2
    def operation_a(self):
3
        return "SubsystemA: Operation A"
4

5
class SubsystemB:
6
    def operation_b(self):
7
        return "SubsystemB: Operation B"
8

9
class SubsystemC:
10
    def operation_c(self):
11
        return "SubsystemC: Operation C"
12

13
class Facade:
14
    def __init__(self):
15
        self.subsystem_a = SubsystemA()
16
        self.subsystem_b = SubsystemB()
17
        self.subsystem_c = SubsystemC()
18

19
    def operation(self):
20
        results = []
21
        results.append(self.subsystem_a.operation_a())
22
        results.append(self.subsystem_b.operation_b())
23
        results.append(self.subsystem_c.operation_c())
24
        return "\n".join(results)
25

26
# 使用
27
facade = Facade()
28
print(facade.operation())
29
# SubsystemA: Operation A
30
# SubsystemB: Operation B
31
# SubsystemC: Operation C

应用场景：简化复杂系统接口、第三方库封装、模块入口。

2.6 桥接模式（Bridge）#

将抽象与实现分离，使它们可以独立变化。

1
from abc import ABC, abstractmethod
2

3
# 实现接口
4
class Implementation(ABC):
5
    @abstractmethod
6
    def operation_impl(self) -> str:
7
        pass
8

9
class ConcreteImplementationA(Implementation):
10
    def operation_impl(self) -> str:
11
        return "ConcreteImplementationA"
12

13
class ConcreteImplementationB(Implementation):
14
    def operation_impl(self) -> str:
15
        return "ConcreteImplementationB"
16

17
# 抽象类
18
class Abstraction:
19
    def __init__(self, implementation: Implementation):
20
        self.implementation = implementation
21

22
    def operation(self) -> str:
23
        return f"Abstraction: Base operation with {self.implementation.operation_impl()}"
24

25
# 扩展抽象类
26
class ExtendedAbstraction(Abstraction):
27
    def operation(self) -> str:
28
        return f"ExtendedAbstraction: Extended operation with {self.implementation.operation_impl()}"
29

30
# 使用
31
impl_a = ConcreteImplementationA()
32
impl_b = ConcreteImplementationB()
33

34
abstraction = Abstraction(impl_a)
35
print(abstraction.operation())
36

37
extended = ExtendedAbstraction(impl_b)
38
print(extended.operation())

应用场景：跨平台开发、UI 框架、数据库驱动。

2.7 享元模式（Flyweight）#

运用共享技术有效地支持大量细粒度的对象。

1
import json
2
from typing import Dict
3

4
class Flyweight:
5
    def __init__(self, shared_state: str):
6
        self.shared_state = shared_state
7

8
    def operation(self, unique_state: str):
9
        s = json.dumps(self.shared_state)
10
        u = json.dumps(unique_state)
11
        return f"Flyweight: Shared={s}, Unique={u}"
12

13
class FlyweightFactory:
14
    _flyweights: Dict[str, Flyweight] = {}
15

16
    def get_flyweight(self, shared_state: str) -> Flyweight:
17
        if shared_state not in self._flyweights:
18
            self._flyweights[shared_state] = Flyweight(shared_state)
19
        return self._flyweights[shared_state]
20

21
    def list_flyweights(self):
22
        return len(self._flyweights)
23

24
# 使用
25
factory = FlyweightFactory()
26

27
# 创建享元对象
28
flyweight1 = factory.get_flyweight("shared_state_1")
29
flyweight2 = factory.get_flyweight("shared_state_1")
30
flyweight3 = factory.get_flyweight("shared_state_2")
31

32
print(flyweight1 is flyweight2)  # True（同一对象）
33
print(flyweight1 is flyweight3)  # False（不同对象）
34

35
# 统计创建的对象数量
36
print(f"Flyweights created: {factory.list_flyweights()}")  # 2

应用场景：大量相似对象（字符、图形、棋子）、缓存系统、连接池。

三、行为型模式（Behavioral Patterns）#

行为型模式关注对象间的通信和职责分配。

3.1 观察者模式（Observer）#

定义对象间的一对多依赖，当一个对象状态改变时，所有依赖者都会收到通知。

1
from abc import ABC, abstractmethod
2
from typing import List
3

4
class Subject(ABC):
5
    @abstractmethod
6
    def attach(self, observer):
7
        pass
8

9
    @abstractmethod
10
    def detach(self, observer):
11
        pass
12

13
    @abstractmethod
14
    def notify(self):
15
        pass
16

17
class ConcreteSubject(Subject):
18
    def __init__(self):
19
        self._observers: List[Observer] = []
20
        self._state = None
21

22
    @property
23
    def state(self):
24
        return self._state
25

26
    @state.setter
27
    def state(self, value):
28
        self._state = value
29
        self.notify()
30

31
    def attach(self, observer):
32
        if observer not in self._observers:
33
            self._observers.append(observer)
34

35
    def detach(self, observer):
36
        self._observers.remove(observer)
37

38
    def notify(self):
39
        for observer in self._observers:
40
            observer.update(self)
41

42
class Observer(ABC):
43
    @abstractmethod
44
    def update(self, subject):
45
        pass
46

47
class ConcreteObserverA(Observer):
48
    def update(self, subject):
49
        if subject.state < 3:
50
            print("ConcreteObserverA: Reacted to the event")
51

52
class ConcreteObserverB(Observer):
53
    def update(self, subject):
54
        if subject.state >= 3:
55
            print("ConcreteObserverB: Reacted to the event")
56

57
# 使用
58
subject = ConcreteSubject()
59
observer_a = ConcreteObserverA()
60
observer_b = ConcreteObserverB()
61

62
subject.attach(observer_a)
63
subject.attach(observer_b)
64

65
subject.state = 2  # ConcreteObserverA: Reacted to the event
66
subject.state = 4  # ConcreteObserverB: Reacted to the event
67

68
# Python 内置 Observer（weakref）
69
from weakref import WeakKeyDictionary
70

71
class EventManager:
72
    def __init__(self):
73
        self._listeners = WeakKeyDictionary()
74

75
    def register(self, listener):
76
        self._listeners[listener] = True
77

78
    def unregister(self, listener):
79
        del self._listeners[listener]
80

81
    def notify(self, event):
82
        for listener in list(self._listeners.keys()):
83
            listener.on_event(event)
84

85
class Listener:
86
    def on_event(self, event):
87
        print(f"Listener received: {event}")

应用场景：事件系统、发布订阅、GUI 组件、日志系统、消息队列。

3.2 策略模式（Strategy）#

定义一系列算法，把它们封装起来，并使它们可以互相替换。

1
from abc import ABC, abstractmethod
2

3
class Strategy(ABC):
4
    @abstractmethod
5
    def execute(self, data):
6
        pass
7

8
class ConcreteStrategyA(Strategy):
9
    def execute(self, data):
10
        return sorted(data)
11

12
class ConcreteStrategyB(Strategy):
13
    def execute(self, data):
14
        return sorted(data, reverse=True)
15

16
class ConcreteStrategyC(Strategy):
17
    def execute(self, data):
18
        return list(set(data))
19

20
class Context:
21
    def __init__(self, strategy: Strategy):
22
        self._strategy = strategy
23

24
    @property
25
    def strategy(self):
26
        return self._strategy
27

28
    @strategy.setter
29
    def strategy(self, strategy: Strategy):
30
        self._strategy = strategy
31

32
    def do_something(self, data):
33
        return self._strategy.execute(data)
34

35
# 使用
36
data = [3, 1, 4, 1, 5, 9]
37

38
context = Context(ConcreteStrategyA())
39
print(context.do_something(data))  # [1, 1, 3, 4, 5, 9]
40

41
context.strategy = ConcreteStrategyB()
42
print(context.do_something(data))  # [9, 5, 4, 3, 1, 1]
43

44
context.strategy = ConcreteStrategyC()
45
print(context.do_something(data))  # [1, 3, 4, 5, 9]

应用场景：算法切换、排序策略、支付方式、日志级别。

3.3 命令模式（Command）#

将请求封装成对象，使你可以用不同的请求对客户进行参数化。

1
from abc import ABC, abstractmethod
2

3
class Receiver:
4
    def action(self):
5
        print("Receiver: Performing action")
6

7
class Command(ABC):
8
    @abstractmethod
9
    def execute(self):
10
        pass
11

12
    @abstractmethod
13
    def undo(self):
14
        pass
15

16
class ConcreteCommand(Command):
17
    def __init__(self, receiver: Receiver):
18
        self.receiver = receiver
19

20
    def execute(self):
21
        self.receiver.action()
22

23
    def undo(self):
24
        print("ConcreteCommand: Undoing action")
25

26
class Invoker:
27
    def __init__(self):
28
        self._commands = []
29

30
    def add_command(self, command: Command):
31
        self._commands.append(command)
32

33
    def execute_commands(self):
34
        for command in self._commands:
35
            command.execute()
36

37
    def undo_commands(self):
38
        for command in reversed(self._commands):
39
            command.undo()
40

41
# 使用
42
receiver = Receiver()
43
command = ConcreteCommand(receiver)
44
invoker = Invoker()
45
invoker.add_command(command)
46

47
invoker.execute_commands()  # Receiver: Performing action
48
invoker.undo_commands()     # ConcreteCommand: Undoing action

应用场景：撤销/重做、事务管理、菜单命令、任务队列。

3.4 责任链模式（Chain of Responsibility）#

将请求沿着处理链传递，直到有一个处理器处理它。

1
from abc import ABC, abstractmethod
2

3
class Handler(ABC):
4
    def __init__(self):
5
        self._next_handler = None
6

7
    def set_next(self, handler):
8
        self._next_handler = handler
9
        return handler
10

11
    @abstractmethod
12
    def handle(self, request):
13
        pass
14

15
class ConcreteHandlerA(Handler):
16
    def handle(self, request):
17
        if request < 10:
18
            print(f"ConcreteHandlerA handled request: {request}")
19
        elif self._next_handler:
20
            self._next_handler.handle(request)
21

22
class ConcreteHandlerB(Handler):
23
    def handle(self, request):
24
        if 10 <= request < 20:
25
            print(f"ConcreteHandlerB handled request: {request}")
26
        elif self._next_handler:
27
            self._next_handler.handle(request)
28

29
class ConcreteHandlerC(Handler):
30
    def handle(self, request):
31
        if request >= 20:
32
            print(f"ConcreteHandlerC handled request: {request}")
33
        elif self._next_handler:
34
            self._next_handler.handle(request)
35

36
# 使用
37
handler_a = ConcreteHandlerA()
38
handler_b = ConcreteHandlerB()
39
handler_c = ConcreteHandlerC()
40

41
handler_a.set_next(handler_b).set_next(handler_c)
42

43
handler_a.handle(5)   # ConcreteHandlerA handled request: 5
44
handler_a.handle(15)  # ConcreteHandlerB handled request: 15
45
handler_a.handle(25)  # ConcreteHandlerC handled request: 25

应用场景：日志级别、权限验证、请求处理管道、中间件。

3.5 状态模式（State）#

允许对象在其内部状态改变时改变它的行为。

1
from abc import ABC, abstractmethod
2

3
class Context:
4
    def __init__(self, state):
5
        self._state = state
6

7
    @property
8
    def state(self):
9
        return self._state
10

11
    @state.setter
12
    def state(self, state):
13
        self._state = state
14
        print(f"Context: Transition to {type(state).__name__}")
15

16
    def request(self):
17
        self._state.handle(self)
18

19
class State(ABC):
20
    @abstractmethod
21
    def handle(self, context):
22
        pass
23

24
class ConcreteStateA(State):
25
    def handle(self, context):
26
        print("ConcreteStateA: Handling request")
27
        context.state = ConcreteStateB()
28

29
class ConcreteStateB(State):
30
    def handle(self, context):
31
        print("ConcreteStateB: Handling request")
32
        context.state = ConcreteStateA()
33

34
# 使用
35
context = Context(ConcreteStateA())
36
context.request()  # Transition to ConcreteStateB
37
context.request()  # Transition to ConcreteStateA

应用场景：状态机、工作流、游戏状态、UI 状态。

3.6 模板方法模式（Template Method）#

定义算法骨架，将某些步骤延迟到子类实现。

1
from abc import ABC, abstractmethod
2

3
class AbstractClass(ABC):
4
    def template_method(self):
5
        self.base_operation1()
6
        self.required_operations1()
7
        self.base_operation2()
8
        self.hook1()
9
        self.required_operations2()
10
        self.base_operation3()
11
        self.hook2()
12

13
    def base_operation1(self):
14
        print("AbstractClass: Base operation 1")
15

16
    def base_operation2(self):
17
        print("AbstractClass: Base operation 2")
18

19
    def base_operation3(self):
20
        print("AbstractClass: Base operation 3")
21

22
    @abstractmethod
23
    def required_operations1(self):
24
        pass
25

26
    @abstractmethod
27
    def required_operations2(self):
28
        pass
29

30
    def hook1(self):
31
        pass
32

33
    def hook2(self):
34
        pass
35

36
class ConcreteClass(AbstractClass):
37
    def required_operations1(self):
38
        print("ConcreteClass: Required operation 1")
39

40
    def required_operations2(self):
41
        print("ConcreteClass: Required operation 2")
42

43
    def hook1(self):
44
        print("ConcreteClass: Overridden hook 1")
45

46
# 使用
47
concrete = ConcreteClass()
48
concrete.template_method()

应用场景：框架设计、算法标准化、代码复用。

3.7 迭代器模式（Iterator）#

提供一种方法顺序访问聚合对象中的各个元素，而又不暴露该对象的内部表示。

1
from abc import ABC, abstractmethod
2
from typing import List, Any
3

4
class Iterator(ABC):
5
    @abstractmethod
6
    def has_next(self) -> bool:
7
        pass
8

9
    @abstractmethod
10
    def next(self) -> Any:
11
        pass
12

13
class ConcreteIterator(Iterator):
14
    def __init__(self, collection: List[Any]):
15
        self._collection = collection
16
        self._index = 0
17

18
    def has_next(self) -> bool:
19
        return self._index < len(self._collection)
20

21
    def next(self) -> Any:
22
        item = self._collection[self._index]
23
        self._index += 1
24
        return item
25

26
class Aggregate(ABC):
27
    @abstractmethod
28
    def create_iterator(self) -> Iterator:
29
        pass
30

31
class ConcreteAggregate(Aggregate):
32
    def __init__(self):
33
        self._items: List[Any] = []
34

35
    def add_item(self, item):
36
        self._items.append(item)
37

38
    def create_iterator(self) -> Iterator:
39
        return ConcreteIterator(self._items)
40

41
# 使用
42
aggregate = ConcreteAggregate()
43
aggregate.add_item("Item 1")
44
aggregate.add_item("Item 2")
45
aggregate.add_item("Item 3")
46

47
iterator = aggregate.create_iterator()
48
while iterator.has_next():
49
    print(iterator.next())
50

51
# Python 内置迭代器
52
for item in aggregate._items:
53
    print(item)

应用场景：集合遍历、自定义数据结构、分页处理。

3.8 访问者模式（Visitor）#

表示对某对象结构中各元素执行的操作，可在不改变元素类的前提下定义新操作。

1
from abc import ABC, abstractmethod
2
from typing import List
3

4
class Element(ABC):
5
    @abstractmethod
6
    def accept(self, visitor):
7
        pass
8

9
class ConcreteElementA(Element):
10
    def accept(self, visitor):
11
        visitor.visit_concrete_element_a(self)
12

13
class ConcreteElementB(Element):
14
    def accept(self, visitor):
15
        visitor.visit_concrete_element_b(self)
16

17
class Visitor(ABC):
18
    @abstractmethod
19
    def visit_concrete_element_a(self, element):
20
        pass
21

22
    @abstractmethod
23
    def visit_concrete_element_b(self, element):
24
        pass
25

26
class ConcreteVisitor(Visitor):
27
    def visit_concrete_element_a(self, element):
28
        print("ConcreteVisitor: Visiting ConcreteElementA")
29

30
    def visit_concrete_element_b(self, element):
31
        print("ConcreteVisitor: Visiting ConcreteElementB")
32

33
# 使用
34
elements: List[Element] = [ConcreteElementA(), ConcreteElementB()]
35
visitor = ConcreteVisitor()
36

37
for element in elements:
38
    element.accept(visitor)

应用场景：数据导出、报表生成、操作扩展。

3.9 中介者模式（Mediator）#

定义一个中介对象来封装一系列对象的交互。

1
from abc import ABC, abstractmethod
2

3
class Mediator(ABC):
4
    @abstractmethod
5
    def notify(self, sender, event):
6
        pass
7

8
class ConcreteMediator(Mediator):
9
    def __init__(self):
10
        self._components = []
11

12
    def add_component(self, component):
13
        self._components.append(component)
14
        component.mediator = self
15

16
    def notify(self, sender, event):
17
        for component in self._components:
18
            if component != sender:
19
                component.receive(event)
20

21
class Component:
22
    def __init__(self, name):
23
        self.name = name
24
        self.mediator = None
25

26
    def send(self, event):
27
        print(f"{self.name} sends: {event}")
28
        self.mediator.notify(self, event)
29

30
    def receive(self, event):
31
        print(f"{self.name} receives: {event}")
32

33
# 使用
34
mediator = ConcreteMediator()
35

36
comp1 = Component("Component1")
37
comp2 = Component("Component2")
38
comp3 = Component("Component3")
39

40
mediator.add_component(comp1)
41
mediator.add_component(comp2)
42
mediator.add_component(comp3)
43

44
comp1.send("Hello")
45
# Component1 sends: Hello
46
# Component2 receives: Hello
47
# Component3 receives: Hello

应用场景：UI 组件通信、聊天室、微服务协调。

3.10 备忘录模式（Memento）#

保存对象的内部状态，以便在需要时恢复。

1
class Memento:
2
    def __init__(self, state):
3
        self._state = state
4

5
    def get_state(self):
6
        return self._state
7

8
class Originator:
9
    def __init__(self, state):
10
        self._state = state
11

12
    def do_something(self):
13
        self._state = f"Modified {self._state}"
14

15
    def save(self) -> Memento:
16
        return Memento(self._state)
17

18
    def restore(self, memento: Memento):
19
        self._state = memento.get_state()
20

21
    def __str__(self):
22
        return f"State: {self._state}"
23

24
class Caretaker:
25
    def __init__(self, originator: Originator):
26
        self._originator = originator
27
        self._mementos = []
28

29
    def save(self):
30
        self._mementos.append(self._originator.save())
31

32
    def undo(self):
33
        if self._mementos:
34
            memento = self._mementos.pop()
35
            self._originator.restore(memento)
36

37
# 使用
38
originator = Originator("Initial State")
39
caretaker = Caretaker(originator)
40

41
print(originator)  # State: Initial State
42

43
caretaker.save()
44
originator.do_something()
45
print(originator)  # State: Modified Initial State
46

47
caretaker.save()
48
originator.do_something()
49
print(originator)  # State: Modified Modified Initial State
50

51
caretaker.undo()
52
print(originator)  # State: Modified Initial State
53

54
caretaker.undo()
55
print(originator)  # State: Initial State

应用场景：撤销/重做、状态快照、事务回滚。

3.11 解释器模式（Interpreter）#

给定一个语言，定义它的语法表示，并定义一个解释器。

1
from abc import ABC, abstractmethod
2
from typing import List
3

4
class Expression(ABC):
5
    @abstractmethod
6
    def interpret(self, context):
7
        pass
8

9
class TerminalExpression(Expression):
10
    def __init__(self, data):
11
        self._data = data
12

13
    def interpret(self, context):
14
        return self._data in context
15

16
class OrExpression(Expression):
17
    def __init__(self, expr1, expr2):
18
        self._expr1 = expr1
19
        self._expr2 = expr2
20

21
    def interpret(self, context):
22
        return self._expr1.interpret(context) or self._expr2.interpret(context)
23

24
class AndExpression(Expression):
25
    def __init__(self, expr1, expr2):
26
        self._expr1 = expr1
27
        self._expr2 = expr2
28

29
    def interpret(self, context):
30
        return self._expr1.interpret(context) and self._expr2.interpret(context)
31

32
# 使用
33
# 规则：Robert 和 John 是男性
34
male = OrExpression(TerminalExpression("Robert"), TerminalExpression("John"))
35

36
# 规则：Julie 是已婚女性
37
married_woman = AndExpression(
38
    TerminalExpression("Julie"),
39
    TerminalExpression("Married")
40
)
41

42
print(f"John is male? {male.interpret('John')}")           # True
43
print(f"Julie is married woman? {married_woman.interpret('Julie Married')}")  # True

应用场景：表达式解析、规则引擎、配置语言、SQL 解析。

四、设计模式选择指南#

4.1 问题场景匹配#

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
│   └── 语言解析 → 解释器模式

4.2 Python 特有实现方式#

模式	Python 实现方式
单例模式	`__new__` / metaclass / 模块
装饰器模式	`@decorator` 语法
迭代器模式	`__iter__` / `__next__`
工厂模式	函数 / 类方法 / `__init_subclass__`
观察者模式	`weakref` / `functools`
策略模式	函数作为参数 / 字典映射

五、最佳实践#

5.1 使用原则#

1
✅ 不要过度设计，简单代码优先
2
✅ 遇到问题再应用模式，不要预先设计
3
✅ 理解模式的意图，不要生搬硬套
4
✅ 优先使用 Python 内置机制（装饰器、迭代器等）
5
✅ 组合优于继承
6
✅ 面向接口编程，而非面向实现
7
✅ 依赖倒置：高层模块不依赖低层模块
8
✅ 开闭原则：对扩展开放，对修改关闭

5.2 常见误区#

1
❌ 滥用单例模式（全局状态难测试）
2
❌ 过度使用模式（简单问题复杂化）
3
❌ 模式命名不当（代码可读性差）
4
❌ 模式嵌套过深（难以维护）
5
❌ 忽略 Python 语言特性（重新发明轮子）
6
❌ 设计模式银弹化（没有万能模式）

5.3 学习路径#

1
入门 → 进阶 → 精通
2
 │      │      │
3
 │      │      ├── 模式组合应用
4
 │      │      ├── 模式反模式识别
5
 │      │      └── 架构层面应用
6
 │      │
7
 │      ├── 理解模式意图
8
 │      ├── 实际场景应用
9
 │      └── 模式优缺点分析
10
 │
11
 ├── 阅读 GoF 设计模式
12
 ├── 编写代码示例
13
 └── 在项目中尝试使用

六、总结#

设计模式是软件设计的经典智慧结晶。掌握设计模式可以：

提高代码质量：写出更清晰、更可维护的代码
提升架构能力：更好地设计系统架构
促进团队沟通：用模式语言交流设计思路
解决常见问题：快速解决重复性问题

23 种设计模式速览：

类别	模式	核心思想
创建型	单例	全局唯一实例
创建型	工厂	对象创建封装
创建型	抽象工厂	产品族创建
创建型	建造者	分步构建
创建型	原型	克隆创建
结构型	适配器	接口转换
结构型	装饰器	功能增强
结构型	代理	访问控制
结构型	组合	树形结构
结构型	外观	统一接口
结构型	桥接	抽象与实现分离
结构型	享元	对象复用
行为型	观察者	事件通知
行为型	策略	算法替换
行为型	命令	请求封装
行为型	责任链	请求传递
行为型	状态	状态驱动
行为型	模板方法	算法骨架
行为型	迭代器	集合遍历
行为型	访问者	操作扩展
行为型	中介者	对象解耦
行为型	备忘录	状态恢复
行为型	解释器	语言解析

记住：设计模式是工具，不是目标。不要为了用模式而用模式，而是在真正需要时使用。2026 年，设计模式仍然是软件工程师必备的知识体系。