Python函数：装饰器的概念和实现方式

Python中，装饰器是一种功能强大的语法结构，它可以对函数进行声明式的扩展和修改。装饰器可以在不改变函数原有结构的情况下，为函数添加新的功能，比如记录日志，缓存结果，检查权限等。装饰器还可以用来修改函数参数和返回值，甚至可以将多个装饰器组合在一起使用。

装饰器的实现方式有两种：函数装饰器和类装饰器。在Python中，函数和类都是一等公民，因此可以将它们作为参数传递到其他函数或类中。

函数装饰器

函数装饰器是最常见的装饰器类型。它是一个函数，接收一个函数作为参数，返回一个新的函数作为替换原有函数使用。函数装饰器的定义方式为：

def decorator(func):
    def wrapper(*args, **kwargs):
        # do something before
        result = func(*args, **kwargs)
        # do something after
        return result
    return wrapper

这里定义了一个装饰器函数decorator，它接收一个函数func作为参数，返回一个新的函数wrapper。wrapper函数调用原有函数func，并在调用前后执行一些操作。装饰器的使用方式为：

@decorator
def my_function():
    pass

这样，my_function就会在调用时先执行decorator函数，然后再执行my_function本身。

类装饰器

类装饰器是一种更高级的装饰器类型。它是一个类，实现了__call__方法，接收一个函数作为参数，返回一个新的函数作为替换原有函数使用。类装饰器的定义方式为：

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

    def __call__(self, *args, **kwargs):
        # do something before
        result = self.func(*args, **kwargs)
        # do something after
        return result

这里定义了一个类装饰器Decorator，它接收一个函数func作为参数，并实现了__call__方法。__call__方法与函数装饰器中的wrapper函数相似，调用原有函数func，并在调用前后执行一些操作。装饰器的使用方式为：

@Decorator
def my_function():
    pass

这样，my_function就会在调用时先执行Decorator类的__call__方法，然后再执行my_function本身。

装饰器的应用场景

装饰器在实际应用中非常有用，它可以帮助我们更加方便地实现一些通用的功能。以下是一些常见的装饰器应用场景：

1. 记录日志

我们可以定义一个记录日志的装饰器，用来记录函数的调用时间、参数和返回值等信息，以便后续分析和调试。

import logging
import time

def log(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        delta_time = end_time - start_time
        logging.info(f"function {func.__name__} finished in {delta_time:.10f} seconds")
        return result
    return wrapper

@log
def my_function(x):
    return x * 2

2. 缓存结果

我们可以定义一个缓存结果的装饰器，用来缓存函数的计算结果，以避免重复计算。

def cache(func):
    cached_results = {}

    def wrapper(*args, **kwargs):
        key = (args, tuple(kwargs.items()))
        if key not in cached_results:
            cached_results[key] = func(*args, **kwargs)
        return cached_results[key]

    return wrapper

@cache
def my_function(x, y):
    # do some heavy computation
    pass

3. 检查权限

我们可以定义一个检查权限的装饰器，用来检查用户是否有调用函数的权限。

def check_permission(perm):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if user_has_permission(perm):
                return func(*args, **kwargs)
            else:
                raise PermissionError("permission denied")
        return wrapper
    return decorator

@check_permission("admin")
def my_function():
    # do something only admin can do
    pass

4. 计算函数执行时间

我们可以定义一个计算函数执行时间的装饰器，用来统计函数的执行时间。

import time

def timeit(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"function {func.__name__} finished in {end_time - start_time:.10f} seconds")
        return result
    return wrapper

@timeit
def my_function():
    # do something
    pass

5. 处理异常

我们可以定义一个处理异常的装饰器，用来捕获函数抛出的异常并处理。

def handle_exception(func):
    def wrapper(*args, **kwargs):
        try:
            result = func(*args, **kwargs)
        except Exception as e:
            # handle the exception
            result = None
        return result
    return wrapper

@handle_exception
def my_function():
    # do something that may throw an exception
    pass

总结

装饰器是一种强大而灵活的工具，它可以帮助我们简化代码、提高代码复用性，同时也为我们提供了很多优雅的解决方案。在实际应用中，我们可以根据不同的需求定义不同的装饰器，以实现更加高效、健壮和可维护的代码。