Python 函数的装饰器使用方法

Python 的函数装饰器是 Python 语言的一项强大特性，它允许开发者动态地修改现有函数的行为。你可以通过函数装饰器扩展函数的功能，比如性能追踪、日志记录、输入验证等等。在本文中，我们将了解 Python 函数装饰器的用法。

## 基础概念

在 Python 中，函数是一等对象，它们可以被赋值给变量、作为函数参数传递以及作为函数的返回值。函数装饰器是 Python 中用来装饰函数的函数，它可以改变或者扩展原来的函数的行为。Python 函数装饰器具有以下特点：

1. 是一个函数

2. 接收一个函数作为参数

3. 返回一个新的函数

4. 新函数的行为可以在不修改原函数的情况下被修改或扩展

## 语法

函数装饰器是一个函数，它接收被装饰的函数作为参数，并返回一个新的函数来代替原来的函数。通常情况下，函数装饰器是通过 @ 符号来使用的：

@decorator
def func():
    pass

等价于

def func():
    pass

func = decorator(func)

## 装饰器的实现

下面是一个最简单的装饰器实现：

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


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

# 装饰器的使用
say_hello = my_decorator(say_hello)

# 调用被装饰的函数
say_hello()

上面的代码运行结果为：

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

在这个例子中，我们定义了一个装饰器 my_decorator，它接收一个函数作为参数，返回一个新的函数 wrapper。在 wrapper 函数中，我们首先打印一条消息，然后调用传入的 func 函数，最后再打印一条消息。在被装饰函数 say_hello 被调用时，其实调用的是由 my_decorator 返回的 wrapper 函数，因此会先打印两条消息，再执行 say_hello 函数。

为了方便起见，Python 提供了 @ 符号来应用装饰器。将上面的代码改写为使用 @ 符号的语法：

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

# 调用被装饰的函数
say_hello()

与之前的写法相比，这个语法更加简洁明了。我们只需要在函数定义前加上 @my_decorator，就可以使函数被装饰器 my_decorator 装饰。

## 带参数的装饰器

函数装饰器可以带参数。在这种情况下，装饰器实际上是一个返回装饰器函数的函数。示例如下：

def logger(log_file):
    def decorator(func):
        def wrapper(*args, **kwargs):
            with open(log_file, 'a') as f:
                f.write(f'function {func.__name__} called with args {args}, {kwargs}
')
            result = func(*args, **kwargs)
            with open(log_file, 'a') as f:
                f.write(f'function {func.__name__} returned {result}
')
            return result
        return wrapper
    return decorator


@logger('log.txt')
def add(a, b):
    return a + b

# 调用被装饰的函数
print(add(1, 2))

在这个简单的示例中，我们定义了一个装饰器 logger，它接收一个参数 log_file。它返回一个函数 decorator，这个函数接收一个函数作为参数，并返回一个新函数 wrapper，这个新函数可以记录被装饰函数的调用情况和返回结果。在 wrapper 函数中，我们首先打开一个文件，将函数名和参数写入文件中，然后调用原函数，并将结果保存下来，最后将结果写入文件中，并返回结果。通过这样的方式，我们就可以方便地对任意函数进行日志记录了。

## 多个装饰器的使用

在 Python 中，我们可以使用多个装饰器来装饰一个函数，它们的执行顺序与装饰器定义的顺序相反。例如：

def debug(func):
    def wrapper(*args, **kwargs):
        print(f'DEBUG: {func.__name__}({args!r}, {kwargs!r})')
        return func(*args, **kwargs)
    return wrapper

def trace(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        print(f'TRACE: {func.__name__}({args!r}, {kwargs!r}) = {result!r}')
        return result
    return wrapper

@trace
@debug
def add(a, b):
    return a + b

result = add(3, 4)

在这个例子中，我们定义了两个装饰器 debug 和 trace，它们都接收一个函数作为参数，并返回一个新函数。我们使用 @trace 和 @debug 装饰 add 函数。因此，add 函数实际上被等价于 trace(debug(add)) 装饰，也就是说，函数会被先调用 debug，然后再调用 trace。在这个例子中，调用 add(3, 4) 的结果为：

DEBUG: add((3,), {'b': 4})
TRACE: add((3,), {'b': 4}) = 7

## 类装饰器

除了函数装饰器，Python 还支持类装饰器，它们的实现方式类似于函数装饰器。类装饰器接收一个类作为参数，并可以修改或扩展这个类的行为。示例如下：

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

    def __call__(self, *args, **kwargs):
        with open('log.txt', 'a') as f:
            f.write(f'function {self.func.__name__} called with args {args}, {kwargs}
')
        result = self.func(*args, **kwargs)
        with open('log.txt', 'a') as f:
            f.write(f'function {self.func.__name__} returned {result}
')
        return result


@Logger
def add(a, b):
    return a + b

# 调用被装饰的函数
print(add(1, 2))

在这个示例中，我们定义了一个类装饰器 Logger，它接收一个函数作为参数，并实现了 __call__ 方法，这个方法类似于一个函数调用。在这个方法中，我们首先打开一个文件，将函数名和参数写入文件中，然后调用原函数，并将结果保存下来，最后将结果写入文件中，并返回结果。

## 小结

通过本文的介绍，我们了解到 Python 函数装饰器的基本概念和用法，以及如何编写带参数的装饰器、多个装饰器和类装饰器。装饰器是 Python 非常重要的语言特性之一，使用装饰器可以让我们方便地实现代码复用，提高代码的可读性和可维护性，强烈建议开发者们掌握这一