Python中的函数装饰器执行时机与装饰器参数处理机制

一、问题描述
函数装饰器是Python中用于修改或增强函数行为的强大工具。理解装饰器的执行时机和参数处理机制对掌握高级Python编程至关重要。常见困惑包括：装饰器何时执行？带参数的装饰器如何工作？多层装饰器的执行顺序是怎样的？

二、装饰器基础回顾
装饰器本质上是一个可调用对象（函数或类），接受一个函数作为参数并返回一个新函数：

def decorator(func):
    def wrapper(*args, **kwargs):
        print("装饰器逻辑")
        return func(*args, **kwargs)
    return wrapper

@decorator
def target_function():
    print("目标函数")

当Python解释器遇到@decorator时，会立即执行装饰器函数。

三、装饰器执行时机详解
装饰器在模块导入时（函数定义时）立即执行，而非在函数调用时：

def decorator(func):
    print(f"装饰器执行，装饰函数: {func.__name__}")
    return func

@decorator  # 导入时立即输出"装饰器执行，装饰函数: target"
def target():
    print("函数调用")

print("模块加载完成")
# 输出顺序：
# 装饰器执行，装饰函数: target
# 模块加载完成

关键点：

1. 装饰器在函数定义后立即执行
2. 返回的新函数替换原函数名绑定
3. 函数调用时执行的是装饰器返回的包装函数

四、不带参数的装饰器参数处理
标准装饰器接收唯一参数——被装饰函数：

def trace(func):
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__name__} 参数: {args}, {kwargs}")
        result = func(*args, **kwargs)
        print(f"返回: {result}")
        return result
    return wrapper

@trace
def add(a, b):
    return a + b

# 等价于: add = trace(add)

五、带参数的装饰器参数处理
装饰器参数需要三层嵌套函数处理：

def repeat(num_times):  # 第一层：接收装饰器参数
    def decorator(func):  # 第二层：接收被装饰函数
        def wrapper(*args, **kwargs):  # 第三层：接收函数参数
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(num_times=3)  # 1. 执行repeat(3)返回decorator函数
def greet(name):
    print(f"Hello {name}")

# 执行过程分解：
# 步骤1: repeat(3) → 返回decorator函数
# 步骤2: @语法调用decorator(greet) → 返回wrapper函数
# 步骤3: greet名称绑定到wrapper函数

六、多层装饰器的执行顺序
多个装饰器从下往上依次应用：

@decorator1
@decorator2
def my_function():
    pass

# 等价于: my_function = decorator1(decorator2(my_function))

具体执行流程：

1. 先应用最内层装饰器：temp = decorator2(my_function)
2. 再应用外层装饰器：my_function = decorator1(temp)
3. 函数调用时从外向内执行包装逻辑

七、类装饰器的参数处理
类装饰器通过__init__和__call__方法处理参数：

class CountCalls:
    def __init__(self, func):  # 不带参数时接收被装饰函数
        self.func = func
        self.num_calls = 0
    
    def __call__(self, *args, **kwargs):
        self.num_calls += 1
        return self.func(*args, **kwargs)

# 带参数的类装饰器
class DecoratorWithArgs:
    def __init__(self, prefix):  # 第一层：接收装饰器参数
        self.prefix = prefix
    
    def __call__(self, func):  # 第二层：接收被装饰函数
        def wrapper(*args, **kwargs):
            print(f"{self.prefix}: 调用 {func.__name__}")
            return func(*args, **kwargs)
        return wrapper

@DecoratorWithArgs("DEBUG")
def test():
    pass

八、functools.wraps保持元信息
装饰器会掩盖原函数的元信息，需要使用functools.wraps保留：

from functools import wraps

def decorator(func):
    @wraps(func)  # 将原函数的元信息复制到包装函数
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

作用：

• 保持__name__、__doc__等属性不变
• 确保调试和文档生成的正确性

九、实际应用场景

1. 日志记录：自动记录函数调用参数和返回值
2. 权限验证：检查用户权限后再执行函数
3. 性能监控：测量函数执行时间
4. 重试机制：对失败操作自动重试
5. 缓存装饰器：记忆化函数计算结果

理解装饰器的执行时机和参数处理机制，能够帮助您编写更灵活、可维护的装饰器，并在实际开发中正确应用这种强大的元编程技术。