55、Python之函数高级：一篇文章彻底搞懂什么是“闭包”

最新推荐文章于 2024-10-02 10:53:34 发布

南宫理的日知录

最新推荐文章于 2024-10-02 10:53:34 发布

阅读量1.3k

点赞数 34

分类专栏：好玩好用的Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/dqrcsc/article/details/141640514

版权

好玩好用的Python 专栏收录该内容

95 篇文章 1 订阅

订阅专栏

引言

在Python编程中，有一个让一些新手望而却步的概念——“闭包（Closure）”。

一方面闭包的定义及作用机制确实稍微有点复杂，另一方面，这个概念似乎更偏向数学、理论场面，新手学来，似乎无太多应用场景。

但是，基于前面介绍的，关于函数对象、函数是一等公民、高阶函数，以及函数对象的内部细节的探究等。我相信理解并掌握“闭包”的概念及使用，会变得更加容易，是“水到渠成、自然而然”的事情。

本文的主要内容有：

1、探究“闭包”概念背后的本质

2、一个闭包实例

3、闭包的作用机制

探究“闭包”概念背后的本质

前面的文章中，我们曾经提及编程学习中的两大核心，即“数据的表达”和“数据的处理”，也可以表述为“数据结构”和“算法”。其实，这是一个极简的表达。

更加完整来看的话，每一个程序更加完整的构成，都需要有以下几个部分：

1、输入数据的集合

2、内部状态的集合

3、计算规则的集合

4、输出数据的集合

这其实也是计算机科学背后的图灵机的抽象。从这个抽象的角度，如果看通常的编程语言中的函数，我们可以发现，似乎是对图灵机的删减版本，删减的部分是“内部状态的集合”。也就是说，纯粹的函数是更加聚焦于计算规则，而没有内部状态的图灵机。

但是，有些时候，我们确实是需要内部状态的，根据内部状态的不同，对于相同的输入，函数能给出不一样的输出。

于是便有了“闭包”的概念，闭包可以粗略理解为“有内部状态的函数”，它是一个函数与其相关的上下文环境状态的组合。

这样看来，闭包其实就是一个简单的对象，这个对象只有一个方法。

反过来看，对象可以看成是几个共享内部状态的闭包，这种说法也是可以成立的。

所以，闭包和对象，是一而二，二而一的关系，本质上是一个东西。

由此，我们可以进一步得出，函数式编程与面向对象编程，在底层基础上也是一致的结论。

如果在其他函数式编程语言中，理解函数、闭包、对象似乎还有些复杂。

但是，如果我们聚焦到Python中来看，由于“一切皆对象”这个底层的“一”的存在，Python中的函数是对象，其本身也是具有状态（即属性）的。那么，在Python中我们似乎又不必严格区分什么是函数、什么是闭包了，因为Python中的函数都是对象，都有状态，有状态的函数就是闭包，那么Python中一切函数似乎也都是闭包了。

当然，以上只是基于底层概念所做的一些推论而已。在实际的编程语法上，普通函数和闭包还是有些许的差别的。

结合上一篇文章中，关于函数对象的内部构成的探究，我们可以得出如下的结论：

1、Python中的函数都是对象，所以，从广义上来说，Python中的函数都可以是有状态的函数。

2、Python中的函数状态，就是其定义执行的上下文环境。

3、Python中的普通函数，其内部状态也就是其定义所处的全局命名空间，这个状态在函数对象中，可以通过__globals__属性来进行读写。

4、Python中的特殊函数对象，特指“闭包”，其内部状态除了__globals__属性所对应的全局命名空间外，还有一个__closure__属性所存储的“闭包”所特有的内部状态。

暂且停止概念的论述，只要有个理念性的感知即可。后面，我们通过实际代码进一步演示这些概念。

一个闭包实例

我们以一个带初始值的累加器的实现为例，来分别看一下普通函数和闭包的使用，从而分析、比较闭包的特点及特定场景中的优势所在。

在真正使用闭包之前，我们先看一下普通的有状态的函数的使用：

首先定义一个模块m1.py：

total = 20


def acc(step):
    global total
    total += step

然后，我们在入口文件中导入m1模块，进行函数调用：

import m1

print(f"初始值为：{m1.total}")
print(f"函数内部状态：{m1.acc.__globals__['total']}")
m1.acc(5)
print(f"加5之后变为：{m1.total}")
print(f"函数内部状态：{m1.acc.__globals__['total']}")
m1.acc(10)
print(f"又加了10之后变为：{m1.total}")
print(f"函数内部状态：{m1.acc.__globals__['total']}")

执行结果：

从执行结果来看，Python中定义的普通函数确实是有状态的，也实现了累加器的效果。

但是，我们也应该意识到，普通函数的状态，本质上不是独属于函数自身的，而是与函数所属模块中的所有函数、代码块所共享的模块自身的全局命名空间。

所以，这个状态显然是不够安全的，毕竟全局变量中存储的状态，被修改的途径比较多。

除了状态共享所导致的不安全之外，我们没法实现多个不同状态的累加器的并存。

下面，我们通过闭包实现这个累加器的需求：

def acc(total=20):
    def inner(step):
        nonlocal total
        total += step
        return total

    return inner


acc1 = acc(0)
print(acc1.__closure__)
print(f"初始状态：{acc1.__closure__[0].cell_contents}")
print(f"加10之后变为：{acc1(10)}")
print(f"加10之后变为：{acc1(100)}")

acc2 = acc(100)
print(acc2.__closure__)
print(f"初始状态：{acc2.__closure__[0].cell_contents}")
print(f"加10之后变为：{acc2(10)}")
print(f"加10之后变为：{acc2(100)}")
print(acc1)
print(acc2)

执行结果：