如何使用python装饰器

使用Python装饰器的步骤是：定义装饰器函数、将装饰器应用到目标函数、处理传递的参数和返回值。 其中，定义装饰器函数是最关键的一步。装饰器本质上是一个函数，它接受另一个函数作为参数，并返回一个新的函数。通过这种方式，可以在不改变目标函数代码的情况下，扩展其功能。下面将详细介绍如何使用Python装饰器。

一、定义装饰器函数

定义一个装饰器函数需要理解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是一个装饰器，它接受一个函数func作为参数，并返回一个新的函数wrapper。wrapper函数在调用func之前和之后分别打印一些信息，从而扩展了func的功能。

二、将装饰器应用到目标函数

将装饰器应用到目标函数有两种方法：一种是使用装饰器语法糖@，另一种是手动调用装饰器函数。

使用装饰器语法糖

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

在这个例子中，@my_decorator语法糖将my_decorator应用到say_hello函数，相当于执行了say_hello = my_decorator(say_hello)。因此，调用say_hello时，实际上执行的是wrapper函数。

手动调用装饰器函数

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

这种方式与使用装饰器语法糖的效果相同，但显得更为直观。

三、处理传递的参数和返回值

为了使装饰器更通用，需要处理传递给目标函数的参数和返回值。可以使用*args和kwargs来接受任意数量和类型的参数。

def my_decorator(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

在这个例子中，wrapper函数接受任意数量和类型的参数，并将它们传递给func。同时，wrapper函数也返回func的返回值，从而保证装饰器不会改变目标函数的行为。

四、使用多个装饰器

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!"。

五、装饰器在实际中的应用

日志记录

装饰器可以用于记录函数的调用日志，包括函数名称、参数和返回值等信息。

import functools
def log(func):
    @functools.wraps(func)
    def wrapper(*args, kwargs):
        print(f"Calling {func.__name__} with args {args} and kwargs {kwargs}")
        result = func(*args, kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper
@log
def add(a, b):
    return a + b
add(2, 3)

访问控制

装饰器可以用于实现访问控制，例如检查用户是否有权限执行某个操作。

def requires_permission(permission):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, kwargs):
            if not has_permission(permission):
                raise PermissionError(f"User does not have {permission} permission")
            return func(*args, kwargs)
        return wrapper
    return decorator
def has_permission(permission):
    # 假设有一个函数检查权限
    return True
@requires_permission("admin")
def delete_user(user_id):
    print(f"Deleting user {user_id}")
delete_user(123)

缓存

装饰器可以用于缓存函数的返回结果，以提高性能。

def cache(func):
    cached_results = {}
    @functools.wraps(func)
    def wrapper(*args):
        if args in cached_results:
            return cached_results[args]
        result = func(*args)
        cached_results[args] = result
        return result
    return wrapper
@cache
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(10))

六、类装饰器

除了函数装饰器，Python还支持类装饰器。类装饰器是通过实现__call__方法，使类实例成为可调用对象。

class MyDecorator:
    def __init__(self, func):
        self.func = func
    def __call__(self, *args, kwargs):
        print("Something is happening before the function is called.")
        result = self.func(*args, kwargs)
        print("Something is happening after the function is called.")
        return result
@MyDecorator
def say_hello():
    print("Hello!")
say_hello()

在这个例子中，MyDecorator类实现了__call__方法，使其实例成为可调用对象，从而可以作为装饰器使用。

七、装饰器与类方法

装饰器也可以用于类方法。需要注意的是，类方法的第一个参数是self，因此在定义装饰器时需要处理这个参数。

def log_method(func):
    @functools.wraps(func)
    def wrapper(self, *args, kwargs):
        print(f"Calling {func.__name__} with args {args} and kwargs {kwargs}")
        result = func(self, *args, kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper
class MyClass:
    @log_method
    def add(self, a, b):
        return a + b
my_instance = MyClass()
my_instance.add(2, 3)

在这个例子中，log_method装饰器用于记录类方法的调用日志。

八、装饰器与静态方法、类方法

装饰器也可以用于静态方法和类方法。静态方法通过@staticmethod装饰，类方法通过@classmethod装饰。

def log_static_method(func):
    @functools.wraps(func)
    def wrapper(*args, kwargs):
        print(f"Calling {func.__name__} with args {args} and kwargs {kwargs}")
        result = func(*args, kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper
class MyClass:
    @log_static_method
    @staticmethod
    def add(a, b):
        return a + b
    @classmethod
    def create_instance(cls):
        return cls()
MyClass.add(2, 3)
MyClass.create_instance()

在这个例子中，log_static_method装饰器用于记录静态方法的调用日志。

九、装饰器与参数化装饰器

参数化装饰器是指可以接受参数的装饰器。参数化装饰器需要定义一个返回装饰器函数的函数。

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