Python版23种设计模式终极指南：原理+场景+实战代码全覆盖

一、创建型模式（5种）

1. 单例模式（Singleton）

• 核心思想：确保一个类仅有一个实例。
• 使用场景：全局配置管理、数据库连接池。
• Python案例：

  class AppConfig:
      _instance = None
      def __new__(cls):
          if not cls._instance:
              cls._instance = super().__new__(cls)
              cls._instance.load_config()
          return cls._instance
      def load_config(self):
          self.settings = {"theme": "dark", "language": "zh"}
  # 使用
  config1 = AppConfig()
  config2 = AppConfig()
  print(config1 is config2)  # True
  

2. 工厂方法模式（Factory Method）

• 核心思想：由子类决定创建哪种对象。
• 使用场景：支付方式选择、日志记录器。
• Python案例：

  from abc import ABC, abstractmethod
  class Payment(ABC):
      @abstractmethod
      def pay(self, amount): pass
  class Alipay(Payment):
      def pay(self, amount): print(f"支付宝支付：{amount}元")
  class WechatPay(Payment):
      def pay(self, amount): print(f"微信支付：{amount}元")
  class PaymentFactory(ABC):
      @abstractmethod
      def create_payment(self): pass
  class AlipayFactory(PaymentFactory):
      def create_payment(self): return Alipay()
  # 使用
  factory = AlipayFactory()
  payment = factory.create_payment()
  payment.pay(100)  # 支付宝支付：100元
  

3. 抽象工厂模式（Abstract Factory）

• 核心思想：创建一组相关对象的接口。
• 使用场景：跨平台UI组件库。
• Python案例：

  class LinuxButton:
      def render(self): print("Linux风格按钮")
  class MacButton:
      def render(self): print("Mac风格按钮")
  class GUIFactory(ABC):
      @abstractmethod
      def create_button(self): pass
  class LinuxFactory(GUIFactory):
      def create_button(self): return LinuxButton()
  # 使用
  factory = LinuxFactory()
  button = factory.create_button()
  button.render()  # Linux风格按钮
  

4. 建造者模式（Builder）

• 核心思想：分步骤构建复杂对象。
• 使用场景：SQL查询构造器、文档生成器。
• Python案例：

  class Pizza:
      def __init__(self):
          self.toppings = []
      def add_topping(self, item):
          self.toppings.append(item)
  class PizzaBuilder:
      def __init__(self):
          self.pizza = Pizza()
      def add_cheese(self):
          self.pizza.add_topping("芝士")
          return self
      def add_pepperoni(self):
          self.pizza.add_topping("意大利辣香肠")
          return self
      def build(self):
          return self.pizza
  # 使用
  pizza = PizzaBuilder().add_cheese().add_pepperoni().build()
  print(pizza.toppings)  # ['芝士', '意大利辣香肠']
  

5. 原型模式（Prototype）

• 核心思想：通过克隆现有对象创建新对象。
• 使用场景：对象创建成本高时。
• Python案例：

  import copy
  class Prototype:
      def clone(self):
          return copy.deepcopy(self)
  class Car(Prototype):
      def __init__(self, model):
          self.model = model
  # 使用
  car1 = Car("Tesla Model S")
  car2 = car1.clone()
  print(car2.model)  # Tesla Model S
  

---

二、结构型模式（7种）

6. 适配器模式（Adapter）

• 核心思想：转换接口使其兼容。
• 使用场景：整合第三方库。
• Python案例：

  class OldSystem:
      def legacy_output(self): return "旧系统数据"
  class Adapter:
      def __init__(self, old_system):
          self.old_system = old_system
      def new_output(self):
          return f"适配后的数据：{self.old_system.legacy_output()}"
  # 使用
  adapter = Adapter(OldSystem())
  print(adapter.new_output())  # 适配后的数据：旧系统数据
  

7. 装饰器模式（Decorator）

• 核心思想：动态添加功能。
• 使用场景：权限校验、日志增强。
• Python案例（使用Python装饰器语法）：

  def log_decorator(func):
      def wrapper(*args, **kwargs):
          print(f"调用函数：{func.__name__}")
          return func(*args, **kwargs)
      return wrapper
  @log_decorator
  def calculate(a, b):
      return a + b
  print(calculate(2, 3))  # 输出：调用函数：calculate → 5
  

8. 代理模式（Proxy）

• 核心思想：控制对象访问。
• 使用场景：延迟加载、访问控制。
• Python案例：

  class RealImage:
      def display(self): print("显示高清图片")
  class ProxyImage:
      def __init__(self):
          self.real_image = None
      def display(self):
          if self.real_image is None:
              self.real_image = RealImage()
          self.real_image.display()
  # 使用
  proxy = ProxyImage()
  proxy.display()  # 显示高清图片（延迟加载）
  

9. 外观模式（Facade）

• 核心思想：提供统一入口简化子系统。
• 使用场景：复杂API封装。
• Python案例：

  class CPU:
      def start(self): print("CPU启动")
  class Memory:
      def load(self): print("内存加载")
  class ComputerFacade:
      def __init__(self):
          self.cpu = CPU()
          self.memory = Memory()
      def start(self):
          self.cpu.start()
          self.memory.load()
  # 使用
  computer = ComputerFacade()
  computer.start()  # CPU启动 → 内存加载
  

10. 桥接模式（Bridge）

• 核心思想：抽象与实现分离。
• 使用场景：跨平台图形渲染。
• Python案例：

  class Renderer(ABC):
      @abstractmethod
      def render_circle(self, radius): pass
  class VectorRenderer(Renderer):
      def render_circle(self, radius):
          print(f"矢量渲染圆形，半径：{radius}")
  class Shape:
      def __init__(self, renderer):
          self.renderer = renderer
      def draw(self): pass
  class Circle(Shape):
      def __init__(self, renderer, radius):
          super().__init__(renderer)
          self.radius = radius
      def draw(self):
          self.renderer.render_circle(self.radius)
  # 使用
  vector_renderer = VectorRenderer()
  circle = Circle(vector_renderer, 5)
  circle.draw()  # 矢量渲染圆形，半径：5
  

11. 组合模式（Composite）

• 核心思想：树形结构处理整体-部分关系。
• 使用场景：文件系统、菜单组件。
• Python案例：

  class FileComponent(ABC):
      @abstractmethod
      def show(self): pass
  class File(FileComponent):
      def __init__(self, name):
          self.name = name
      def show(self): print(f"文件：{self.name}")
  class Folder(FileComponent):
      def __init__(self, name):
          self.name = name
          self.children = []
      def add(self, component):
          self.children.append(component)
      def show(self):
          print(f"文件夹：{self.name}")
          for child in self.children:
              child.show()
  # 使用
  root = Folder("根目录")
  root.add(File("a.txt"))
  sub_folder = Folder("子文件夹")
  sub_folder.add(File("b.jpg"))
  root.add(sub_folder)
  root.show()
  

12. 享元模式（Flyweight）

• 核心思想：共享细粒度对象节省内存。
• 使用场景：文字编辑器字符对象池。
• Python案例：

  class CharacterFactory:
      _characters = {}
      @classmethod
      def get_character(cls, char):
          if char not in cls._characters:
              cls._characters[char] = Character(char)
          return cls._characters[char]
  class Character:
      def __init__(self, char):
          self.char = char
  # 使用
  char_a = CharacterFactory.get_character('A')
  char_b = CharacterFactory.get_character('A')
  print(char_a is char_b)  # True（对象复用）
  

---

三、行为型模式（11种）

13. 观察者模式（Observer）

• 核心思想：状态变化自动通知依赖对象。
• 使用场景：事件通知系统。
• Python案例：

  class NewsAgency:
      def __init__(self):
          self._subscribers = []
      def subscribe(self, subscriber):
          self._subscribers.append(subscriber)
      def publish_news(self, news):
          for sub in self._subscribers:
              sub.update(news)
  class Subscriber:
      def update(self, news):
          print(f"收到新闻：{news}")
  # 使用
  agency = NewsAgency()
  agency.subscribe(Subscriber())
  agency.publish_news("Breaking News!")
  

14. 策略模式（Strategy）

• 核心思想：封装可互换的算法族。
• 使用场景：排序算法切换。
• Python案例：

  class SortStrategy(ABC):
      @abstractmethod
      def sort(self, data): pass
  class QuickSort(SortStrategy):
      def sort(self, data):
          print("快速排序执行")
          return sorted(data)
  class Context:
      def __init__(self, strategy):
          self.strategy = strategy
      def execute_sort(self, data):
          return self.strategy.sort(data)
  # 使用
  context = Context(QuickSort())
  context.execute_sort([3,1,2])
  

15. 责任链模式（Chain of Responsibility）

• 核心思想：请求沿处理链传递直至被处理。
• 使用场景：审批流程、异常处理。
• Python案例：

  class Handler(ABC):
      def __init__(self, successor=None):
          self.successor = successor
      @abstractmethod
      def handle(self, request): pass
  class ConcreteHandlerA(Handler):
      def handle(self, request):
          if request == "A":
              print("HandlerA处理请求")
          elif self.successor:
              self.successor.handle(request)
  class ConcreteHandlerB(Handler):
      def handle(self, request):
          if request == "B":
              print("HandlerB处理请求")
          elif self.successor:
              self.successor.handle(request)
  # 使用
  chain = ConcreteHandlerA(ConcreteHandlerB())
  chain.handle("B")  # HandlerB处理请求
  

16. 命令模式（Command）

• 核心思想：将请求封装为对象。
• 使用场景：GUI按钮操作、事务系统。
• Python案例：

  class Command(ABC):
      @abstractmethod
      def execute(self): pass
  class LightOnCommand(Command):
      def execute(self): print("开灯")
  class RemoteControl:
      def set_command(self, command):
          self.command = command
      def press_button(self):
          self.command.execute()
  # 使用
  remote = RemoteControl()
  remote.set_command(LightOnCommand())
  remote.press_button()  # 开灯
  

17. 迭代器模式（Iterator）

• 核心思想：提供统一的集合遍历接口。
• 使用场景：自定义数据结构遍历。
• Python案例（Python内置支持）：

  class BookCollection:
      def __init__(self):
          self.books = ["Python入门", "算法导论"]
      def __iter__(self):
          return iter(self.books)
  # 使用
  for book in BookCollection():
      print(book)  # 输出所有书名
  

18. 中介者模式（Mediator）

• 核心思想：通过中介对象协调多个对象交互。
• 使用场景：聊天室系统。
• Python案例：

  class ChatRoom:
      @staticmethod
      def send_message(user, message):
          print(f"[{user}] 发送消息：{message}")
  class User:
      def __init__(self, name):
          self.name = name
      def send(self, message):
          ChatRoom.send_message(self.name, message)
  # 使用
  user1 = User("Alice")
  user1.send("你好！")  # [Alice] 发送消息：你好！
  

19. 备忘录模式（Memento）

• 核心思想：捕获对象状态实现撤销。
• 使用场景：文本编辑器撤销功能。
• Python案例：

  class EditorMemento:
      def __init__(self, content):
          self.content = content
  class Editor:
      def __init__(self):
          self.content = ""
      def write(self, text):
          self.content += text
      def save(self):
          return EditorMemento(self.content)
      def restore(self, memento):
          self.content = memento.content
  # 使用
  editor = Editor()
  editor.write("Hello")
  saved = editor.save()
  editor.write(" World")
  editor.restore(saved)
  print(editor.content)  # Hello
  

20. 状态模式（State）

• 核心思想：对象行为随状态改变而改变。
• 使用场景：订单状态流转。
• Python案例：

  class OrderState(ABC):
      @abstractmethod
      def next_state(self): pass
  class PaidState(OrderState):
      def next_state(self):
          print("订单已支付 → 发货")
          return ShippedState()
  class ShippedState(OrderState):
      def next_state(self):
          print("订单已发货 → 完成")
          return CompletedState()
  class Order:
      def __init__(self):
          self.state = PaidState()
      def proceed(self):
          self.state = self.state.next_state()
  # 使用
  order = Order()
  order.proceed()  # 订单已支付 → 发货
  order.proceed()  # 订单已发货 → 完成
  

21. 访问者模式（Visitor）

• 核心思想：将算法与对象结构分离。
• 使用场景：文档格式转换。
• Python案例：

  class DocumentElement(ABC):
      @abstractmethod
      def accept(self, visitor): pass
  class TextElement(DocumentElement):
      def accept(self, visitor):
          visitor.visit_text(self)
  class Visitor(ABC):
      @abstractmethod
      def visit_text(self, element): pass
  class HTMLExportVisitor(Visitor):
      def visit_text(self, element):
          print("将文本导出为HTML")
  # 使用
  elements = [TextElement()]
  visitor = HTMLExportVisitor()
  for elem in elements:
      elem.accept(visitor)
  

22. 模板方法模式（Template Method）

• 核心思想：定义算法骨架，子类实现具体步骤。
• 使用场景：数据库操作模板。
• Python案例：

  from abc import ABC, abstractmethod
  class DatabaseTemplate(ABC):
      def execute(self):
          self.connect()
          self.query()
          self.close()
      @abstractmethod
      def connect(self): pass
      @abstractmethod
      def query(self): pass
      def close(self): print("关闭连接")
  class MySQL(DatabaseTemplate):
      def connect(self): print("连接MySQL")
      def query(self): print("执行查询")
  # 使用
  db = MySQL()
  db.execute()  # 连接MySQL → 执行查询 → 关闭连接
  

23. 解释器模式（Interpreter）

• 核心思想：定义语言的文法表示。
• 使用场景：SQL解析、正则表达式。
• Python案例（简单布尔表达式解析）：

  class Context:
      def __init__(self):
          self.variables = {}
  class BooleanExpression(ABC):
      @abstractmethod
      def evaluate(self, context): pass
  class Variable(BooleanExpression):
      def __init__(self, name):
          self.name = name
      def evaluate(self, context):
          return context.variables[self.name]
  # 使用
  context = Context()
  context.variables["x"] = True
  expr = Variable("x")
  print(expr.evaluate(context))  # True
  

---

总结

本文完整实现了23种设计模式的Python代码示例，覆盖创建型、结构型、行为型三大类别。设计模式本质是代码设计经验的总结，使用时需注意：

1. 避免过度设计：优先使用简单直观的方案
2. 结合语言特性：如Python可利用装饰器语法简化实现
3. 关注场景匹配：如观察者模式适用于事件驱动系统
4. 保持灵活性：通过工厂模式隔离变化点

建议收藏本文作为开发参考手册，实际编码时根据具体需求灵活选用。