Python装饰器动态修改函数行为详解

IT行业相对于一般传统行业，发展更新速度更快，一旦停止了学习，很快就会被行业所淘汰。所以我们需要踏踏实实的不断学习，精进自己的技术，尤其是初学者。今天golang学习网给大家整理了《Python装饰器动态修改函数行为教程》，聊聊，我们一起来看看吧！

装饰器是通过高阶函数动态增强函数行为的技术，利用函数是一等公民的特性，以@语法糖实现包装逻辑。

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里函数是“一等公民”这回事。这意味着函数可以像普通变量一样被赋值、作为参数传递、甚至作为另一个函数的返回值。装饰器正是利用了这一点。

当你写 @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。这种模式让我们能灵活地配置装饰器的行为，非常实用。

装饰器在实际项目中有什么应用场景？

装饰器在实际项目里简直是“万金油”，能解决好多重复性的、横切关注点的问题。我个人觉得，以下几个

理论要掌握，实操不能落！以上关于《Python装饰器动态修改函数行为详解》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！