python的装饰器如何使用

Python的装饰器如何使用

Python的装饰器用于修改函数或方法的行为、可以实现代码复用、增强函数功能、简化代码结构。其中，最常见的用法是为一个函数添加日志功能、访问控制、缓存等。装饰器在实际开发中非常有用，因为它们允许我们在不改变原始函数代码的情况下，添加额外的功能。

一、什么是装饰器

装饰器本质上是一个返回函数的高阶函数。它接受一个函数作为参数，并返回一个增强后的函数。装饰器通常用于横切关注点（cross-cutting concerns），例如日志记录、权限检查、事务管理等。在Python中，装饰器通过使用@符号进行应用。

1.1 简单示例

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

在这个示例中，my_decorator是一个装饰器，它增强了say_hello函数的功能，使其在调用前后打印一些额外的信息。

二、装饰器的应用场景

2.1 日志记录

通过装饰器，我们可以很方便地为函数添加日志记录功能，而不需要修改函数本身的代码。

def log_decorator(func):
    def wrapper(*args, kwargs):
        print(f"Calling function: {func.__name__}")
        result = func(*args, kwargs)
        print(f"Function {func.__name__} returned {result}")
        return result
    return wrapper
@log_decorator
def add(a, b):
    return a + b
add(3, 5)

2.2 权限检查

在一些安全性要求较高的应用中，权限检查是必不可少的，通过装饰器可以很方便地实现这一功能。

def requires_permission(permission):
    def decorator(func):
        def wrapper(*args, kwargs):
            if not user_has_permission(permission):
                raise PermissionError(f"User does not have {permission} permission")
            return func(*args, kwargs)
        return wrapper
    return decorator
@requires_permission('admin')
def delete_user(user_id):
    print(f"User {user_id} deleted")
def user_has_permission(permission):
    # 假设当前用户的权限
    current_user_permissions = ['admin']
    return permission in current_user_permissions
delete_user(123)

三、多个装饰器的使用

在Python中，一个函数可以被多个装饰器装饰。多个装饰器的执行顺序是自上而下，但实际调用函数时，装饰器是自下而上执行的。

def decorator1(func):
    def wrapper(*args, kwargs):
        print("Decorator 1")
        return func(*args, kwargs)
    return wrapper
def decorator2(func):
    def wrapper(*args, kwargs):
        print("Decorator 2")
        return func(*args, kwargs)
    return wrapper
@decorator1
@decorator2
def say_hello():
    print("Hello!")
say_hello()

在这个示例中，say_hello函数首先被decorator2装饰，然后再被decorator1装饰。因此，当我们调用say_hello时，输出将是：

Decorator 1 Decorator 2 Hello!

四、带参数的装饰器

有时候，我们希望装饰器能够接受参数，这可以通过再嵌套一层函数来实现。

def repeat(n):
    def decorator(func):
        def wrapper(*args, kwargs):
            for _ in range(n):
                func(*args, kwargs)
        return wrapper
    return decorator
@repeat(3)
def say_hello():
    print("Hello!")
say_hello()

在这个示例中，repeat是一个带参数的装饰器，它接受一个整数参数n，并使say_hello函数被调用n次。

五、类装饰器

除了函数装饰器，Python还支持类装饰器。类装饰器的实现方式与函数装饰器类似，只不过它们是用来装饰类的。

def singleton(cls):
    instances = {}
    def get_instance(*args, kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, kwargs)
        return instances[cls]
    return get_instance
@singleton
class MyClass:
    def __init__(self, value):
        self.value = value
a = MyClass(10)
b = MyClass(20)
print(a.value)  # 输出: 10
print(b.value)  # 输出: 10
print(a is b)   # 输出: True

在这个示例中，singleton装饰器保证了MyClass类只有一个实例。

六、标准库中的装饰器

Python标准库中提供了一些常用的装饰器，例如functools.wraps、staticmethod、classmethod等。

6.1 functools.wraps

functools.wraps是一个装饰器，用于将原函数的元数据（如函数名、文档字符串等）复制到装饰器中的包装函数。这样可以保持原函数的元数据不丢失。

from functools import wraps
def log_decorator(func):
    @wraps(func)
    def wrapper(*args, kwargs):
        print(f"Calling function: {func.__name__}")
        result = func(*args, kwargs)
        print(f"Function {func.__name__} returned {result}")
        return result
    return wrapper
@log_decorator
def add(a, b):
    """This function adds two numbers"""
    return a + b
print(add.__name__)  # 输出: add
print(add.__doc__)   # 输出: This function adds two numbers

6.2 staticmethod 和 classmethod

staticmethod和classmethod是Python内置的装饰器，用于定义静态方法和类方法。

class MyClass:
    @staticmethod
    def static_method():
        print("This is a static method")
    @classmethod
    def class_method(cls):
        print(f"This is a class method of {cls}")
MyClass.static_method()
MyClass.class_method()

staticmethod定义的方法不需要传递实例或类参数，而classmethod定义的方法需要传递类参数。

七、装饰器的实际应用

7.1 缓存

装饰器可以用于缓存函数的计算结果，以提高性能。Python标准库提供了functools.lru_cache装饰器来实现这个功能。

from functools import lru_cache
@lru_cache(maxsize=32)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(10))

7.2 计时

装饰器可以用于计算函数的执行时间，这在性能调优中非常有用。

import time
def timer(func):
    @wraps(func)
    def wrapper(*args, kwargs):
        start_time = time.time()
        result = func(*args, kwargs)
        end_time = time.time()
        print(f"Function {func.__name__} took {end_time - start_time} seconds")
        return result
    return wrapper
@timer
def long_running_function():
    time.sleep(2)
long_running_function()

通过这些示例，可以看出装饰器在Python编程中的强大作用。它们不仅能简化代码，还能增强代码的可读性和可维护性。在实际开发中，合理地使用装饰器可以大大提高代码的质量和效率。