找回密码
立即注册
搜索
发回帖 发新帖

5322

积分

0

好友

680

主题
发表于 昨天 11:10 | 查看: 15| 回复: 0

写 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 个模式和手法里,如果平时主要写业务代码,我会优先掌握策略模式、装饰器和上下文管理器。它们解决的问题很常见,用起来也比较自然。

工厂模式和适配器模式,在系统接入的组件越来越多时会更有价值;观察者模式适合拆分事件后的多个动作;单例模式则要克制,别把全局状态搞得满天飞。

还有一点,设计模式不会让程序凭空变快,也不保证代码行数一定减少。

它真正省下来的,是下一次需求变更时,你不必在一大坨代码里找入口,也能降低改动一个分支影响其他分支的风险。

代码写到最后,拼的不是谁用了更多模式,而是谁能把该复杂的地方处理好,把不该复杂的地方留简单。




上一篇:前同事离世后,我重新想了想加班和生活
下一篇:微软全球服务宕机近24小时:Outlook与Teams已恢复
您需要登录后才可以回帖 登录 | 立即注册

关闭

站长推荐上一条 /1 下一条

手机版|小黑屋|网站地图|云栈社区 ( 苏ICP备2022046150号-2 )

GMT+8, 2026-11-20 05:02 , Processed in 0.077481 second(s), 42 queries , Gzip On.

Powered by Discuz! X3.5

© 2025-2026 云栈社区.

快速回复 返回顶部 返回列表