12步轻松搞定python装饰器！

《12步轻松搞定Python装饰器！》

Python装饰器（Decorator）是编程中极具魅力的特性之一，它允许在不修改原函数代码的前提下，动态地为其添加功能。这种"开箱即用"的设计模式，不仅提升了代码的可复用性，还让函数逻辑与附加功能（如日志记录、权限校验、缓存等）解耦。本文将通过12个循序渐进的步骤，结合大量实例，彻底攻克装饰器的理解与应用难题。

一、为什么需要装饰器？

在正式学习装饰器前，我们需要理解其存在的必要性。假设有多个函数需要记录执行时间：

def func1():
    print("Function 1 executed")

def func2():
    print("Function 2 executed")

# 传统方式：为每个函数重复编写计时逻辑
import time
start = time.time()
func1()
print(f"Time elapsed: {time.time()-start:.2f}s")

start = time.time()
func2()
print(f"Time elapsed: {time.time()-start:.2f}s")

这种写法存在明显缺陷：计时逻辑与业务逻辑耦合，且当需要新增函数时需重复编写相同代码。装饰器的出现完美解决了这一问题。

二、装饰器基础：函数作为参数

装饰器的核心思想是将函数作为参数传递。首先看一个简单示例：

def greet(name):
    return f"Hello, {name}!"

def call_func(func, arg):
    print("Before calling function")
    result = func(arg)
    print("After calling function")
    return result

print(call_func(greet, "Alice"))

输出结果：

Before calling function
After calling function
Hello, Alice!

这个例子展示了如何通过包装函数（call_func）在调用目标函数（greet）前后插入额外逻辑。

三、装饰器语法糖

Python提供了更优雅的装饰器语法，使用@符号：

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

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

say_hello()

等价于：

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

say_hello = my_decorator(say_hello)

四、处理带参数的函数

当被装饰函数有参数时，需要修改wrapper函数：

def decorator_with_args(func):
    def wrapper(*args, **kwargs):
        print("Before function call")
        result = func(*args, **kwargs)
        print("After function call")
        return result
    return wrapper

@decorator_with_args
def greet(name, message="Hello"):
    print(f"{message}, {name}!")

greet("Bob", "Hi")

五、保持原函数元信息

使用装饰器后，原函数的__name__等属性会被wrapper覆盖。使用functools.wraps修复：

from functools import wraps

def preserve_meta(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        """Wrapper docstring"""
        return func(*args, **kwargs)
    return wrapper

@preserve_meta
def example():
    """Original docstring"""
    pass

print(example.__name__)  # 输出: example
print(example.__doc__)   # 输出: Original docstring

六、类装饰器实现

装饰器不仅可以用函数实现，还可以用类：

class ClassDecorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print("Class decorator before")
        result = self.func(*args, **kwargs)
        print("Class decorator after")
        return result

@ClassDecorator
def multiply(a, b):
    return a * b

print(multiply(3, 4))

七、装饰器链式调用

多个装饰器按从下到上的顺序应用：

def decorator1(func):
    def wrapper():
        print("Decorator 1 before")
        func()
        print("Decorator 1 after")
    return wrapper

def decorator2(func):
    def wrapper():
        print("Decorator 2 before")
        func()
        print("Decorator 2 after")
    return wrapper

@decorator1
@decorator2
def say_world():
    print("World!")

say_world()

输出顺序：

Decorator 1 before
Decorator 2 before
World!
Decorator 2 after
Decorator 1 after

八、带参数的装饰器

要创建带参数的装饰器，需要三层嵌套：

def repeat(num_times):
    def decorator_repeat(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                value = func(*args, **kwargs)
            return value
        return wrapper
    return decorator_repeat

@repeat(num_times=3)
def greet(name):
    print(f"Hello {name}")

greet("Charlie")

九、实际应用：日志记录

使用装饰器自动记录函数调用信息：

import logging
from datetime import datetime

def log_activity(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        logging.basicConfig(filename=f"{func.__name__}.log", level=logging.INFO)
        logging.info(f"Called {func.__name__} at {datetime.now()} with args: {args}, kwargs: {kwargs}")
        return func(*args, **kwargs)
    return wrapper

@log_activity
def calculate(x, y):
    return x + y

calculate(5, 3)

十、实际应用：权限校验

实现简单的权限控制装饰器：

def require_auth(role):
    def decorator(func):
        @wraps(func)
        def wrapper(user, *args, **kwargs):
            if user.get("role") != role:
                raise PermissionError(f"Requires {role} role")
            return func(user, *args, **kwargs)
        return wrapper
    return decorator

users = [{"name": "Alice", "role": "admin"}, {"name": "Bob", "role": "user"}]

@require_auth("admin")
def delete_data(user):
    print(f"{user['name']} deleted data")

delete_data(users[0])  # 正常执行
# delete_data(users[1])  # 抛出PermissionError

十一、实际应用：缓存机制

实现函数结果缓存装饰器：

def cache_results(func):
    cache = {}
    @wraps(func)
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper

@cache_results
def fibonacci(n):
    if n 

十二、装饰器最佳实践

1. 保持装饰器简单专注，每个装饰器只做一件事

2. 使用functools.wraps保留原函数元信息

3. 为装饰器编写清晰的文档字符串

4. 考虑装饰器的执行顺序影响

5. 对于复杂逻辑，优先使用类装饰器

6. 避免过度使用装饰器导致代码难以调试

常见问题解答

Q1: 装饰器和普通函数的区别？
A: 装饰器本质上是一个返回函数的高阶函数，通过特殊语法糖简化调用。

Q2: 多个装饰器执行顺序？
A: 从下到上应用，从内到外执行。@d1 @d2 func 等价于 d1(d2(func))。

Q3: 装饰器能否修改返回值？
A: 可以，wrapper函数中处理返回值即可：

def modify_return(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        original = func(*args, **kwargs)
        return f"Modified: {original}"
    return wrapper

总结

通过12个步骤的学习，我们掌握了：

1. 装饰器的基本语法和工作原理

2. 处理带参数和返回值的函数

3. 类装饰器的实现方式

4. 装饰器链式调用和参数传递

5. 三个典型应用场景（日志、权限、缓存）

装饰器是Python中"Pythonic"编程的典范，合理使用能显著提升代码质量。建议从简单场景开始实践，逐步掌握高级用法。

关键词：Python装饰器、高阶函数、functools.wraps、闭包、元编程、日志记录、权限校验、缓存机制、链式调用、类装饰器

简介：本文通过12个循序渐进的步骤，系统讲解Python装饰器的核心概念与实现技巧。从基础语法到高级应用，涵盖函数装饰器、类装饰器、带参数装饰器等核心知识点，结合日志记录、权限校验、缓存机制等实际案例，帮助读者彻底掌握装饰器的设计与使用。