当前位置：首页 > 文章列表 > 文章 > python教程 > Python装饰器原理与应用详解

Python装饰器原理与应用详解

2026-04-14 12:40:50 0浏览收藏

Python装饰器是利用函数作为一等公民和闭包机制实现的优雅编程技巧，它允许你在不修改原函数代码的前提下，通过@语法为其动态添加日志记录、权限校验、缓存、重试、性能监控等横切关注功能，极大提升代码复用性、可维护性与可读性；文章从原理剖析到实战示例层层深入，涵盖基础装饰器、带参数装饰器、类装饰器及多种真实场景应用，帮你真正掌握这一让Python代码更简洁、更强大、更具“魔法感”的核心技能。

Python怎么编写一个装饰器_Python装饰器原理与实战开发

Python装饰器，说白了，就是一种特殊函数，它能接收一个函数作为输入，然后给这个函数增加一些额外功能，最终返回一个全新的函数。它就像给你的老朋友穿上了一件新衣服，朋友还是那个朋友，但现在他可能更酷、更强大了，而且这一切都发生在不改变朋友本身代码的前提下。用起来很方便，一个@符号就能搞定。

解决方案

编写一个Python装饰器，核心在于理解函数作为一等公民的特性以及闭包的概念。最基础的装饰器，通常是一个接收函数、定义一个内部包装函数、然后返回这个包装函数的高阶函数。

我们先从一个最简单的例子开始。假设我们想在每次调用某个函数之前和之后都打印一些信息，但又不想每次都手动加print。

import functools

def log_calls(func):
    """
    这是一个简单的装饰器，用于记录函数被调用的信息。
    """
    @functools.wraps(func) # 这一行很重要，它能保留原函数的元信息，比如函数名、文档字符串等。
    def wrapper(*args, **kwargs):
        print(f"--- 函数 '{func.__name__}' 即将被调用 ---")
        # 执行原函数
        result = func(*args, **kwargs)
        print(f"--- 函数 '{func.__name__}' 调用完毕，返回值为: {result} ---")
        return result
    return wrapper

# 现在，我们用这个装饰器来装饰一个函数
@log_calls
def add(a, b):
    """一个简单的加法函数。"""
    print(f"正在执行 add({a}, {b})")
    return a + b

@log_calls
def greet(name, greeting="Hello"):
    """向指定的人打招呼。"""
    print(f"正在执行 greet('{name}', '{greeting}')")
    return f"{greeting}, {name}!"

# 调用被装饰的函数
print("调用 add(5, 3):")
sum_result = add(5, 3)
print(f"add 函数的最终结果是: {sum_result}\n")

print("调用 greet('Alice'):")
greet_result = greet("Alice")
print(f"greet 函数的最终结果是: {greet_result}\n")

print("调用 greet('Bob', greeting='Hi'):")
greet_result_hi = greet("Bob", greeting="Hi")
print(f"greet 函数的最终结果是: {greet_result_hi}\n")

# 如果没有 @log_calls 语法糖，手动装饰是这样的：
# original_add = add
# add = log_calls(original_add)
# print(add(1, 2))

在这个例子里，log_calls就是我们的装饰器。它接收一个函数func，内部定义了一个wrapper函数，wrapper函数负责在调用func前后添加逻辑，并最终返回func的执行结果。最后，log_calls返回这个wrapper函数。当我们把@log_calls放在add函数上方时，Python解释器其实做了一件等价于add = log_calls(add)的事情，也就是说，add这个名字现在指向的不再是原来的加法函数，而是log_calls返回的那个wrapper函数。

functools.wraps非常关键，它能把原函数的一些重要元信息（比如__name__、__doc__、__module__等）复制到wrapper函数上。如果没有它，当你调试或者查看add.__name__时，你会发现它变成了wrapper，而不是add，这会给调试带来不小的麻烦。

Python装饰器的核心工作原理是什么？

在我看来，理解Python装饰器的核心，主要抓住两点：函数是“一等公民”和闭包。

首先，Python中的函数是“一等公民”（First-Class Citizen）。这意味着函数可以像普通变量一样被赋值给其他变量，可以作为参数传递给其他函数，也可以作为其他函数的返回值。正是因为这个特性，我们才能把一个函数（被装饰的函数）传给另一个函数（装饰器），让装饰器对它进行操作。

其次，也是更关键的一点，是闭包（Closure）。当我们定义log_calls装饰器时，它内部的wrapper函数引用了外部log_calls函数的参数func。当log_calls执行完毕并返回wrapper时，即使log_calls的局部作用域已经消失，wrapper函数仍然能够“记住”并访问到它被创建时所处的环境中的func变量。这种机制就是闭包。

所以，当Python解释器看到@log_calls装饰器语法糖时，它会做以下几步：

定义时执行： 在add函数被定义时，log_calls(add)会被立即调用。
返回包装函数： log_calls函数执行，它接收add作为参数func，然后定义并返回一个名为wrapper的新函数。
替换原函数： 此时，add这个名字不再指向原始的add函数，而是指向log_calls返回的那个wrapper函数。
调用时执行： 当你之后调用add(5, 3)时，实际执行的是wrapper(5, 3)。wrapper函数内部会先打印一些信息，然后通过闭包机制访问到它“记住”的原始add函数，并调用它，获取结果，最后再打印一些信息，并将结果返回。

整个过程巧妙地实现了在不修改原函数代码的情况下，为其添加新功能，这在很多场景下都非常有用，比如日志、权限控制、性能测量等等。

装饰器在实际项目中能解决哪些常见问题？

实际开发中，装饰器简直是“万金油”，能优雅地解决很多跨领域、重复性的问题。它避免了代码的重复，让业务逻辑更聚焦。

日志记录与调试 (Logging & Debugging)： 这是最常见的用途。我们经常需要知道哪个函数在什么时候被调用了，传入了什么参数，返回了什么结果，或者执行了多久。一个通用的日志装饰器能完美解决这些需求，而不需要在每个函数内部都写一堆print或logging语句。

import time
import logging

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

def log_and_time(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        logging.info(f"Calling {func.__name__} with args: {args}, kwargs: {kwargs}")
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        logging.info(f"{func.__name__} finished in {end_time - start_time:.4f}s. Result: {result}")
        return result
    return wrapper

@log_and_time
def complex_calculation(x, y):
    time.sleep(0.1) # 模拟耗时操作
    return x * y + 10

complex_calculation(10, 20)

权限校验与认证 (Authentication & Authorization)： 在Web应用中，很多视图函数都需要检查用户是否已登录，或者是否有足够的权限来访问某个资源。把这些检查逻辑封装成装饰器，能让视图函数专注于处理业务逻辑，而不是权限验证。

def requires_admin(func):
    @functools.wraps(func)
    def wrapper(user, *args, **kwargs):
        if not user.is_authenticated:
            raise PermissionError("User not logged in.")
        if not user.is_admin:
            raise PermissionError("User does not have admin privileges.")
        return func(user, *args, **kwargs)
    return wrapper

class User:
    def __init__(self, name, authenticated=False, admin=False):
        self.name = name
        self.is_authenticated = authenticated
        self.is_admin = admin

@requires_admin
def delete_user_data(current_user, user_id):
    print(f"Admin '{current_user.name}' deleting data for user {user_id}")
    return True

# try:
#     admin_user = User("Alice", authenticated=True, admin=True)
#     delete_user_data(admin_user, 123)
#     guest_user = User("Bob", authenticated=True, admin=False)
#     delete_user_data(guest_user, 456)
# except PermissionError as e:
#     print(e)

缓存 (Caching)： 对于那些计算成本高昂且结果相对稳定的函数，我们可以用装饰器来缓存其返回值。当函数再次被相同的参数调用时，直接返回缓存结果，避免重复计算。

from functools import lru_cache

@lru_cache(maxsize=None) # Python内置的LRU缓存装饰器
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 第一次计算会比较慢
print(fibonacci(30))
# 第二次计算（相同参数）会非常快，因为结果已被缓存
print(fibonacci(30))

重试机制 (Retry Mechanism)： 当调用外部服务或执行可能失败的操作时，我们可能需要自动重试几次。一个重试装饰器可以优雅地处理这种场景。

import time
import random

def retry(max_attempts=3, delay=1):
    def decorator_retry(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    print(f"Attempt {attempt} failed: {e}")
                    if attempt < max_attempts:
                        time.sleep(delay)
            raise Exception(f"Function {func.__name__} failed after {max_attempts} attempts.")
        return wrapper
    return decorator_retry

@retry(max_attempts=5, delay=0.5)
def unstable_api_call():
    if random.random() < 0.7: # 70%的几率失败
        raise ConnectionError("Simulated API connection error.")
    return "Data fetched successfully!"

# print(unstable_api_call()) # 尝试调用，可能会重试几次

参数验证 (Argument Validation)： 在函数内部对参数进行类型或值检查，可以用装饰器来集中处理，保持函数体的简洁。

这些例子只是冰山一角，装饰器在Web框架（如Flask、Django的路由装饰器）、ORM（如SQLAlchemy的事件监听）、以及各种库中都扮演着重要角色，极大地提高了代码的复用性和可维护性。

编写带参数的装饰器有哪些技巧和注意事项？

带参数的装饰器，相比不带参数的，多了一层嵌套。这其实是理解装饰器更深一步的关键。

当装饰器本身需要接收参数时，它就不能直接返回wrapper函数了。它需要先接收自己的参数，然后返回一个真正的装饰器函数，这个装饰器函数再接收被装饰的函数，最后返回wrapper。听起来有点绕，但看代码就清楚了。

import functools

def repeat(num_times):
    """
    一个带参数的装饰器，让被装饰的函数重复执行指定次数。
    `num_times` 是装饰器自身的参数。
    """
    def decorator_repeat(func): # 这一层是真正的装饰器，它接收被装饰的函数
        @functools.wraps(func)
        def wrapper(*args, **kwargs): # 这一层是包装函数，它执行原函数
            print(f"--- 函数 '{func.__name__}' 将重复执行 {num_times} 次 ---")
            results = []
            for i in range(num_times):
                print(f"  执行第 {i+1} 次...")
                result = func(*args, **kwargs)
                results.append(result)
            print(f"--- 函数 '{func.__name__}' 执行完毕 ---")
            # 通常只返回最后一次执行的结果，或者根据需求返回所有结果
            return results[-1] if results else None
        return wrapper
    return decorator_repeat # 装饰器函数返回的是真正的装饰器

@repeat(num_times=3) # 这里 num_times=3 就是装饰器的参数
def say_hello(name):
    print(f"Hello, {name}!")
    return f"Hello result for {name}"

print("调用 say_hello('Charlie'):")
final_result = say_hello("Charlie")
print(f"say_hello 函数的最终结果是: {final_result}\n")

@repeat(num_times=2)
def calculate_power(base, exp):
    res = base ** exp
    print(f"{base}^{exp} = {res}")
    return res

print("调用 calculate_power(2, 3):")
power_result = calculate_power(2, 3)
print(f"calculate_power 函数的最终结果是: {power_result}\n")

技巧和注意事项：

多一层嵌套： 最直观的变化就是多了一层函数嵌套。外层函数repeat接收装饰器的参数（如num_times），它返回的是内层函数decorator_repeat。decorator_repeat才是那个接收被装饰函数func的“真正的”装饰器。
执行时机：
- @repeat(num_times=3)这行代码，首先会执行repeat(num_times=3)。
- repeat函数会立即执行，并返回decorator_repeat这个函数对象。
- 然后，Python解释器再用decorator_repeat去装饰say_hello函数，即执行say_hello = decorator_repeat(say_hello)。
- 所以，带参数的装饰器，它的参数是在定义被装饰函数时就确定了的，而不是在调用被装饰函数时才确定。
functools.wraps的位置： functools.wraps(func)应该放在最内层的wrapper函数上，因为它负责将func的元信息复制到最终被返回的wrapper函数上。
参数传递： 装饰器参数（如num_times）通过闭包机制，被decorator_repeat和wrapper函数“记住”并使用。

类作为装饰器： 除了函数，类也可以作为装饰器。如果一个类实现了__call__方法，它就可以被用作装饰器。当类被用作装饰器时，类的实例就是那个“包装函数”。

class CountCalls:
    def __init__(self, func):
        functools.update_wrapper(self, func) # 类似 functools.wraps
        self.func = func
        self.num_calls = 0

    def __call__(self, *args, **kwargs):
        self.num_calls += 1
        print(f"函数 '{self.func.__name__}' 已被调用 {self.num_calls} 次")
        return self.func(*args, **kwargs)

@CountCalls
def say_whee():
    print("Whee!")

# say_whee() # 第一次调用
# say_whee() # 第二次调用

类装饰器在需要维护状态（如上面的调用次数）时非常方便，因为状态可以直接存储在实例属性中。带参数的类装饰器也同样需要多一层嵌套，即外层函数返回一个类实例。

理解这些，就能更灵活地运用装饰器，为你的Python代码注入更多“魔力”和可维护性。

今天关于《Python装饰器原理与应用详解》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于Python,装饰器的内容请关注golang学习网公众号！

Python 装饰器