写 Python 时间长了就会发现,有些代码刚开始看着挺简单,业务一迭代就开始难受。
比如支付接口,最初只有微信支付,后来加上支付宝、银行卡,再后来又多了退款、重试和支付状态校验。一个函数从几十行涨到几百行,里面全是 if...elif...。
这时候,继续往里面塞判断不是好办法。与其每次改业务都动一遍老代码,不如先把代码结构理顺。
下面这 7 个模式和编程手法,在 Python 项目中值得掌握。目的不是炫技,而是让代码更容易修改和维护。
1. 策略模式:别让 if-else 越长越难维护
先看一个订单支付的场景。
如果每增加一种支付方式,都要修改原来的支付函数,时间长了,就很难保证每个分支都不出问题。
可以用策略模式,把不同支付方式拆成独立实现。
class WechatPay:
def pay(self, amount):
print(f"微信支付:{amount} 元")
class AliPay:
def pay(self, amount):
print(f"支付宝支付:{amount} 元")
PAYMENT_METHODS = {
"wechat": WechatPay(),
"alipay": AliPay(),
}
def submit_payment(method, amount):
handler = PAYMENT_METHODS.get(method)
if handler is None:
raise ValueError(f"不支持的支付方式:{method}")
handler.pay(amount)
以后新增支付方式,只需要增加一个实现,再注册进去,不用重新修改支付函数。
这里有个细节:如果支付方式只有两种,而且不会扩展,普通的 if-else 完全够用。设计模式不是越多越好,能解决维护问题才值得引入。
2. 工厂模式:别把对象创建散落在业务代码里
项目里经常有这种情况:多个地方都需要创建不同类型的处理器,每个地方都写一遍判断。
以后修改构造参数,就得挨个找调用位置。用工厂模式把创建逻辑集中起来,会省事很多。
class CsvImporter:
def run(self, path):
print(f"导入 CSV 文件:{path}")
class JsonImporter:
def run(self, path):
print(f"导入 JSON 文件:{path}")
def create_importer(file_type):
importers = {
"csv": CsvImporter,
"json": JsonImporter,
}
importer_class = importers.get(file_type)
if importer_class is None:
raise ValueError(f"不支持的文件类型:{file_type}")
return importer_class()
importer = create_importer("csv")
importer.run("orders.csv")
这种写法适合导入器、消息处理器、存储客户端等场景。
工厂模式的价值不在于多写一个函数,而是把对象创建规则集中管理。业务代码只管使用,不必知道具体怎么构造。
3. 装饰器模式:不改原函数,也能增加能力
Python 开发者应该对装饰器很熟悉。接口耗时统计、日志记录、权限检查,都可以考虑用它。
例如,想知道某个任务执行了多久,又不想在业务函数里面到处加计时代码。
from functools import wraps
from time import perf_counter
def trace_cost(func):
@wraps(func)
def wrapper(*args, **kwargs):
started = perf_counter()
try:
return func(*args, **kwargs)
finally:
elapsed = perf_counter() - started
print(f"{func.__name__} 耗时 {elapsed:.3f}s")
return wrapper
@trace_cost
def rebuild_search_index():
# 实际项目中放索引重建逻辑
sum(i * i for i in range(500_000))
rebuild_search_index()
这里用 finally,是因为即使函数抛出异常,也能记录耗时;wraps 则能保留原函数的名称等元信息。
不过要注意,统计耗时不等于解决性能问题。发现慢之后,还得继续查数据库、网络调用和 CPU 开销。
4. 单例模式:某些资源确实没必要重复创建
比如一个进程里的配置读取器,如果每次使用都重新加载配置文件,就可能产生不必要的开销。
Python 里可以用模块自身的导入机制实现简单的单例效果,不一定非要写复杂的单例类。
# app_config.py
from pathlib import Path
import json
CONFIG_PATH = Path("settings.json")
def load_config():
return json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
config = load_config()
其他模块直接导入:
from app_config import config
database_url = config["database_url"]
在同一个 Python 进程中,模块通常只初始化一次,其他模块可以共享这个对象。
但这不意味着配置会自动热更新,也不意味着多个进程共享同一份内存。Gunicorn 开多个 worker 时,每个进程仍然有自己的配置对象。
如果只是为了少创建几个普通对象,没必要强行使用单例。
5. 适配器模式:第三方接口不统一,就在中间加一层
接入外部服务时很容易遇到这种问题:A 服务返回 data,B 服务返回 result,C 服务成功时返回字符串,失败时又是另一套格式。
如果业务代码直接依赖这些差异,后面换服务会很麻烦。可以在外面包一层适配器:
class WeatherAdapter:
def __init__(self, client):
self.client = client
def get_temperature(self, city):
response = self.client.fetch(city)
if "data" in response:
return float(response["data"]["temp"])
if "result" in response:
return float(response["result"]["temperature"])
raise ValueError("无法识别天气服务的响应格式")
业务代码只调用 get_temperature(),不需要关心第三方返回字段叫什么。
实际接入时,还要根据供应商协议处理超时、错误码和数据校验。适配器负责统一接口,不负责把所有异常都掩盖掉。
6. 观察者模式:一个事件发生,不要让所有业务挤在一起
订单创建后,可能需要发送通知、记录审计日志、更新统计数据。
如果全部写在订单函数里,每增加一个后续动作,都要改核心业务。可以用事件发布和订阅的方式拆开:
from collections import defaultdict
class EventBus:
def __init__(self):
self._listeners = defaultdict(list)
def subscribe(self, event, callback):
self._listeners[event].append(callback)
def publish(self, event, payload):
for callback in self._listeners[event]:
callback(payload)
events = EventBus()
events.subscribe(
"order.created",
lambda order: print(f"发送订单通知:{order['id']}")
)
events.subscribe(
"order.created",
lambda order: print(f"记录审计日志:{order['id']}")
)
events.publish("order.created", {"id": "ORD-20261027"})
这个例子适合进程内的简单事件分发。
但有个坑必须注意:某个监听器抛出异常,可能导致后面的监听器无法执行。真正用于生产时,需要明确异常隔离、执行顺序和重试策略。
如果要求服务重启后事件也不能丢,单纯的内存事件总线不够,还得考虑消息队列或事务消息方案。
7. 上下文管理器:资源释放这件事,别依赖记性
文件、锁、数据库连接,这些资源用完后都需要释放。
有些代码只关注正常流程,一旦中途抛出异常,清理逻辑就被跳过去了。Python 的 with 就是解决这类问题的好工具。
from contextlib import contextmanager
from time import perf_counter
@contextmanager
def task_timer(task_name):
started = perf_counter()
print(f"{task_name} 开始")
try:
yield
finally:
elapsed = perf_counter() - started
print(f"{task_name} 结束,耗时 {elapsed:.3f}s")
with task_timer("日报生成"):
# 替换成真实的报表生成逻辑
sum(i for i in range(300_000))
无论 with 里面正常结束还是抛出异常,finally 都会执行。
文件操作可以直接用 with open(...),数据库连接和锁也应优先使用各自提供的上下文管理能力。能让资源生命周期跟着代码块走,就不要自己维护一堆容易遗漏的释放逻辑。
这 7 个模式和手法里,如果平时主要写业务代码,我会优先掌握策略模式、装饰器和上下文管理器。它们解决的问题很常见,用起来也比较自然。
工厂模式和适配器模式,在系统接入的组件越来越多时会更有价值;观察者模式适合拆分事件后的多个动作;单例模式则要克制,别把全局状态搞得满天飞。
还有一点,设计模式不会让程序凭空变快,也不保证代码行数一定减少。
它真正省下来的,是下一次需求变更时,你不必在一大坨代码里找入口,也能降低改动一个分支影响其他分支的风险。
代码写到最后,拼的不是谁用了更多模式,而是谁能把该复杂的地方处理好,把不该复杂的地方留简单。