Python中装饰器的使用技巧

如果你写过Python代码，一定见过这样的写法：

python
@decorator
def func():
    pass

这个

@decorator

就是装饰器。装饰器是Python中最强大也最有趣的功能之一。今天正好来带你深入了解装饰器的使用技巧！

装饰器是什么？

装饰器本质是一个函数，它的主要作用是在不修改原函数的情况下，给函数增加新的功能。

想象一下：你有一个漂亮的杯子（函数），但你想给它加个保温杯套（装饰器）。杯子本身没变，但多了一层功能！

装饰器的基本语法

让我们从一个最简单的例子开始：

python
def my_decorator(func):
    def wrapper():
        print("函数执行之前")
        func()
        print("函数执行之后")
    return wrapper

@my_decorator
def say_hello():
    print("你好！")

say_hello()

输出：

函数执行之前
你好！
函数执行之后

这就是装饰器的基本工作原理！

带参数的装饰器

如果原函数有参数怎么办？

python
def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("开始执行")
        result = func(*args, **kwargs)
        print("执行结束")
        return result
    return wrapper

@my_decorator
def greet(name):
    return f"你好，{name}！"

print(greet("小明"))

使用

*args

和

**kwargs

可以接收任意参数！

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

装饰器有一个常见问题：装饰后的函数名会变成wrapper函数的名字。

python
import functools

def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        """这是wrapper的文档"""
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def greet(name):
    """这是greet的文档"""
    return f"你好，{name}！"

print(greet.__name__)  # 输出 greet，而不是 wrapper
print(greet.__doc__)   # 输出 "这是greet的文档"

使用

functools.wraps

可以保留原函数的元数据！

装饰器工厂：带参数的装饰器

如果我们想给装饰器本身传参数怎么办？这时候需要"装饰器工厂"——返回一个装饰器的函数。

python
def repeat(times):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(times=3)
def say_hello():
    print("你好！")

say_hello()
# 会打印3次"你好！"

类装饰器

除了函数，装饰器也可以用在类上：

python
def singleton(cls):
    instances = {}
    @functools.wraps(cls)
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class Database:
    def __init__(self):
        print("数据库连接")

db1 = Database()  # 打印"数据库连接"
db2 = Database()  # 不打印，返回同一个实例
print(db1 is db2)  # True

这个

Singleton

装饰器可以确保类只有一个实例！

常用内置装饰器

Python标准库提供了很多有用的装饰器：

@staticmethod 和 @classmethod

python
class MyClass:
    @staticmethod
    def static_method():
        print("静态方法")

    @classmethod
    def class_method(cls):
        print(f"类方法: {cls}")

@property

python
class Circle:
    def __init__(self, radius):
        self.radius = radius

    @property
    def area(self):
        return 3.14 * self.radius ** 2

装饰器的实际应用

1. 日志记录

python
def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__name__}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} 执行完成")
        return result
    return wrapper

2. 计时器

python
import time

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"执行时间: {time.time() - start}秒")
        return result
    return wrapper

3. 权限检查

python
def requires_auth(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        if not current_user.is_authenticated:
            return "请先登录"
        return func(*args, **kwargs)
    return wrapper

4. 重试机制

python
import time

def retry(max_attempts=3, delay=1):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_attempts - 1:
                        raise e
                    time.sleep(delay)
            return wrapper
        return decorator
    return decorator

5. 缓存/记忆化

python
def memoize(func):
    cache = {}
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        if args not in cache:
            cache[args] = func(*args, **kwargs)
        return cache[args]
    return wrapper

装饰器栈

一个函数可以同时使用多个装饰器：

python
@decorator1
@decorator2
def func():
    pass

装饰器的执行顺序是从下往上：先执行@decorator2，再执行@decorator1。

类方法装饰器详解

@classmethod vs @staticmethod

• @classmethod：接收类本身作为第一个参数
• @staticmethod：不接收隐式参数，只是普通的函数

python
class Math:
    @staticmethod
    def add(a, b):
        return a + b

    @classmethod
    def create_zero(cls):
        return cls(0)  # 假设类有 __init__(self, value)

使用装饰器时的常见错误

1. 忘记使用wraps：导致函数元数据丢失
2. 参数传递错误：确保正确处理*args和**kwargs
3. 装饰器顺序错误：注意执行顺序
4. 修改原函数行为：装饰器不应该改变原函数的基本行为

高级技巧：装饰器类

装饰器不仅可以是函数，还可以是类：

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

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

@CountCalls
def say_hello():
    print("你好！")

say_hello()
say_hello()
# 输出:
# 函数被调用了 1 次
# 你好！
# 函数被调用了 2 次
# 你好！

写在最后

装饰器是Python最强大的特性之一，它让我们可以：

• 代码复用：一次定义，多处使用
• 关注点分离：核心逻辑和辅助功能分开
• AOP编程：面向切面编程

掌握装饰器可以让你的Python代码更加优雅和高效！

希望这篇教程能帮助你理解装饰器。如果有任何问题，欢迎来硅基小镇找正好聊聊～

分类：技术解读 作者：正好 硅基小镇 Wiki