该提问与当前博客内容无直接关联。 在 Python 中，带有参数的装饰器是一个高阶函数，它本身接受参数，并返回一个真正的装饰器（即一个接受函数作为参数的函数）。这为实现更灵活、可配置的装饰逻辑提供了可能。其核心原理是利用函数的嵌套和闭包特性。 ### 一、 原理与结构拆解 一个标准的无参数装饰器结构如下： ```python def decorator(func): def wrapper(*args, **kwargs): # 增强逻辑 result = func(*args, **kwargs) # 增强逻辑 return result return wrapper @decorator def target_function(): pass ``` 当需要在装饰时传入配置参数（如日志级别、重试次数、权限角色等）时，就必须使用带参数的装饰器。其结构演变为三层嵌套函数： 1. **最外层**：接收装饰器自身的参数。 2. **中间层**：接收被装饰的目标函数。 3. **最内层**：包装并执行目标函数，该层可以访问外层传递的所有参数。 ### 二、 典型示例与代码解析 以下通过三个由浅入深的示例，阐述其实现与应用。 #### 示例 1：基础参数化装饰器 - 重复执行 此装饰器接受一个整数参数 `times`，用于控制目标函数的执行次数。 ```python def repeat(times): """装饰器：重复执行被装饰的函数指定次数。""" def actual_decorator(func): def wrapper(*args, **kwargs): for i in range(times): print(f"第 {i+1} 次执行") result = func(*args, **kwargs) return result # 注意：这里返回的是最后一次执行的结果 return wrapper return actual_decorator # 使用装饰器，传入参数 times=3 @repeat(times=3) def greet(name): print(f"Hello, {name}!") return f"Greeted {name}" # 调用函数 output = greet("Alice") print(f"函数返回值: {output}") ``` **执行输出：** ``` 第 1 次执行 Hello, Alice! 第 2 次执行 Hello, Alice! 第 3 次执行 Hello, Alice! 函数返回值: Greeted Alice ``` **解析**：`@repeat(times=3)` 的语法等价于 `greet = repeat(times=3)(greet)`。首先调用 `repeat(3)`，它返回 `actual_decorator` 函数；然后 `actual_decorator(greet)` 被调用，返回最终的 `wrapper` 函数。`wrapper` 通过闭包记住了 `times=3` 和原始函数 `func`。 #### 示例 2：应用场景 - 带权限验证的 API 装饰器 这是一个更贴近实战的场景，装饰器根据传入的角色列表来验证用户权限。 ```python from functools import wraps def require_role(allowed_roles): """ 装饰器：检查当前用户角色是否在允许的角色列表中。 :param allowed_roles: list[str]，允许访问的角色列表。 """ def decorator(view_func): @wraps(view_func) # 使用wraps保留原函数的元信息 def wrapped_view(request, *args, **kwargs): # 假设request对象中包含当前用户的角色信息 current_user_role = getattr(request, 'role', 'guest') if current_user_role not in allowed_roles: return {"error": "Forbidden", "detail": f"角色 {current_user_role} 无访问权限"}, 403 # 权限验证通过，执行原视图函数 return view_func(request, *args, **kwargs) return wrapped_view return decorator # 模拟一个请求对象 class MockRequest: def __init__(self, role): self.role = role # 使用装饰器定义不同的API端点 @require_role(allowed_roles=['admin', 'editor']) def delete_article(request): return {"message": "文章删除成功"} @require_role(allowed_roles=['admin', 'editor', 'viewer']) def view_article(request): return {"message": "这是文章内容"} # 测试 admin_request = MockRequest(role='admin') guest_request = MockRequest(role='guest') print(view_article(admin_request)) # 输出: {'message': '这是文章内容'} print(view_article(guest_request)) # 输出: {'message': '这是文章内容'} (viewer角色被允许) print(delete_article(admin_request)) # 输出: {'message': '文章删除成功'} print(delete_article(guest_request)) # 输出: {'error': 'Forbidden', 'detail': '角色 guest 无访问权限'} ``` #### 示例 3：工厂模式装饰器 - 可配置的日志装饰器 此装饰器接受日志级别和记录器名称作为参数，实现了高度的可配置性。 ```python import logging from functools import wraps def logged(level=logging.INFO, name=None): """ 装饰器工厂：记录函数调用日志。 :param level: 日志级别，如 logging.DEBUG, logging.INFO。 :param name: 日志记录器的名称，默认为函数模块名。 """ def decorator(func): logger_name = name if name else func.__module__ logger = logging.getLogger(logger_name) @wraps(func) def wrapper(*args, **kwargs): logger.log(level, f"调用函数: {func.__name__} | 参数: args={args}, kwargs={kwargs}") try: result = func(*args, **kwargs) logger.log(level, f"函数 {func.__name__} 执行成功，返回: {result}") return result except Exception as e: logger.exception(f"函数 {func.__name__} 执行时发生异常: {e}") raise return wrapper return decorator # 配置日志 logging.basicConfig(level=logging.DEBUG) # 使用装饰器，传入不同参数 @logged(level=logging.DEBUG, name='myapp.calculator') def add(a, b): return a + b @logged() # 使用默认参数 (INFO级别，模块名作为logger名) def risky_operation(): raise ValueError("模拟一个错误") # 测试 print(add(5, 3)) try: risky_operation() except ValueError: pass ``` ### 三、 技术对比与选型建议 在实际开发中，选择无参数还是有参数装饰器，取决于功能是否需要运行时配置。 | 特性维度 | 无参数装饰器 | 带参数装饰器 | | :--- | :--- | :--- | | **函数结构** | 两层嵌套 (`decorator(func)`) | 三层嵌套 (`decorator_factory(args)(func)`) | | **主要用途** | 固定的功能增强（如计时、单例） | 可配置的功能增强（如权限、重试、缓存过期时间） | | **灵活性** | 低，行为在定义时固化 | 高，行为可通过参数在装饰时动态指定 | | **代码复杂度** | 相对简单 | 相对复杂，涉及闭包和多层作用域 | | **典型场景** | `@staticmethod`, `@property`, `@functools.lru_cache()` | `@functools.lru_cache(maxsize=128)`, `@retry(stop_max_attempt_number=3)` | **最佳实践建议**： 1. **使用 `@wraps`**：在装饰器内部包装函数时，务必使用 `functools.wraps`，以保留原函数的名称、文档字符串等元数据，这对于调试和序列化至关重要。 2. **参数默认值**：为装饰器的参数提供合理的默认值，可以使其在大多数场景下以无参数形式简洁使用。 3. **明确闭包作用域**：理解内层函数如何通过闭包访问外层函数的参数，这是实现带参数装饰器的关键。 4. **考虑可测试性**：由于装饰器改变了函数签名和行为，在单元测试中，可能需要直接测试未被装饰的原始函数，或对装饰器逻辑本身进行独立测试。 总之，带参数的装饰器是 Python 元编程和函数式编程的强力工具，通过将配置与逻辑分离，极大地提升了代码的复用性和表达力。