Python装饰器怎么正确使用

引言

在Python编程中，装饰器（Decorator）是一种强大的工具，它允许我们在不修改原有函数或类代码的情况下，动态地添加功能。装饰器的使用场景非常广泛，比如日志记录、性能测试、权限校验、缓存等。本文将详细介绍Python装饰器的概念、使用方法以及一些高级技巧，帮助你正确理解和使用装饰器。

1. 什么是装饰器

装饰器本质上是一个函数，它接受一个函数作为参数，并返回一个新的函数。装饰器的作用是在不改变原函数代码的情况下，给函数添加额外的功能。

1.1 装饰器的基本语法

在Python中，装饰器的基本语法如下：

@decorator
def function():
    pass

这里的@decorator就是装饰器，它等价于：

def function():
    pass
function = decorator(function)

1.2 装饰器的简单示例

让我们通过一个简单的例子来理解装饰器的基本用法：

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()

输出结果：

Something is happening before the function is called.
Hello!
Something is happening after the function is called.

在这个例子中，my_decorator是一个装饰器，它接受一个函数func作为参数，并返回一个新的函数wrapper。当我们调用say_hello()时，实际上调用的是wrapper函数，它在调用func之前和之后分别打印了一些信息。

2. 装饰器的常见用法

2.1 日志记录

装饰器常用于记录函数的调用日志。例如，我们可以编写一个装饰器来记录函数的执行时间：

import time

def log_execution_time(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} executed in {end_time - start_time:.4f} seconds")
        return result
    return wrapper

@log_execution_time
def slow_function():
    time.sleep(2)

slow_function()

输出结果：

slow_function executed in 2.0021 seconds

2.2 权限校验

装饰器还可以用于权限校验。例如，我们可以编写一个装饰器来检查用户是否有权限执行某个函数：

def check_permission(func):
    def wrapper(*args, **kwargs):
        user = kwargs.get('user')
        if user and user == 'admin':
            return func(*args, **kwargs)
        else:
            raise PermissionError("You do not have permission to perform this action.")
    return wrapper

@check_permission
def delete_file(user):
    print("File deleted.")

delete_file(user='admin')  # 正常执行
delete_file(user='guest')  # 抛出异常

2.3 缓存

装饰器还可以用于实现缓存功能。例如，我们可以编写一个装饰器来缓存函数的计算结果：

def cache_result(func):
    cache = {}
    def wrapper(*args):
        if args in cache:
            return cache[args]
        result = func(*args)
        cache[args] = result
        return result
    return wrapper

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

print(fibonacci(10))  # 第一次计算，结果被缓存
print(fibonacci(10))  # 直接从缓存中获取结果

3. 带参数的装饰器

有时候我们需要装饰器本身接受一些参数，这时我们可以使用带参数的装饰器。带参数的装饰器实际上是一个返回装饰器的函数。

3.1 带参数的装饰器示例

def repeat(num_times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

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

greet("Alice")

输出结果：

Hello, Alice!
Hello, Alice!
Hello, Alice!

在这个例子中，repeat是一个带参数的装饰器，它接受一个参数num_times，并返回一个装饰器decorator。decorator再接受一个函数func，并返回一个新的函数wrapper。wrapper函数会调用func多次。

4. 类装饰器

除了函数装饰器，Python还支持类装饰器。类装饰器是一个类，它接受一个函数作为参数，并返回一个新的函数或对象。

4.1 类装饰器示例

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

    def __call__(self, *args, **kwargs):
        self.num_calls += 1
        print(f"Call {self.num_calls} of {self.func.__name__}")
        return self.func(*args, **kwargs)

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

say_hello()
say_hello()

输出结果：

Call 1 of say_hello
Hello!
Call 2 of say_hello
Hello!

在这个例子中，CountCalls是一个类装饰器，它接受一个函数func作为参数，并在__call__方法中实现了装饰器的功能。每次调用say_hello时，__call__方法都会被调用，从而记录函数的调用次数。

5. 装饰器的堆叠

在Python中，我们可以将多个装饰器堆叠在一起，从而给函数添加多个功能。装饰器的堆叠顺序是从下往上。

5.1 装饰器堆叠示例

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

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

@decorator1
@decorator2
def say_hello():
    print("Hello!")

say_hello()

输出结果：

Decorator 1
Decorator 2
Hello!

在这个例子中，say_hello函数被decorator1和decorator2两个装饰器修饰。调用say_hello时，首先执行decorator1的wrapper函数，然后执行decorator2的wrapper函数，最后执行say_hello函数本身。

6. 装饰器的注意事项

6.1 保留原函数的元信息

在使用装饰器时，原函数的元信息（如__name__、__doc__等）会被覆盖。为了保留这些元信息，我们可以使用functools.wraps装饰器。

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("Something is happening before the function is called.")
        result = func(*args, **kwargs)
        print("Something is happening after the function is called.")
        return result
    return wrapper

@my_decorator
def say_hello():
    """This is a docstring."""
    print("Hello!")

print(say_hello.__name__)  # 输出: say_hello
print(say_hello.__doc__)   # 输出: This is a docstring.

6.2 装饰器的性能影响

装饰器虽然方便，但也会带来一定的性能开销。每次调用被装饰的函数时，都会额外执行装饰器中的代码。因此，在性能敏感的场景中，需要谨慎使用装饰器。

7. 总结

装饰器是Python中非常强大的工具，它允许我们在不修改原函数代码的情况下，动态地添加功能。通过本文的介绍，你应该已经掌握了装饰器的基本用法、常见场景以及一些高级技巧。在实际开发中，合理使用装饰器可以大大提高代码的可读性和可维护性。

希望本文对你理解和使用Python装饰器有所帮助！