装饰器是通过高阶函数动态增强函数行为的技术，利用函数是一等公民的特性，以@语法糖实现包装逻辑。
Python的装饰器提供了一种非常优雅且强大的方式来修改或增强函数、方法甚至类的行为，而无需直接改动它们原有的代码。说白了，它就是个“包装器”，在不触碰核心逻辑的前提下，给函数穿上新衣服，赋予新能力。
要用装饰器动态修改函数行为，核心在于理解装饰器本身就是一个接受函数作为参数，并返回一个新函数（通常是内部定义的
wrapper函数）的“高阶函数”。这个
wrapper函数会执行一些额外的逻辑，然后（或在特定条件下）调用原始函数。
一个最简单的装饰器骨架大概长这样：
import time
def log_execution_time(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs) # 调用原始函数
end_time = time.time()
print(f"函数 '{func.__name__}' 执行耗时: {end_time - start_time:.4f} 秒")
return result
return wrapper
# 使用装饰器
@log_execution_time
def my_complex_calculation(a, b):
time.sleep(0.5) # 模拟耗时操作
return a * b
# 调用被装饰的函数
print(f"计算结果: {my_complex_calculation(10, 20)}")
# 实际上，@log_execution_time 等价于 my_complex_calculation = log_execution_time(my_complex_calculation)这段代码展示了如何通过
log_execution_time装饰器，在不修改
my_complex_calculation函数体的情况下，给它加上了计时功能。
wrapper函数在这里就是行为修改的核心，它在调用原函数前后插入了计时逻辑。
立即学习“Python免费学习笔记（深入）”；
装饰器的工作原理是什么？
在我看来，理解装饰器，首先得明白Python里函数是“一等公民”这回事。这意味着函数可以像普通变量一样被赋值、作为参数传递、甚至作为另一个函数的返回值。装饰器正是利用了这一点。
当你写
@decorator_name在一个函数定义上方时，Python解释器做的事情，其实就是把这个函数对象作为参数传给
decorator_name这个函数，然后把
decorator_name返回的新函数重新赋值给原来的函数名。举个例子：
@my_decorator
def say_hello():
print("Hello!")这行代码在运行时，等价于：
def say_hello():
print("Hello!")
say_hello = my_decorator(say_hello)所以，
my_decorator函数需要接受一个函数作为输入，并且必须返回一个函数作为输出。通常，这个返回的函数是一个内部定义的
wrapper（或
inner）函数，它“闭包”了外部作用域的变量，特别是那个被装饰的原始函数。
wrapper函数才是真正执行你想要添加的新行为的地方，它在执行新行为后，会适时地调用原始函数。这种机制巧妙地实现了行为的“注入”和“包装”。
如何编写一个带参数的装饰器？
有时候，我们希望装饰器本身也能接受一些配置参数，比如一个重试装饰器，我们想指定重试的次数。这时候，装饰器就需要多一层嵌套，变成一个“装饰器工厂”。
结构上，它会是三层：最外层函数负责接收装饰器参数，它返回一个真正的装饰器（第二层），这个真正的装饰器再返回那个执行实际逻辑的
wrapper函数（第三层）。
import time
import functools
def retry(max_attempts=3, delay=1):
def decorator(func):
@functools.wraps(func) # 保持原函数的元数据
def wrapper(*args, **kwargs):
attempts = 0
while attempts < max_attempts:
try:
return func(*args, **kwargs)
except Exception as e:
attempts += 1
print(f"尝试失败 ({attempts}/{max_attempts}): {e}")
if attempts < max_attempts:
time.sleep(delay)
raise RuntimeError(f"函数 '{func.__name__}' 在 {max_attempts} 次尝试后仍失败。")
return wrapper
return decorator
@retry(max_attempts=5, delay=2) # 装饰器带参数
def unreliable_operation():
import random
if random.random() < 0.7: # 70% 的几率失败
raise ValueError("模拟网络错误或临时故障")
print("操作成功！")
return "成功数据"
# 调用被装饰的函数
try:
result = unreliable_operation()
print(f"最终结果: {result}")
except RuntimeError as e:
print(e)
print("-" * 30)
@retry() # 使用默认参数
def another_unreliable_op():
import random
if random.random() < 0.5:
raise ConnectionError("连接超时")
print("另一个操作成功！")
return "另一个成功数据"
try:
result = another_unreliable_op()
print(f"最终结果: {result}")
except RuntimeError as e:
print(e)这里的
retry函数就是装饰器工厂，它先接收
max_attempts和
delay参数，然后返回
decorator。
decorator再接收被装饰的函数
func，并返回
wrapper。这种模式让我们能灵活地配置装饰器的行为，非常实用。
装饰器在实际项目中有什么应用场景？
装饰器在实际项目里简直是“万金油”，能解决好多重复性的、横切关注点的问题。我个人觉得，以下几个
