如何使用闭包函数实现装饰器

装饰器是 Python 语言中非常常用的高级编程特性，它们允许将一个函数或类包装在另一个可调用对象中，从而改变其行为。使用装饰器可以将代码的逻辑分离，增强代码的可复用性和可维护性。

装饰器本身就是一个函数，它可以被用来包装其他函数，并返回一个新的函数，从而改变传递给原始函数的行为。Python 中有许多内置的装饰器，比如 @staticmethod、@classmethod、@property 等等，它们可以用来修饰类方法、实例方法和属性访问方法。此外，Python 中还支持用户自定义装饰器，让用户可以灵活地扩展 Python 语言的功能。

在本文中，我们将介绍如何使用闭包函数实现装饰器。首先我们会讲解闭包的概念；然后会讲解 Python 中的装饰器是如何工作的；最后我们会以示例代码的形式来说明如何使用闭包函数实现装饰器。

1. 闭包函数

闭包函数是指将一个函数返回另一个函数的函数。函数中的“闭包”是指函数内部定义的一个函数，该函数可以访问函数外部的变量和函数，即使函数外部已经执行完毕并且该变量已经不存在了，闭包函数仍然能够访问该变量。

举个例子，下面的代码定义了一个函数 outer_func，它返回了一个闭包函数 inner_func：

def outer_func(x):
    def inner_func(y):
        return x + y
    return inner_func

outer_func 接收一个参数 x，并在内部定义了一个函数 inner_func，返回 inner_func。 inner_func 接收一个参数 y，并返回 x+y。闭包函数 inner_func 可以访问外部函数 outer_func 的参数 x，虽然 outer_func 已经执行完毕并且变量 x 已经不存在了。

我们可以测试一下闭包函数的行为：

>>> f = outer_func(10)  # f指向inner_func，x=10
>>> f(1)  # 计算10+1
11
>>> f(2)  # 计算10+2
12
>>> f = outer_func(20)  # f指向inner_func，x=20
>>> f(1)  # 计算20+1
21
>>> f(2)  # 计算20+2
22

由上面的测试可以看出，每次调用 outer_func，都会返回一个新的函数 inner_func，并记住其所在的环境，从而能够访问外部函数的变量。

2. Python 中的装饰器

在 Python 中，装饰器通常是一个函数，它可以被用来修饰其他函数或类。装饰器函数会接收被装饰的函数或类作为参数，并返回一个新的函数或类，从而改变被装饰对象的行为。

假设我们有一个函数 add，它实现了加法操作：

def add(x, y):
    return x + y

现在我们想要对 add 函数进行装饰，使之在每次调用 add 函数时都输出一行调用日志。这可以通过定义一个装饰器函数来实现：

def log(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        print(f"Call {func.__name__} with arguments {args} and result {result}")
        return result
    return wrapper

装饰器函数 log 接收一个函数作为参数，并返回一个新的闭包函数 wrapper。wrapper 函数可以访问被装饰函数的参数和返回值，并在函数执行前后输出日志。

现在我们可以将 log 装饰器应用到 add 函数上：

@log
def add(x, y):
    return x + y

这等价于执行 add = log(add)，即将函数 add 传递给装饰器函数 log，并将返回的闭包函数 wrapper 赋值给 add。

现在，每次调用 add 函数，都会先输出一行日志，然后执行原来的 add 函数：

>>> add(2, 3)
Call add with arguments (2, 3) and result 5
5

由此可见，Python 的装饰器可以非常方便地扩展原有的函数或类，而不需要修改其源代码。

3. 闭包函数实现装饰器的示例

现在我们来看一个示例，使用闭包函数实现一个装饰器，用来记录函数的执行时间。该装饰器可以应用于任何函数，并在函数完成执行后输出该函数的执行时间。

首先，我们定义计时器函数 timer，用来计算函数的执行时间：

import time

def timer(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:.6f} seconds")
        return result
    return wrapper

timer 函数接收一个函数作为参数，并返回一个闭包函数 wrapper。wrapper 函数用 time 模块计算函数的执行时间，并输出一行日志。

然后，我们定义一个测试函数 slow_calculation，它用于模拟一个较慢的计算过程：

@timer
def slow_calculation(n):
    result = 0
    for i in range(n):
        for j in range(n):
            result += i * j
    return result

slow_calculation 函数和 add 函数一样，使用了 @timer 装饰器，将 timer 函数应用于 slow_calculation 函数上。

现在，我们可以测试一下 slow_calculation 函数的执行时间：

>>> slow_calculation(10)
Function slow_calculation took 0.000001 seconds
2025
>>> slow_calculation(100)
Function slow_calculation took 0.000166 seconds
24502500
>>> slow_calculation(1000)
Function slow_calculation took 0.219315 seconds
166666500000

由此可见，slow_calculation 函数的执行时间随输入参数 n 的增加而增加，但是装饰器函数 timer 可以准确地计算函数的执行时间。