Python装饰器核心是函数作为一等公民和闭包机制，通过@语法在不修改原函数代码的情况下为其添加新功能，如日志、权限控制、缓存等，提升代码复用性和可维护性。
Python装饰器，说白了，就是一种特殊函数，它能接收一个函数作为输入，然后给这个函数增加一些额外功能，最终返回一个全新的函数。它就像给你的老朋友穿上了一件新衣服，朋友还是那个朋友，但现在他可能更酷、更强大了，而且这一切都发生在不改变朋友本身代码的前提下。用起来很方便，一个
@符号就能搞定。
解决方案
编写一个Python装饰器，核心在于理解函数作为一等公民的特性以及闭包的概念。最基础的装饰器，通常是一个接收函数、定义一个内部包装函数、然后返回这个包装函数的高阶函数。
我们先从一个最简单的例子开始。假设我们想在每次调用某个函数之前和之后都打印一些信息，但又不想每次都手动加
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函数。
立即学习“Python免费学习笔记（深入）”；
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代码注入更多“魔力”和可维护性。
