《精通 Python 设计模式：从入门理解到实战落地》

"设计模式不是银弹，但它是你代码世界的地图。"------写给每一位渴望写出优雅、可维护代码的 Python 开发者

一、引言：为什么 Python 程序员也需要设计模式？

在 Python 这样一门灵活、动态、语法优雅的语言中，很多人误以为"设计模式是 Java 工程师的事"。但随着项目规模扩大、团队协作加深、系统复杂度提升，设计模式的重要性愈发凸显。

设计模式不是约束，而是经验的沉淀。它们帮助我们：

提高代码复用性与可维护性
降低模块间耦合度
提升团队协作效率
快速识别和解决架构问题

本文将带你系统梳理 Python 中最常用的设计模式，结合语言特性与实战案例，帮助你在实际开发中灵活运用这些"编程武器"。

二、设计模式分类概览

设计模式大致可分为三类：

类型	作用说明	示例模式
创建型模式	关注对象的创建方式	单例、工厂、建造者、原型等
结构型模式	关注对象之间的组合与结构	适配器、装饰器、代理、组合等
行为型模式	关注对象之间的通信与职责分配	观察者、策略、命令、状态等

三、Python 中常用的设计模式详解

1. 单例模式（Singleton）

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

Python 实现方式一：模块级单例（推荐）

Python 的模块天然就是单例的。

python 复制代码

# config.py
db_connection = None

python 复制代码

# main.py
import config

def get_db():
    if config.db_connection is None:
        config.db_connection = "连接数据库"
    return config.db_connection

实现方式二：使用装饰器

python 复制代码

def singleton(cls):
    instances = {}
    def wrapper(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return wrapper

@singleton
class Logger:
    def log(self, msg):
        print(f"[LOG] {msg}")

实战应用：

数据库连接池
配置管理器
日志系统

2. 工厂模式（Factory）

目的：将对象的创建逻辑封装起来，解耦调用者与具体类的依赖。

简单工厂模式

python 复制代码

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

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

def animal_factory(kind):
    if kind == "dog":
        return Dog()
    elif kind == "cat":
        return Cat()
    raise ValueError("Unknown animal type")

animal = animal_factory("dog")
print(animal.speak())  # 输出：Woof!

实战应用：

根据配置动态创建对象（如不同数据库驱动）
插件系统的加载器

3. 策略模式（Strategy）

目的：定义一系列算法，将它们封装起来，并使它们可以互换。

Python 实现（函数式风格）

python 复制代码

def add(x, y): return x + y
def sub(x, y): return x - y
def mul(x, y): return x * y

strategies = {
    "add": add,
    "sub": sub,
    "mul": mul
}

def execute(strategy, x, y):
    return strategies[strategy](x, y)

print(execute("mul", 3, 4))  # 输出：12

实战应用：

支付方式切换（支付宝、微信、信用卡）
不同排序策略
AI 模型选择

4. 装饰器模式（Decorator）

目的：在不修改原始类的情况下，动态添加功能。

Python 原生支持

python 复制代码

def log(func):
    def wrapper(*args, **kwargs):
        print(f"调用函数：{func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@log
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")

实战应用：

权限校验
缓存机制
性能监控（如记录函数耗时）

5. 观察者模式（Observer）

目的：当一个对象状态发生变化时，自动通知依赖它的对象。

Python 实现

python 复制代码

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

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

    def notify(self, msg):
        for obs in self._observers:
            obs.update(msg)

class Observer:
    def update(self, msg):
        print(f"收到通知：{msg}")

subject = Subject()
subject.attach(Observer())
subject.notify("数据更新啦！")

实战应用：

GUI 事件系统
发布订阅模型（如消息队列）
数据绑定（如 Vue 的响应式）

6. 适配器模式（Adapter）

目的：将一个类的接口转换成客户端期望的另一个接口。

Python 实现

python 复制代码

class OldPrinter:
    def print_text(self, text):
        print(f"[OldPrinter] {text}")

class NewPrinter:
    def output(self, content):
        print(f"[NewPrinter] {content}")

class PrinterAdapter:
    def __init__(self, printer):
        self.printer = printer

    def print_text(self, text):
        if hasattr(self.printer, 'print_text'):
            self.printer.print_text(text)
        else:
            self.printer.output(text)

printer = PrinterAdapter(NewPrinter())
printer.print_text("Hello, Adapter!")

实战应用：

第三方库接口兼容
老旧系统与新系统的桥接

7. 命令模式（Command）

目的：将请求封装为对象，从而支持撤销、重做、日志等操作。

Python 实现

python 复制代码

class Command:
    def execute(self): pass

class LightOnCommand(Command):
    def execute(self):
        print("灯打开了")

class RemoteControl:
    def __init__(self):
        self._commands = []

    def add_command(self, cmd):
        self._commands.append(cmd)

    def run(self):
        for cmd in self._commands:
            cmd.execute()

remote = RemoteControl()
remote.add_command(LightOnCommand())
remote.run()

实战应用：

GUI 按钮事件绑定
操作日志记录与回滚
游戏指令系统

四、实战案例：构建一个可扩展的任务调度器

我们以"任务调度器"为例，结合策略模式 + 命令模式 + 单例模式，实现一个可扩展、可配置的系统。

需求：

支持多种任务类型（如发送邮件、备份文件）
支持任务注册与执行
支持日志记录

核心代码结构：

python 复制代码

# task_base.py
class Task:
    def run(self):
        raise NotImplementedError

# tasks.py
from task_base import Task

class EmailTask(Task):
    def run(self):
        print("发送邮件任务执行中...")

class BackupTask(Task):
    def run(self):
        print("备份文件任务执行中...")

# registry.py
class TaskRegistry:
    _tasks = {}

    @classmethod
    def register(cls, name, task_cls):
        cls._tasks[name] = task_cls

    @classmethod
    def get(cls, name):
        return cls._tasks.get(name)

# main.py
from tasks import EmailTask, BackupTask
from registry import TaskRegistry

TaskRegistry.register("email", EmailTask)
TaskRegistry.register("backup", BackupTask)

def run_task(name):
    task_cls = TaskRegistry.get(name)
    if task_cls:
        task = task_cls()
        task.run()
    else:
        print(f"任务 {name} 未注册")

run_task("email")
run_task("backup")

五、最佳实践与建议

组合优于继承：设计模式鼓励通过组合实现灵活扩展，避免深层继承链。
保持简洁：Python 的语法优势让我们可以用更少的代码实现设计意图，避免"过度设计"。
结合标准库 ：如 functools、contextlib、abc 等模块可辅助实现多种模式。
测试驱动开发（TDD）：设计模式与单元测试天然契合，便于验证行为与解耦逻辑。
文档与注释：模式的使用应清晰标注意图，避免团队成员误解。