python中的装饰器本质上是一个接收函数并返回新函数的特殊函数，它通过@符号实现语法糖机制，使得在不修改原函数代码的前提下扩展其行为。装饰器的执行顺序遵循从下往上的原则，但调用时最外层装饰器先执行；使用functools.wraps可保留原函数元数据，确保装饰后函数信息完整；带参数的装饰器通过三层嵌套结构实现，由装饰器工厂函数接收参数并返回实际装饰器；类也可作为装饰器，通常通过__call__方法实现功能扩展或修改。这些特性使装饰器成为封装日志记录、性能分析、权限校验等通用逻辑的强大工具。
Python中的装饰器，本质上是一个特殊的函数，它能接收另一个函数作为参数，并返回一个新的函数，这个新函数通常在不修改原函数源代码的情况下，扩展或修改了原函数的行为。它提供了一种优雅的方式来封装可重用的代码逻辑，比如日志记录、性能分析、权限校验等。
解决方案
使用Python装饰器，最直观的方式就是利用它的“语法糖”特性，即在定义函数时，在其上方使用 @ 符号加上装饰器函数的名称。
import time
import functools
# 一个简单的日志装饰器
def log_calls(func):
@functools.wraps(func) # 保持原函数的元数据，非常重要！
def wrapper(*args, **kwargs):
print(f"正在调用函数: {func.__name__}，参数: {args}, {kwargs}")
result = func(*args, **kwargs)
print(f"函数 {func.__name__} 调用完成，结果: {result}")
return result
return wrapper
# 一个简单的性能测量装饰器
def time_it(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
start_time = time.perf_counter()
result = func(*args, **kwargs)
end_time = time.perf_counter()
print(f"函数 {func.__name__} 执行耗时: {end_time - start_time:.4f} 秒")
return result
return wrapper
@log_calls
@time_it
def calculate_sum(a, b):
"""计算两个数的和"""
time.sleep(0.1) # 模拟耗时操作
return a + b
@log_calls
def greet(name):
"""向某人打招呼"""
return f"你好，{name}！"
# 使用被装饰的函数
print("--- 第一次调用 calculate_sum ---")
total = calculate_sum(10, 20)
print(f"最终结果: {total}\n")
print("--- 第二次调用 greet ---")
message = greet("张三")
print(f"最终消息: {message}")
# 验证functools.wraps的作用
print(f"\ncalculate_sum 的文档字符串: {calculate_sum.__doc__}")
print(f"calculate_sum 的名称: {calculate_sum.__name__}")上面这个例子展示了如何定义和使用两个不同的装饰器，并且它们可以堆叠使用。当你调用 calculate_sum(10, 20) 时，它会先被 time_it 装饰器处理，再被 log_calls 装饰器处理。执行顺序是从下往上（离函数定义最近的先执行），但实际执行时，最外层的装饰器（log_calls）的 wrapper 会先被调用，然后它会调用内层的 wrapper（time_it 的），最终才调用原始函数 calculate_sum。
立即学习“Python免费学习笔记（深入）”；
@符号背后的魔法：Python装饰器的语法糖原理
当我第一次看到 @ 符号时，它给我的感觉就像是某种魔法，能凭空给函数加上新功能。但深入了解后，才发现它不过是Python提供的一个非常巧妙的语法糖。理解这背后的原理，能帮助我们更好地掌握装饰器，甚至在调试时茅塞顿开。
简单来说，@decorator_name 放在函数定义上方，等同于在函数定义完成后，执行 函数名 = decorator_name(函数名) 这行代码。
以我们之前的 log_calls 装饰器为例：
@log_calls
def my_function():
print("这是我的函数")这段代码在Python解释器看来，实际上是这样的：
def my_function():
print("这是我的函数")
my_function = log_calls(my_function) # 这一步就是语法糖的本质这意味着 log_calls 函数接收了 my_function 这个函数对象作为参数，然后 log_calls 返回了一个新的函数对象（也就是我们 wrapper），这个新的函数对象又被重新赋值给了 my_function 这个名字。所以，当你之后调用 my_function() 时，你实际上调用的是 log_calls 返回的那个 wrapper 函数，而不是最初定义的 my_function。这个 wrapper 函数内部才负责调用原始的 my_function，并在其前后添加额外的逻辑。
这种机制的精妙之处在于，它让我们可以“无痛”地修改或扩展函数的行为，而不需要去动原始函数的代码。对于代码的维护和复用来说，简直是福音。
装饰器的进阶用法：带参数的装饰器与类装饰器
当你对基础装饰器运用自如后，自然会遇到更复杂的需求：比如，我希望我的装饰器能接收一些配置参数，或者我需要装饰的不是函数，而是整个类。别担心，Python的装饰器机制同样提供了优雅的解决方案。
带参数的装饰器
想象一下，你希望一个限速装饰器能够自定义每分钟允许的调用次数。这时候，装饰器本身就需要接收参数。这通常通过一个“装饰器工厂”函数来实现，它接收参数，然后返回一个真正的装饰器。
def rate_limit(calls_per_minute):
# 这是一个装饰器工厂，它接收参数，并返回一个装饰器
def decorator(func):
last_called = {} # 简单模拟，实际生产环境需更健壮的机制
@functools.wraps(func)
def wrapper(*args, **kwargs):
current_time = time.time()
if func.__name__ not in last_called:
last_called[func.__name__] = []
# 移除一分钟前的调用记录
last_called[func.__name__] = [
t for t in last_called[func.__name__] if current_time - t < 60
]
if len(last_called[func.__name__]) >= calls_per_minute:
print(f"函数 {func.__name__} 调用过于频繁，请稍后再试！")
return None # 或者抛出异常
last_called[func.__name__].append(current_time)
return func(*args, **kwargs)
return wrapper
return decorator
@rate_limit(calls_per_minute=2) # 传入参数
def send_email(to_address, subject):
print(f"发送邮件到 {to_address}，主题：{subject}")
return True
print("\n--- 测试带参数的装饰器 ---")
send_email("test@example.com", "Hello") # 第一次，成功
send_email("test@example.com", "Hello") # 第二次，成功
send_email("test@example.com", "Hello") # 第三次，失败（被限速）
time.sleep(61) # 等待超过一分钟
send_email("test@example.com", "Hello again") # 第四次，成功这里，rate_limit 函数首先被调用，它接收 calls_per_minute 参数，然后返回 decorator 函数。接着，这个 decorator 函数作为真正的装饰器，接收 send_email 函数，并返回 wrapper 函数。所以，这实际上是三层嵌套：rate_limit -> decorator -> wrapper。
类装饰器
虽然不如函数装饰器常见，但类同样可以作为装饰器。一个类作为装饰器时，它的实例通常会被设计成可调用的（通过实现 __call__ 方法），或者类本身作为装饰器工厂。
以下是一个简单的类装饰器示例，它给被装饰的类添加一个方法：
class AddMethodDecorator:
def __init__(self, new_method_name):
self.new_method_name = new_method_name
def __call__(self, cls):
# 这是一个简单的类装饰器，给类添加一个新方法
def added_method(self_instance):
return f"这是 {self_instance.__class__.__name__} 类通过装饰器添加的方法 '{self.new_method_name}'。"
setattr(cls, self.new_method_name, added_method)
return cls
@AddMethodDecorator("say_hello")
class MyClass:
def __init__(self, name):
self.name = name
def get_name(self):
return self.name
print("\n--- 测试类装饰器 ---")
obj = MyClass("Alice")
print(obj.get_name())
print(obj.say_hello()) # 调用通过装饰器添加的方法
这个 AddMethodDecorator 类在被实例化时（例如 @AddMethodDecorator("say_hello")），其 __call__ 方法会被调用，并将 MyClass 作为参数传入。__call__ 方法随后动态地向 MyClass 添加了一个名为 say_hello 的新方法，并返回修改后的 MyClass。类装饰器通常用于为类添加功能、注册类、修改类属性或方法等场景。
掌握了这些，你对Python装饰器的理解就更上一层楼了。它们确实是Python中一个强大而灵活的特性，能够极大地提升代码的模块化和复用性。不过，在使用时也要注意，过度复杂的装饰器链可能会增加调试的难度，所以保持简洁和单一职责原则依然很重要。
