Python装饰器如何扩展函数功能？

本篇文章向大家介绍《Python装饰器如何扩展函数功能？》，主要包括，具有一定的参考价值，需要的朋友可以参考一下。

装饰器是一个接收函数并返回新函数的高阶函数，用于在不修改原函数代码的情况下添加额外功能；2. 实现装饰器需定义外层函数接收原函数，内层wrapper函数封装原函数并添加逻辑，最后返回wrapper；3. 使用@decorator语法糖可简洁地应用装饰器，等价于func = decorator(func)；4. wrapper函数应使用*args和**kwargs接收任意参数，以支持带参数的原函数；5. 为保留原函数的\_\_name\_\_、\_\_doc\_\_等元信息，应使用functools.wraps装饰wrapper；6. 带参数的装饰器需再增加一层函数嵌套，外层接收装饰器参数，中间层为真正的装饰器，内层为wrapper。装饰器通过函数嵌套和闭包机制，实现了对函数行为的动态增强，同时保持代码的清晰与复用性。

Python的装饰器，说白了，就是一种非常优雅且强大的语法糖，它允许你在不修改原始函数代码的前提下，给函数动态地添加一些额外的功能或者修改它的行为。你可以把它想象成给函数穿上一件“外套”，这件外套能做很多事情，比如日志记录、性能监控、权限校验等等，而函数本身对此毫不知情，或者说，它根本不需要关心这些。

解决方案

要用装饰器给函数添加额外功能，核心思路是创建一个“高阶函数”。这个高阶函数会接收一个函数作为参数，然后返回一个新的函数。这个新的函数通常是一个“闭包”，它在内部调用了原始函数，并在调用前后（或者根据需要）执行一些额外的逻辑。Python通过@符号提供了一种非常方便的语法糖来使用装饰器，让代码看起来更简洁直观。

举个例子，假设我们想给一个函数添加一个日志功能，每次函数执行前都打印一条信息，执行后也打印一条。

def log_decorator(func):
    """这是一个简单的日志装饰器"""
    def wrapper(*args, **kwargs):
        print(f"--- 函数 '{func.__name__}' 即将执行 ---")
        result = func(*args, **kwargs) # 调用原始函数
        print(f"--- 函数 '{func.__name__}' 执行完毕 ---")
        return result
    return wrapper

@log_decorator
def greet(name):
    """一个简单的问候函数"""
    print(f"你好，{name}！")
    return f"Hello, {name}!"

@log_decorator
def calculate_sum(a, b):
    """计算两个数的和"""
    print(f"正在计算 {a} + {b}...")
    return a + b

# 使用被装饰的函数
greet("小明")
print("-" * 20)
total = calculate_sum(10, 20)
print(f"计算结果是: {total}")

在这个例子里，log_decorator就是我们的装饰器。它接收greet或calculate_sum函数，然后返回一个wrapper函数。当我们调用greet("小明")时，实际上执行的是log_decorator返回的那个wrapper函数，这个wrapper函数在内部调用了真正的greet函数，并在前后添加了日志打印。

装饰器究竟是个什么“东西”？

说实话，刚接触装饰器的时候，我个人觉得它有点绕，尤其是那个嵌套的函数结构。但当你理解了它的本质，就会发现它其实是Python里“函数是第一类对象”这个概念的极致体现。简单来说，装饰器就是一个能接受函数作为输入，并返回一个新函数的函数。

用更具体一点的说法，当你写下@some_decorator在函数定义上方时，这行代码等价于：

def original_function():
    pass

# original_function = some_decorator(original_function)
# 语法糖的背后就是这样

它把original_function作为参数传给了some_decorator，然后把some_decorator的返回值（通常是另一个函数，也就是我们上面例子里的wrapper）重新赋值给了original_function这个名字。所以，之后你再调用original_function()时，实际上调用的是被装饰器“加工”过的新函数。

这种设计哲学，我个人觉得非常棒，它让代码的关注点分离变得更容易。比如，你的核心业务逻辑可以保持干净，而那些通用的、横切面的功能（像日志、缓存、权限等）则可以通过装饰器优雅地注入进来，互不干扰。

写一个最简单的装饰器，我该从何入手？

要写一个最简单的装饰器，你得先理解那个“两层嵌套”的结构。这确实是初学者的一道坎，但一旦跨过去，就豁然开朗了。

步骤拆解：

1. 定义外层函数： 这个函数就是你的装饰器本身，它接受一个参数，这个参数就是你要装饰的那个函数（我们通常称之为func或original_func）。
2. 定义内层函数（wrapper）： 在外层函数内部，你需要定义另一个函数，我们习惯叫它wrapper。这个wrapper函数才是真正用来替代原始函数的。它会负责调用原始函数，并在调用前后加入你想要实现的额外逻辑。
3. 返回内层函数： 外层函数最后需要返回这个wrapper函数。

我们来写一个最最简单的，比如一个统计函数执行时间的装饰器：

import time

def timer_decorator(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

@timer_decorator
def long_running_task():
    """一个模拟耗时操作的函数"""
    print("开始执行耗时任务...")
    time.sleep(2) # 模拟IO或计算密集型操作
    print("耗时任务完成。")
    return "任务结果"

@timer_decorator
def greet_person(name, age):
    print(f"你好，{name}！你今年{age}岁了。")
    time.sleep(0.5)
    return "问候完毕"

# 调用被装饰的函数
task_result = long_running_task()
print(f"任务最终结果: {task_result}")
print("-" * 20)
greet_person("张三", 30)

这里有个小细节，你可能注意到了wrapper(*args, **kwargs)。这是为了确保你的装饰器能够处理任何带有参数（位置参数和关键字参数）的函数。如果没有它们，你的装饰器就只能装饰那些不带参数的函数了，这显然不符合实际需求。

还有一个常见的问题，就是被装饰后的函数，它的__name__、__doc__等元信息会变成wrapper函数的元信息，而不是原始函数的。这在调试或者一些框架反射时会造成困扰。解决方案也很简单，Python标准库里提供了functools.wraps这个装饰器，它可以帮助我们把原始函数的元信息“拷贝”到wrapper函数上。

import time
from functools import wraps # 导入wraps

def timer_decorator_with_wraps(func):
    """一个带functools.wraps的计时装饰器"""
    @wraps(func) # 使用wraps来保留原始函数的元信息
    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

@timer_decorator_with_wraps
def another_task():
    """这是另一个任务的文档字符串"""
    time.sleep(1)
    return "另一个任务完成"

print(f"函数名: {another_task.__name__}") # 输出会是 'another_task' 而不是 'wrapper'
print(f"文档: {another_task.__doc__}")

这下，another_task的__name__和__doc__就正确了，这在实际开发中非常有用。

装饰器能处理带参数的函数吗？

当然可以，而且在实际应用中，绝大多数被装饰的函数都是带参数的。前面在写timer_decorator的时候，我已经悄悄地展示了这一点：wrapper(*args, **kwargs)就是处理带参数函数的关键。

*args会收集所有传递给wrapper的位置参数，并将它们打包成一个元组。 **kwargs会收集所有传递给wrapper的关键字参数，并将它们打包成一个字典。

然后，你只需要把这些收集到的参数原封不动地传递给原始函数func(*args, **kwargs)，这样无论原始函数需要什么参数，都能正确地接收到。

我们再来看一个稍微复杂一点的例子，比如一个权限检查的装饰器，它需要知道当前用户是否有权限访问某个函数，而这个函数本身可能也需要参数：

from functools import wraps

# 模拟一个用户权限列表
AUTHORIZED_USERS = {"admin", "editor"}

def permission_required(allowed_roles):
    """
    一个需要权限的装饰器，装饰器本身也带参数。
    它需要一个参数来指定哪些角色被允许。
    """
    def decorator(func): # 这是真正的装饰器函数，它接收被装饰的函数
        @wraps(func)
        def wrapper(current_user, *args, **kwargs): # wrapper需要接收用户参数以及原始函数的其他参数
            if current_user in allowed_roles:
                print(f"用户 '{current_user}' 权限通过，执行 '{func.__name__}'。")
                return func(current_user, *args, **kwargs) # 传递所有参数给原始函数
            else:
                print(f"用户 '{current_user}' 没有权限执行 '{func.__name__}'。所需权限: {allowed_roles}")
                return None # 或者抛出异常

        return wrapper
    return decorator

@permission_required(allowed_roles=AUTHORIZED_USERS)
def view_sensitive_data(user, data_id):
    """查看敏感数据的功能"""
    print(f"用户 '{user}' 正在查看数据ID: {data_id}")
    return f"敏感数据 {data_id} 的详细内容。"

@permission_required(allowed_roles={"admin"})
def delete_user_account(user, user_to_delete):
    """删除用户账户的功能"""
    print(f"用户 '{user}' 正在尝试删除用户: {user_to_delete}")
    return f"用户 '{user_to_delete}' 已被删除。"

# 测试
print("--- 尝试查看敏感数据 ---")
result1 = view_sensitive_data("admin", "ABC123")
print(f"结果: {result1}\n")

result2 = view_sensitive_data("guest", "XYZ789")
print(f"结果: {result2}\n")

print("--- 尝试删除用户账户 ---")
result3 = delete_user_account("admin", "john_doe")
print(f"结果: {result3}\n")

result4 = delete_user_account("editor", "jane_doe")
print(f"结果: {result4}\n")

这个例子里，permission_required本身也是一个函数，它接受allowed_roles参数，然后返回一个真正的装饰器函数decorator。这个decorator再接收func，并返回wrapper。这就是所谓的“带参数的装饰器”，它比前面不带参数的装饰器多了一层嵌套，但核心思想没变。wrapper函数依然通过*args和**kwargs完美地处理了原始函数view_sensitive_data和delete_user_account可能带有的其他参数。

所以，无论是原始函数有没有参数，装饰器都能灵活地处理，关键就在于wrapper函数签名中的*args和**kwargs，以及你如何把它们传给原始函数。

文中关于高阶函数,Python装饰器,@语法糖,函数功能扩展,wrapper函数的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《Python装饰器如何扩展函数功能？》文章吧，也可关注golang学习网公众号了解相关技术文章。