Python装饰器入门与实战：轻松理解并使用它

原创 2025-08-15 10:05:31编程技术

446

Python装饰器（Decorator）是函数式编程的重要特性，它允许在不修改原函数代码的情况下动态扩展函数功能。这种"不侵入式"的设计模式在日志记录、性能测试、权限校验等场景中广泛应用。理解装饰器的核心在于掌握函数对象特性、闭包机制以及语法糖的解包。本文ZHANID工具网将从基础概念入手，通过渐进式案例解析装饰器的实现原理与实战技巧。

一、装饰器基础：函数与闭包的深度解析

1. 函数是一等公民

Python中函数是一等对象，具备以下特性：

可作为参数传递
可作为返回值返回
可赋值给变量
可存储在数据结构中

# 示例：函数作为参数和返回值
def greet(name):
  return f"Hello, {name}!"

def execute(func, arg):
  return func(arg)

result = execute(greet, "Alice") # 输出: Hello, Alice!

2. 嵌套函数与闭包

当内部函数引用外部函数的变量时，会形成闭包（Closure）。闭包使得内部函数可以记住并访问其定义时的作用域，即使外部函数已执行完毕。

def outer(x):
  def inner(y):
    return x + y
  return inner # 返回内部函数对象

add5 = outer(5) # x=5被闭包记住
print(add5(3))  # 输出: 8 (5+3)

3. 装饰器的原始形态

装饰器本质上是高阶函数，它接收一个函数作为参数，返回一个增强后的新函数。这种模式被称为"函数包装"。

def my_decorator(func):
  def wrapper():
    print("Before function call")
    func() # 调用原函数
    print("After function call")
  return wrapper

def say_hello():
  print("Hello!")

decorated = my_decorator(say_hello)
decorated() # 输出装饰前后的日志

二、装饰器语法糖：@符号的解密

1. 语法糖的等价转换

Python通过@符号简化了装饰器的调用过程，以下两种写法完全等价：

# 传统写法
def target():
  pass
decorated = decorator(target)
decorated()

# 语法糖写法
@decorator
def target():
  pass
target()

2. 装饰器链式调用

多个装饰器会按照从下往上的顺序应用，但执行顺序是从上往下（洋葱模型）：

def decorator_a(func):
  def wrapper():
    print("A before")
    func()
    print("A after")
  return wrapper

def decorator_b(func):
  def wrapper():
    print("B before")
    func()
    print("B after")
  return wrapper

@decorator_a
@decorator_b
def target():
  print("Target")

target()
"""
输出顺序：
A before
B before
Target
B after
A after
"""

3. 带参数的装饰器实现

当需要为装饰器本身传递参数时，需要构建三层嵌套结构：

def repeat(num): # 最外层接收装饰器参数
  def decorator(func): # 中间层接收被装饰函数
    def wrapper(*args, **kwargs): # 最内层处理原函数调用
      for _ in range(num):
        result = func(*args, **kwargs)
      return result
    return wrapper
  return decorator

@repeat(3) # 装饰器参数
def greet(name):
  print(f"Hello, {name}!")

greet("Bob") # 会打印3次问候语

三、装饰器核心应用场景实战

1. 日志记录与审计

场景：自动记录函数调用信息（参数、返回值、执行时间）

import time
from functools import wraps

def log_performance(func):
  @wraps(func) # 保留原函数元信息
  def wrapper(*args, **kwargs):
    start = time.time()
    result = func(*args, **kwargs)
    duration = time.time() - start
    print(f"{func.__name__} executed in {duration:.4f}s")
    return result
  return wrapper

@log_performance
def fibonacci(n):
  if n <= 1:
    return n
  return fibonacci(n-1) + fibonacci(n-2)

fibonacci(30) # 自动打印执行时间

2. 权限验证系统

场景：检查用户是否有权限执行特定操作

def require_admin(func):
  @wraps(func)
  def wrapper(user, *args, **kwargs):
    if not user.get("is_admin"):
      raise PermissionError("Admin access required")
    return func(user, *args, **kwargs)
  return wrapper

class UserSystem:
  @require_admin
  def delete_user(self, user, target_id):
    print(f"Deleting user {target_id}")

admin = {"is_admin": True}
user = {"is_admin": False}

system = UserSystem()
system.delete_user(admin, 123) # 正常执行
system.delete_user(user, 123)  # 抛出PermissionError

3. 缓存机制实现

场景：对耗时函数结果进行缓存（Memoization模式）

def cache(func):
  cache_dict = {}
  @wraps(func)
  def wrapper(n):
    if n not in cache_dict:
      cache_dict[n] = func(n)
    return cache_dict[n]
  return wrapper

@cache
def factorial(n):
  if n == 0:
    return 1
  return n * factorial(n-1)

print(factorial(100)) # 首次计算
print(factorial(100)) # 直接从缓存读取

4. 参数校验与规范化

场景：自动验证函数参数类型和范围

def validate_input(**validations):
  def decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
      for param, checker in validations.items():
        value = kwargs.get(param)
        if not checker(value):
          raise ValueError(f"Invalid {param}: {value}")
      return func(*args, **kwargs)
    return wrapper
  return decorator

def is_positive(x):
  return x > 0

@validate_input(age=is_positive, name=lambda x: len(x) > 0)
def create_user(name, age):
  print(f"Creating user {name} aged {age}")

create_user(name="Alice", age=25) # 正常执行
create_user(name="", age=-5)   # 抛出ValueError

四、装饰器高级技巧与注意事项

1. 使用functools.wraps保留元信息

原始装饰器会丢失原函数的__name__、__doc__等属性，必须使用@wraps装饰器进行修复：

from functools import wraps

def bad_decorator(func):
  def wrapper():
    return func()
  return wrapper

def good_decorator(func):
  @wraps(func)
  def wrapper():
    return func()
  return wrapper

@bad_decorator
def example():
  """This is a test"""
  pass

print(example.__name__) # 输出: wrapper (错误)
print(example.__doc__)  # 输出: None (错误)

# 使用good_decorator会正确保留元信息

2. 类装饰器的实现

除了函数装饰器，还可以用类实现装饰器逻辑：

class CountCalls:
  def __init__(self, func):
    self.func = func
    self.num_calls = 0

  def __call__(self, *args, **kwargs):
    self.num_calls += 1
    print(f"Function called {self.num_calls} times")
    return self.func(*args, **kwargs)

@CountCalls
def say_world():
  print("World!")

say_world() # 计数1
say_world() # 计数2

3. 装饰器与异步函数

处理异步函数时，装饰器需要声明为async：

def async_timer(func):
  async def wrapper(*args, **kwargs):
    start = time.time()
    result = await func(*args, **kwargs)
    print(f"Execution time: {time.time()-start:.2f}s")
    return result
  return wrapper

@async_timer
async def fetch_data():
  await asyncio.sleep(1)
  return "Data"

asyncio.run(fetch_data()) # 自动打印执行时间

4. 常见陷阱与解决方案

陷阱1：装饰器中的循环引用导致内存泄漏

解决：使用weakref模块创建弱引用

陷阱2：装饰器顺序影响功能

解决：明确装饰器应用顺序（如先权限校验后日志记录）

陷阱3：装饰器修改函数签名导致类型检查失败

解决：使用typing.Callable进行类型注解

五、完整实战案例：Web框架路由系统

以下是一个简化版Flask风格的路由装饰器实现：

from functools import wraps

class SimpleFramework:
  def __init__(self):
    self.routes = {}

  def route(self, path):
    def decorator(func):
      @wraps(func)
      def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
      self.routes[path] = wrapper
      return wrapper
    return decorator

  def handle_request(self, path):
    handler = self.routes.get(path)
    if handler:
      return handler()
    return "404 Not Found"

app = SimpleFramework()

@app.route("/")
def home():
  return "Welcome Home!"

@app.route("/about")
def about():
  return "About Us"

# 模拟请求处理
print(app.handle_request("/"))   # 输出: Welcome Home!
print(app.handle_request("/about")) # 输出: About Us
print(app.handle_request("/404"))  # 输出: 404 Not Found