Python设计模式：常用模式实战解析

Python设计模式：常用模式实战解析

引言

设计模式是解决常见软件设计问题的通用解决方案。作为一名从Python转向Rust的后端开发者，理解设计模式对于编写可维护、可扩展的代码至关重要。本文将深入探讨Python中常用的设计模式，帮助你在实际项目中应用这些模式。

一、创建型模式

1.1 单例模式

class Singleton:
_instance = None

def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls, *args, **kwargs)
return cls._instance

def __init__(self):
if not hasattr(self, 'initialized'):
self.value = 0
self.initialized = True

s1 = Singleton()
s2 = Singleton()
print(s1 is s2) # True

1.2 工厂模式

from abc import ABC, abstractmethod

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

class ConcreteProductA(Product):
def operation(self):
return "Product A operation"

class ConcreteProductB(Product):
def operation(self):
return "Product B operation"

class Factory:
def create_product(self, type_):
if type_ == 'A':
return ConcreteProductA()
elif type_ == 'B':
return ConcreteProductB()
else:
raise ValueError("Unknown product type")

factory = Factory()
product = factory.create_product('A')
print(product.operation())

1.3 建造者模式

class Computer:
def __init__(self):
self.cpu = None
self.ram = None
self.storage = None

def __str__(self):
return f"CPU: {self.cpu}, RAM: {self.ram}, Storage: {self.storage}"

class ComputerBuilder:
def __init__(self):
self.computer = Computer()

def set_cpu(self, cpu):
self.computer.cpu = cpu
return self

def set_ram(self, ram):
self.computer.ram = ram
return self

def set_storage(self, storage):
self.computer.storage = storage
return self

def build(self):
return self.computer

builder = ComputerBuilder()
computer = builder.set_cpu('Intel i7').set_ram('16GB').set_storage('1TB').build()
print(computer)

二、结构型模式

2.1 适配器模式

class Target:
def request(self):
return "Target request"

class Adaptee:
def specific_request(self):
return "Specific request"

class Adapter(Target):
def __init__(self, adaptee):
self.adaptee = adaptee

def request(self):
return f"Adapter: {self.adaptee.specific_request()}"

adaptee = Adaptee()
adapter = Adapter(adaptee)
print(adapter.request())

2.2 装饰器模式

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

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()}"

component = Component()
decorated = ConcreteDecoratorA(component)
print(decorated.operation())

2.3 代理模式

class Subject:
def request(self):
pass

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

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

def request(self):
if self.real_subject is None:
self.real_subject = RealSubject()
return f"Proxy: {self.real_subject.request()}"

proxy = Proxy()
print(proxy.request())

三、行为型模式

3.1 观察者模式

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):
for observer in self.observers:
observer.update(self)

class ConcreteSubject(Subject):
def __init__(self):
super().__init__()
self.state = 0

def set_state(self, state):
self.state = state
self.notify()

class Observer:
def update(self, subject):
pass

class ConcreteObserverA(Observer):
def update(self, subject):
print(f"Observer A: State changed to {subject.state}")

class ConcreteObserverB(Observer):
def update(self, subject):
print(f"Observer B: State changed to {subject.state}")

subject = ConcreteSubject()
observer_a = ConcreteObserverA()
observer_b = ConcreteObserverB()

subject.attach(observer_a)
subject.attach(observer_b)
subject.set_state(10)

3.2 策略模式

from abc import ABC, abstractmethod

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

class ConcreteStrategyA(Strategy):
def execute(self, data):
return sorted(data)

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

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

def set_strategy(self, strategy):
self.strategy = strategy

def process(self, data):
return self.strategy.execute(data)

context = Context(ConcreteStrategyA())
print(context.process([3, 1, 4, 1, 5]))

context.set_strategy(ConcreteStrategyB())
print(context.process([3, 1, 4, 1, 5]))

3.3 模板方法模式

from abc import ABC, abstractmethod

class AbstractClass(ABC):
def template_method(self):
self.base_operation1()
self.required_operation1()
self.base_operation2()
self.hook()

def base_operation1(self):
print("Base operation 1")

def base_operation2(self):
print("Base operation 2")

@abstractmethod
def required_operation1(self):
pass

def hook(self):
pass

class ConcreteClass(AbstractClass):
def required_operation1(self):
print("Concrete operation 1")

def hook(self):
print("Optional hook")

concrete = ConcreteClass()
concrete.template_method()

四、实战案例：设计模式组合应用

4.1 日志系统设计

class Logger:
_instance = None

def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
cls._instance.handlers = []
return cls._instance

def add_handler(self, handler):
self.handlers.append(handler)

def log(self, message):
for handler in self.handlers:
handler.handle(message)

class Handler:
def handle(self, message):
pass

class ConsoleHandler(Handler):
def handle(self, message):
print(f"Console: {message}")

class FileHandler(Handler):
def __init__(self, filename):
self.filename = filename

def handle(self, message):
with open(self.filename, 'a') as f:
f.write(f"{message}\\n")

class FormattingHandler(Handler):
def __init__(self, handler, format_):
self.handler = handler
self.format_ = format_

def handle(self, message):
formatted = self.format_.format(message=message)
self.handler.handle(formatted)

logger = Logger()
console = ConsoleHandler()
file = FileHandler('app.log')
formatted = FormattingHandler(console, "[LOG] {message}")

logger.add_handler(formatted)
logger.add_handler(file)
logger.log("Application started")

4.2 数据处理管道

class Pipeline:
def __init__(self):
self.steps = []

def add_step(self, step):
self.steps.append(step)

def process(self, data):
result = data
for step in self.steps:
result = step.execute(result)
return result

class Step:
def execute(self, data):
pass

class ValidateStep(Step):
def execute(self, data):
if not data:
raise ValueError("Empty data")
return data

class TransformStep(Step):
def __init__(self, func):
self.func = func

def execute(self, data):
return self.func(data)

class SaveStep(Step):
def execute(self, data):
print(f"Saving: {data}")
return data

pipeline = Pipeline()
pipeline.add_step(ValidateStep())
pipeline.add_step(TransformStep(lambda x: x.upper()))
pipeline.add_step(SaveStep())

pipeline.process("hello world")

五、设计模式最佳实践

5.1 选择合适的模式

5.2 避免过度设计

# 不要为简单问题使用复杂模式

# 简单场景：直接创建对象
user = User(name="Alice", age=30)

# 复杂场景：使用工厂模式
class UserFactory:
@staticmethod
def create_admin(name):
return User(name=name, role="admin")

@staticmethod
def create_user(name):
return User(name=name, role="user")

5.3 遵循SOLID原则

# 单一职责原则
class UserRepository:
def save(self, user):
pass

class UserService:
def __init__(self, repository):
self.repository = repository

def create_user(self, name):
user = User(name=name)
self.repository.save(user)
return user

六、设计模式与Rust对比

6.1 Python设计模式

class Singleton:
_instance = None

def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance

6.2 Rust设计模式

use std::sync::{Arc, Mutex};

struct Singleton {
value: i32,
}

lazy_static! {
static ref INSTANCE: Arc<Mutex<Singleton>> = Arc::new(Mutex::new(Singleton { value: 0 }));
}

impl Singleton {
fn get_instance() -> Arc<Mutex<Self>> {
INSTANCE.clone()
}
}

6.3 对比分析

总结

设计模式是编写高质量代码的重要工具。通过本文的学习，你应该掌握了以下核心要点：

作为从Python转向Rust的后端开发者，理解设计模式有助于你在两种语言之间进行有效的思维转换。虽然Rust的类型系统和所有权模型改变了某些模式的实现方式，但核心思想是相通的。