Python案例怎么实现代码装饰器？

wen python案例 2026-06-10 12

Python案例怎么实现代码装饰器？从原理到实战一篇看懂

目录导读

装饰器是什么？为什么需要它？（核心概念）
装饰器的底层语法与工作原理
手把手实现第一个装饰器（基础案例）
进阶：带参数装饰器与类装饰器
常见陷阱与调优技巧
真实项目中的装饰器应用场景
高频问答与避坑指南

装饰器是什么？为什么需要它？

直接回答：装饰器本质上是一个接受函数作为参数并返回函数的高阶函数，它允许你在不修改原函数代码的情况下，动态地给函数添加额外功能（如日志、计时、权限校验等）。

Python案例怎么实现代码装饰器？

为什么要用装饰器？

代码复用：100个函数需要记录执行时间，你不需要在每个函数里写重复的time模块代码。
职责分离：业务逻辑与辅助功能（如缓存、鉴权）解耦。
增强可读性：使用@decorator语法糖，让代码意图一目了然。

案例导入：假设你在做数据分析，需要对每个数据清洗函数统计耗时，若不用装饰器，你会在每个函数开头写start = time.time()，结尾写print("耗时",time.time()-start)——这显然是噩梦，装饰器就是来终结这种“样板代码”的。

装饰器的底层语法与工作原理

核心原理解析：
装饰器@decorator等价于func = decorator(func)，Python会在定义阶段执行这一赋值操作，将原函数替换为装饰器返回的新函数。

def simple_decorator(func):
    def wrapper():
        print("调用前操作")
        result = func()
        print("调用后操作")
        return result
    return wrapper
@simple_decorator
def hello():
    print("Hello World!")
# 等价于：hello = simple_decorator(hello)

关键理解：

装饰器函数必须返回一个可调用对象（通常是函数）。
wrapper函数接收*args, **kwargs以兼容任意参数。
原函数的元信息（如__name__）会被覆盖，需用functools.wraps修复（后文详述）。

手把手实现第一个装饰器（基础案例）

需求：给任意函数添加执行时间统计功能。

import time
import functools
def time_it(func):
    @functools.wraps(func)  # 保留原函数元信息
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} 耗时 {elapsed:.4f}秒")
        return result
    return wrapper
@time_it
def load_data(source):
    time.sleep(2)  # 模拟IO操作
    return f"数据来自{source}"
# 测试
data = load_data("MySQL")
print(data)

输出示例：

load_data 耗时 2.0012秒  
数据来自MySQL

为什么必须加@functools.wraps？

不加的话，load_data.__name__会变成wrapper，导致调试或文档生成时混乱。
wraps本质是将原函数的__name__, __doc__, __module__等属性复制到wrapper上。

进阶：带参数装饰器与类装饰器

1 带参数的装饰器（三层嵌套）

场景：允许用户自定义日志级别或重试次数。

def repeat(times=3):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator
@repeat(times=5)
def greet(name):
    print(f"Hello {name}")
greet("Python")  # 打印5次

注意：带参装饰器需要三层函数：外层接收参数，中层接收函数，内层实现功能。

2 类装饰器（更高灵活度）

适用：需要维护状态（如调用次数统计）或依赖类继承的场景。

class CountCalls:
    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.calls = 0
    def __call__(self, *args, **kwargs):
        self.calls += 1
        print(f"第 {self.calls} 次调用")
        return self.func(*args, **kwargs)
@CountCalls
def say_hi():
    print("Hi!")
say_hi()  # 第1次
say_hi()  # 第2次

类装饰器优势：可以通过self.calls属性保存状态，比闭包更直观。

常见陷阱与调优技巧

陷阱1：装饰器顺序问题

多个装饰器时，执行顺序从内到外（靠近函数的先执行）：

@decorator_a
@decorator_b
def func(): ...
# 实际: func = decorator_a(decorator_b(func))

陷阱2：带参装饰器与`functools.wraps`冲突

解决方案：始终在wrapper上使用@functools.wraps(func)，无论装饰器是否带参。

调优技巧：用`functools.lru_cache`加速重复计算

这是Python内置的装饰器，自动缓存函数结果，适合纯函数：

@functools.lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2: return n
    return fibonacci(n-1) + fibonacci(n-2)

真实项目中的装饰器应用场景

场景1：Web框架的权限校验（Flask示例）

def login_required(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        if not current_user.is_authenticated:
            return redirect(url_for('login'))
        return func(*args, **kwargs)
    return wrapper
@app.route('/admin')
@login_required
def admin_dashboard():
    return render_template('admin.html')

场景2：数据库操作的自动重试

def retry_on_failure(max_retries=3, delay=1):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_retries - 1:
                        raise
                    time.sleep(delay)
            return None
        return wrapper
    return decorator
@retry_on_failure(max_retries=5)
def query_database(sql):
    # 可能超时的操作
    pass

场景3：异步函数的装饰器（Python 3.10+）

import asyncio
def async_timer(func):
    async def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = await func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"异步耗时 {elapsed}")
        return result
    return wrapper
@async_timer
async def fetch_data():
    await asyncio.sleep(1)
    return "数据"

高频问答与避坑指南

Q1：装饰器可以装饰类方法吗？

答：可以，但需注意self参数的传递，最常见的坑是装饰器内忘记传入self：

def method_decorator(func):
    def wrapper(self, *args, **kwargs):
        print("方法前")
        return func(self, *args, **kwargs)  # 必须显式传self
    return wrapper

Q2：如何让装饰器支持参数（如`@decorator(arg)`）和常规使用（`@decorator`）两种方式？

答：用functools.partial实现双模式：

def double_mode(func=None, *, repeat=1):
    if func is None:
        return lambda f: double_mode(f, repeat=repeat)
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        for _ in range(repeat):
            result = func(*args, **kwargs)
        return result
    return wrapper
@double_mode  # 常规使用
def foo(): ...
@double_mode(repeat=3)  # 带参使用
def bar(): ...

Q3：装饰器和闭包的区别？

闭包：内部函数可以访问外部函数的变量（词法作用域）。
装饰器：专门用于修改或增强其他函数的闭包模式。所有装饰器都是闭包，但闭包不一定是装饰器。

Q4：用装饰器修改变量作用域需要注意什么？

当装饰器需要修改外部变量时，需使用nonlocal关键字（Python 3）：

def counter():
    count = 0
    def decorator(func):
        def wrapper(*args, **kwargs):
            nonlocal count
            count += 1
            print(f"第{count}次")
            return func(*args, **kwargs)
        return wrapper
    return decorator