Python中不同类型的闭包及其应用

Python 笔记

一、什么是闭包

在Python中，闭包是一个函数对象，即可以作为函数返回值来使用。它由两部分组成：内部函数和外部函数，其中内部函数可以访问外部函数中定义的变量和参数，即使外部函数已经返回，内部函数依然可以操作外部函数中的变量和参数。

举个例子，下面的代码定义了一个简单的闭包函数：

def outer(x):
    def inner(y):
        return x + y
    return inner
func = outer(10)
result = func(5) # 结果为 15

上述代码中，inner函数作为外部函数outer的返回值，在外部函数执行完毕后，通过func对象可以继续访问和使用外部函数中的参数x。

二、Python中的闭包类型

这是最普通的闭包类型，其内部函数在调用外部函数的一个变量时，不需要改变其变量的值。相反，在外部函数调用的同时，这个变量就被保存为内部函数的一个属性，以后每次调用内部函数时，都会使用之前保存的变量值。

下面的代码是一个非局部变量闭包的例子：

def outer():
    x = 10
    def inner():
        return x
    return inner
func = outer()
result = func() # 结果为 10

在这个例子中，我们定义了一个outer函数，它返回一个inner函数。当func变量被赋值为outer的返回时，实际上也保存了outer中的变量x，因此每次调用func时，都能够访问到之前保存的x。

在Python 3之前，内部函数中不能访问外部函数中定义的变量，但是可以修改同名的全局变量。因此，经常用一个解决方案是给外部函数中使用的局部变量打上nonlocal标记，在内部函数中使用这个局部变量的时候，就可以达到类似于闭包的效果。

下面的代码是一个局部变量闭包的例子：

def outer():
    x = 10
    def inner():
        nonlocal x
        x += 1
        return x
    return inner
func = outer()
result = func() # 结果为 11

在这个例子中，我们使用了nonlocal关键字，使得内部函数可以修改并保存x的值，达到了闭包的效果。

Python中的lambda表达式，也可以作为闭包来使用。与普通函数一样，lambda函数也可以捕获外部变量，并在函数内部调用这些变量。

下面的例子演示了lambda函数闭包的使用：

def outer():
    x = 10
    return lambda y: x + y
func = outer()
result = func(5) # 结果为 15

在这个例子中，三行代码等同于前面的例子，只不过使用了lambda函数。

三、闭包的应用

闭包可以用来延迟计算，即将一些计算推迟到必须执行的时候，这可以提高程序的性能和效率。

下面的代码展示了如何使用闭包实现延迟计算：

def outer(x):
    def inner(y):
        return x * y
    return inner
func = outer(10) # x=10
result1 = func(5) # 结果为 50
result2 = func(8) # 结果为 80

在这个例子中，outer函数返回了一个接受一个参数的内部函数inner，每次调用这个内部函数inner时，都会用之前保存的参数x去计算。

闭包也可以用来保存状态，即为每个闭包函数分配一个状态，以便在函数被多次调用时可以继承这个状态。

下面的代码展示了如何使用闭包保存状态：

def outer():
    count = 0
    def inner():
        nonlocal count
        count += 1
        return count
    return inner
func = outer()
result1 = func() # 结果为 1
result2 = func() # 结果为 2
result3 = func() # 结果为 3

在这个例子中，我们使用闭包实现了每次调用inner可以使count值自增1的效果，实现了保存状态的功能。

闭包还可以用来维护缓存，即将一些计算结果缓存起来，以便在下次执行同样的计算时可以直接使用缓存中的结果，提高程序性能和效率。

下面的代码展示了如何使用闭包维护缓存：

def cache(func):
    cached_results = {}
    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)

在这个例子中，我们定义了一个装饰器cache来实现缓存的功能，将计算结果保存在cached_results字典中。

结论

通过上述的介绍，我们可以发现，闭包在Python中有着广泛的应用，可以用来实现延迟计算、保存状态、维护缓存等功能，极大的提高了程序的性能和效率。同时值得注意的是，在使用闭包的时候，需要注意内部函数对外部变量的引用关系，以避免出现错误。