Python 设计模式实战：23 种模式场景化落地
设计模式是软件工程中的最佳实践，Python 作为一门灵活的语言，为各种设计模式的实现提供了优雅的语法支持。本文将通过实际场景深入讲解 23 种设计模式在 Python 中的落地应用，帮助读者掌握设计模式的实际运用。
创建型模式
创建型模式关注对象的创建过程，提供了灵活的对象创建机制。
单例模式
单例模式确保一个类只有一个实例，并提供全局访问点。
class Singleton:
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
cls._instance.initialized = False
return cls._instance
def __init__(self):
if not self.initialized:
self.value = 0
self.initialized = True
def singleton_demo():
print("单例模式演示:")
s1 = Singleton()
s2 = Singleton()
print(f"s1 is s2: {s1 is s2}")
print(f"s1.value: {s1.value}")
s1.value = 100
print(f"s2.value: {s2.value}")
singleton_demo()
工厂方法模式
工厂方法模式定义创建对象的接口，让子类决定实例化哪个类。
from abc import ABC, abstractmethod
class Animal(ABC):
@abstractmethod
def make_sound(self):
pass
class Dog(Animal):
def make_sound(self):
return "汪汪"
class Cat(Animal):
def make_sound(self):
return "喵喵"
class AnimalFactory:
@staticmethod
def create_animal(animal_type):
if animal_type == "dog":
return Dog()
elif animal_type == "cat":
return Cat()
else:
raise ValueError("未知的动物类型")
def factory_method_demo():
print("工厂方法模式演示:")
dog = AnimalFactory.create_animal("dog")
cat = AnimalFactory.create_animal("cat")
print(f"狗叫声: {dog.make_sound()}")
print(f"猫叫声: {cat.make_sound()}")
factory_method_demo()
抽象工厂模式
抽象工厂模式提供创建相关或依赖对象的接口，无需指定具体类。
from abc import ABC, abstractmethod
class Button(ABC):
@abstractmethod
def render(self):
pass
class Checkbox(ABC):
@abstractmethod
def render(self):
pass
class WindowsButton(Button):
def render(self):
return "Windows 按钮"
class WindowsCheckbox(Checkbox):
def render(self):
return "Windows 复选框"
class MacButton(Button):
def render(self):
return "Mac 按钮"
class MacCheckbox(Checkbox):
def render(self):
return "Mac 复选框"
class GUIFactory(ABC):
@abstractmethod
def create_button(self):
pass
@abstractmethod
def create_checkbox(self):
pass
class WindowsFactory(GUIFactory):
def create_button(self):
return WindowsButton()
def create_checkbox(self):
return WindowsCheckbox()
class MacFactory(GUIFactory):
def create_button(self):
return MacButton()
def create_checkbox(self):
return MacCheckbox()
def abstract_factory_demo():
print("抽象工厂模式演示:")
windows_factory = WindowsFactory()
mac_factory = MacFactory()
print(f"Windows: {windows_factory.create_button().render()}, {windows_factory.create_checkbox().render()}")
print(f"Mac: {mac_factory.create_button().render()}, {mac_factory.create_checkbox().render()}")
abstract_factory_demo()
建造者模式
建造者模式将复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。
class Computer:
def __init__(self):
self.cpu = None
self.memory = None
self.storage = None
def __str__(self):
return f"CPU: {self.cpu}, 内存: {self.memory}, 存储: {self.storage}"
class ComputerBuilder:
def __init__(self):
self.computer = Computer()
def set_cpu(self, cpu):
self.computer.cpu = cpu
return self
def set_memory(self, memory):
self.computer.memory = memory
return self
def set_storage(self, storage):
self.computer.storage = storage
return self
def build(self):
return self.computer
def builder_demo():
print("建造者模式演示:")
computer = (ComputerBuilder()
.set_cpu("Intel i7")
.set_memory("16GB")
.set_storage("512GB SSD")
.build())
print(f"配置的电脑: {computer}")
builder_demo()
原型模式
原型模式通过复制现有对象来创建新对象，提高创建效率。
import copy
class Prototype:
def __init__(self, value):
self.value = value
def clone(self):
return copy.deepcopy(self)
def prototype_demo():
print("原型模式演示:")
original = Prototype("原始对象")
cloned = original.clone()
print(f"原始对象: {original.value}")
print(f"克隆对象: {cloned.value}")
print(f"是否相同: {original is cloned}")
prototype_demo()
结构型模式
结构型模式关注类和对象的组合，形成更大的结构。
适配器模式
适配器模式将一个类的接口转换成客户希望的另一个接口。
class Target:
def request(self):
return "目标接口"
class Adaptee:
def specific_request(self):
return "特定接口"
class Adapter(Target):
def __init__(self, adaptee):
self.adaptee = adaptee
def request(self):
return self.adaptee.specific_request()
def adapter_demo():
print("适配器模式演示:")
adaptee = Adaptee()
adapter = Adapter(adaptee)
print(f"适配器请求: {adapter.request()}")
adapter_demo()
桥接模式
桥接模式将抽象与实现分离，使它们可以独立变化。
class DrawingAPI:
def draw_circle(self, x, y, radius):
pass
class DrawingAPI1(DrawingAPI):
def draw_circle(self, x, y, radius):
return f"API1 绘制圆形: ({x}, {y}), 半径: {radius}"
class DrawingAPI2(DrawingAPI):
def draw_circle(self, x, y, radius):
return f"API2 绘制圆形: ({x}, {y}), 半径: {radius}"
class Shape:
def __init__(self, drawing_api):
self.drawing_api = drawing_api
def draw(self):
pass
class Circle(Shape):
def __init__(self, x, y, radius, drawing_api):
super().__init__(drawing_api)
self.x = x
self.y = y
self.radius = radius
def draw(self):
return self.drawing_api.draw_circle(self.x, self.y, self.radius)
def bridge_demo():
print("桥接模式演示:")
circle1 = Circle(1, 2, 3, DrawingAPI1())
circle2 = Circle(4, 5, 6, DrawingAPI2())
print(circle1.draw())
print(circle2.draw())
bridge_demo()
组合模式
组合模式将对象组合成树形结构以表示"部分-整体"的层次结构。
class Component:
def operation(self):
pass
def add(self, component):
pass
def remove(self, component):
pass
class Leaf(Component):
def operation(self):
return "叶子节点"
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 = [child.operation() for child in self.children]
return f"组合节点: {', '.join(results)}"
def composite_demo():
print("组合模式演示:")
leaf1 = Leaf()
leaf2 = Leaf()
composite = Composite()
composite.add(leaf1)
composite.add(leaf2)
print(composite.operation())
composite_demo()
装饰器模式
装饰器模式动态地给对象添加额外的职责。
class Component:
def operation(self):
return "基本操作"
class Decorator(Component):
def __init__(self, component):
self.component = component
def operation(self):
return self.component.operation()
class ConcreteDecorator(Decorator):
def operation(self):
return f"装饰 {super().operation()}"
def decorator_demo():
print("装饰器模式演示:")
component = Component()
decorated = ConcreteDecorator(component)
print(decorated.operation())
decorator_demo()
外观模式
外观模式为子系统中的一组接口提供一个一致的界面。
class SubsystemA:
def operation_a(self):
return "子系统 A 操作"
class SubsystemB:
def operation_b(self):
return "子系统 B 操作"
class Facade:
def __init__(self):
self.subsystem_a = SubsystemA()
self.subsystem_b = SubsystemB()
def operation(self):
return f"{self.subsystem_a.operation_a()}, {self.subsystem_b.operation_b()}"
def facade_demo():
print("外观模式演示:")
facade = Facade()
print(facade.operation())
facade_demo()
享元模式
享元模式运用共享技术有效地支持大量细粒度的对象。
class Flyweight:
def __init__(self, intrinsic_state):
self.intrinsic_state = intrinsic_state
def operation(self, extrinsic_state):
return f"内蕴状态: {self.intrinsic_state}, 外蕴状态: {extrinsic_state}"
class FlyweightFactory:
def __init__(self):
self.flyweights = {}
def get_flyweight(self, key):
if key not in self.flyweights:
self.flyweights[key] = Flyweight(key)
return self.flyweights[key]
def flyweight_demo():
print("享元模式演示:")
factory = FlyweightFactory()
flyweight1 = factory.get_flyweight("共享对象")
flyweight2 = factory.get_flyweight("共享对象")
print(f"是否相同: {flyweight1 is flyweight2}")
print(flyweight1.operation("外蕴状态 1"))
print(flyweight2.operation("外蕴状态 2"))
flyweight_demo()
代理模式
代理模式为其他对象提供一种代理以控制对这个对象的访问。
class Subject:
def request(self):
pass
class RealSubject(Subject):
def request(self):
return "真实请求"
class Proxy(Subject):
def __init__(self):
self.real_subject = None
def request(self):
if self.real_subject is None:
self.real_subject = RealSubject()
return self.real_subject.request()
def proxy_demo():
print("代理模式演示:")
proxy = Proxy()
print(proxy.request())
proxy_demo()
行为型模式
行为型模式关注对象之间的通信和职责分配。
责任链模式
责任链模式使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。
class Handler:
def __init__(self):
self.next_handler = None
def set_next(self, handler):
self.next_handler = handler
return handler
def handle(self, request):
if self.next_handler:
return self.next_handler.handle(request)
return None
class ConcreteHandler1(Handler):
def handle(self, request):
if request == "请求1":
return "处理请求1"
return super().handle(request)
class ConcreteHandler2(Handler):
def handle(self, request):
if request == "请求2":
return "处理请求2"
return super().handle(request)
def chain_of_responsibility_demo():
print("责任链模式演示:")
handler1 = ConcreteHandler1()
handler2 = ConcreteHandler2()
handler1.set_next(handler2)
print(handler1.handle("请求1"))
print(handler1.handle("请求2"))
chain_of_responsibility_demo()
命令模式
命令模式将请求封装为对象，从而可用不同的请求对客户进行参数化。
class Command:
def execute(self):
pass
class Receiver:
def action(self):
return "执行操作"
class ConcreteCommand(Command):
def __init__(self, receiver):
self.receiver = receiver
def execute(self):
return self.receiver.action()
class Invoker:
def __init__(self):
self.command = None
def set_command(self, command):
self.command = command
def execute_command(self):
return self.command.execute()
def command_demo():
print("命令模式演示:")
receiver = Receiver()
command = ConcreteCommand(receiver)
invoker = Invoker()
invoker.set_command(command)
print(invoker.execute_command())
command_demo()
迭代器模式
迭代器模式提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。
class Iterator:
def has_next(self):
pass
def next(self):
pass
class ConcreteIterator(Iterator):
def __init__(self, collection):
self.collection = collection
self.index = 0
def has_next(self):
return self.index < len(self.collection)
def next(self):
if self.has_next():
item = self.collection[self.index]
self.index += 1
return item
return None
def iterator_demo():
print("迭代器模式演示:")
collection = [1, 2, 3, 4, 5]
iterator = ConcreteIterator(collection)
while iterator.has_next():
print(iterator.next())
iterator_demo()
中介者模式
中介者模式用一个中介对象来封装一系列的对象交互。
class Mediator:
def send(self, message, colleague):
pass
class Colleague:
def __init__(self, mediator):
self.mediator = mediator
def send(self, message):
self.mediator.send(message, self)
def receive(self, message):
pass
class ConcreteColleague1(Colleague):
def receive(self, message):
return f"同事1收到: {message}"
class ConcreteColleague2(Colleague):
def receive(self, message):
return f"同事2收到: {message}"
class ConcreteMediator(Mediator):
def __init__(self):
self.colleague1 = None
self.colleague2 = None
def send(self, message, colleague):
if colleague == self.colleague1:
return self.colleague2.receive(message)
else:
return self.colleague1.receive(message)
def mediator_demo():
print("中介者模式演示:")
mediator = ConcreteMediator()
colleague1 = ConcreteColleague1(mediator)
colleague2 = ConcreteColleague2(mediator)
mediator.colleague1 = colleague1
mediator.colleague2 = colleague2
print(colleague1.send("你好"))
print(colleague2.send("再见"))
mediator_demo()
备忘录模式
备忘录模式在不破坏封装性的前提下，捕获一个对象的内部状态。
class Memento:
def __init__(self, state):
self.state = state
class Originator:
def __init__(self):
self.state = None
def set_state(self, state):
self.state = state
def save_state(self):
return Memento(self.state)
def restore_state(self, memento):
self.state = memento.state
class Caretaker:
def __init__(self):
self.mementos = []
def add_memento(self, memento):
self.mementos.append(memento)
def get_memento(self, index):
return self.mementos[index]
def memento_demo():
print("备忘录模式演示:")
originator = Originator()
caretaker = Caretaker()
originator.set_state("状态1")
caretaker.add_memento(originator.save_state())
originator.set_state("状态2")
caretaker.add_memento(originator.save_state())
originator.restore_state(caretaker.get_memento(0))
print(f"恢复状态: {originator.state}")
memento_demo()
观察者模式
观察者模式定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知。
class Observer:
def update(self, message):
pass
class 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, message):
for observer in self.observers:
observer.update(message)
class ConcreteObserver(Observer):
def __init__(self, name):
self.name = name
def update(self, message):
return f"{self.name} 收到: {message}"
def observer_demo():
print("观察者模式演示:")
subject = Subject()
observer1 = ConcreteObserver("观察者1")
observer2 = ConcreteObserver("观察者2")
subject.attach(observer1)
subject.attach(observer2)
print(subject.notify("新消息"))
observer_demo()
状态模式
状态模式允许一个对象在其内部状态改变时改变它的行为。
class State:
def handle(self):
pass
class ConcreteStateA(State):
def handle(self):
return "状态 A"
class ConcreteStateB(State):
def handle(self):
return "状态 B"
class Context:
def __init__(self):
self.state = None
def set_state(self, state):
self.state = state
def request(self):
return self.state.handle()
def state_demo():
print("状态模式演示:")
context = Context()
state_a = ConcreteStateA()
state_b = ConcreteStateB()
context.set_state(state_a)
print(context.request())
context.set_state(state_b)
print(context.request())
state_demo()
策略模式
策略模式定义一系列算法，把它们一个个封装起来，并且使它们可相互替换。
class Strategy:
def execute(self):
pass
class ConcreteStrategyA(Strategy):
def execute(self):
return "策略 A"
class ConcreteStrategyB(Strategy):
def execute(self):
return "策略 B"
class Context:
def __init__(self, strategy):
self.strategy = strategy
def set_strategy(self, strategy):
self.strategy = strategy
def execute_strategy(self):
return self.strategy.execute()
def strategy_demo():
print("策略模式演示:")
context = Context(ConcreteStrategyA())
print(context.execute_strategy())
context.set_strategy(ConcreteStrategyB())
print(context.execute_strategy())
strategy_demo()
模板方法模式
模板方法模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
from abc import ABC, abstractmethod
class AbstractClass(ABC):
def template_method(self):
self.primitive_operation1()
self.primitive_operation2()
@abstractmethod
def primitive_operation1(self):
pass
@abstractmethod
def primitive_operation2(self):
pass
class ConcreteClass(AbstractClass):
def primitive_operation1(self):
return "操作1"
def primitive_operation2(self):
return "操作2"
def template_method_demo():
print("模板方法模式演示:")
concrete = ConcreteClass()
concrete.template_method()
template_method_demo()
访问者模式
访问者模式表示一个作用于某对象结构中的各元素的操作。
class Visitor:
def visit_element_a(self, element):
pass
def visit_element_b(self, element):
pass
class ConcreteVisitor(Visitor):
def visit_element_a(self, element):
return f"访问元素 A: {element.operation_a()}"
def visit_element_b(self, element):
return f"访问元素 B: {element.operation_b()}"
class Element:
def accept(self, visitor):
pass
class ElementA(Element):
def operation_a(self):
return "元素 A 操作"
def accept(self, visitor):
return visitor.visit_element_a(self)
class ElementB(Element):
def operation_b(self):
return "元素 B 操作"
def accept(self, visitor):
return visitor.visit_element_b(self)
def visitor_demo():
print("访问者模式演示:")
visitor = ConcreteVisitor()
element_a = ElementA()
element_b = ElementB()
print(element_a.accept(visitor))
print(element_b.accept(visitor))
visitor_demo()
总结
23 种设计模式在 Python 中的实现体现了面向对象设计的精髓。通过实际场景的落地应用，我们可以更好地理解每种模式的适用场景和实现方式。
掌握设计模式不仅能够提高代码的可维护性和可扩展性，还能帮助开发者更好地理解和应用面向对象设计原则。在实际项目中，合理使用设计模式可以大大提高代码质量和开发效率。
