闭包

闭包，这个名词第一次看的时候非常懵，通过不断的复盘，终于有一点通透的感觉，再次总结一下

举例

闭包不是 Python 的概念，是所有 function-as-first-class 的语言都会涉及的概念

def new_counter():
    ...:     i = 0
    ...:     def count():   
    ...:         nonlocal i    #  onlocal关键字用来在函数或其他作用域中使用外层(非全局)变量。在Python 2.x中，闭包只能读外部函数的变量，而不能改写它。为了解决这个问题，Python 3.x引入了nonlocal关键字,只要在闭包内用nonlocal声明变量，就可以让解释器在外层函数中查找变量名了
    ...:         i += 1
    ...:         return i
    ...:     return count
    ...:

In [62]: a_count = new_counter()
In [63]: b_count = new_counter()

In [64]: a_count()
Out[64]: 1

In [65]: a_count()
Out[65]: 2

In [66]: b_count()
Out[66]: 1

上面代码a_count b_count是2个独立的计数器。

在[函数]外，一段代码最始开所赋值的变量，它可以被多个函数引用，这就是全局变量，在函数内定义的变量名，只能被函数内部引用，不能在函数外引用这个变量名，这个变量的作用域就是局部的，也叫它为局部变量

作用域简单说就是一个[变量]的命名空间。代码中变量被赋值的位置，就决定了哪些范围的对象可以访问这个变量，这个范围就是命名空间。python赋值时生成了变量名，当然作用域也包括在内。

闭包在实际中的妙用

假设你要写一个函数的绘图模块，你并不关心要画的东西究竟是什么，你只负责实现一个功能就是给出 x 坐标的值你能够返回给我一个 y 坐标。
因此你告诉你所有的开发小伙伴，调用我这个绘图的功能大家必须要符合一个接口，就是 foo(x) -> y。你为什么这么要求呢？
因为你们的程序跑在一种异常复杂的硬件上，全世界就你一个人会这个玩意，实现这么一个功能已经很累了。而且同事们的绘图需求太多了，有人要画椭圆，有人要画抛物线，有人要画伽利略螺旋等等，你不可能给每个人都写一个单独的接口提供这个功能。况且，有的东西你也不知道怎么画（譬如什么伽利略螺旋）。因为接口一样，所以有很多好处，比如你的程序可能长这个样子：

def draw(func_list):
    for func in func_list:
        for x in domain:
            draw(x, func(x))     #  异常复杂 ( ⊙ o ⊙ )

于是乎大家就风风火火的开干了。这个时候你们公司有个小明。小明是个新员工，因此他被分配到实现一些简单地功能，比如调用你的接口去画直线。但是这个时候有一个很操蛋的需求，就是这个直线的方程是根据用户的一系列复杂的生理特征动态生成的，比如斜率是24小时平均心跳速度，截距是上一个小时消耗的卡路里（别问我这个直线有什么用，很复杂的！）。OK，因为是动态生成的，所以不能写死啊，不能写成酱紫：

def extreme_complex_line(x):   
    return 12*x+8

但是接口又是写死的，所以你不能写成下边这样：

def extreme_complex_line(heart_beats, ka_lu_li, x):
    return heart_beats*x+ka_lu_li

况且你们公司有2000多名用户，所以必然要有一个动态的方法去生成这些包含上下文信息的函数，怎么做呢？聪明的你已经想到了：闭包！

def line_conf(heart_beats, ka_lu_li):   # 代码展示用，有一点小问题，主要看编程思想
    def _line(x):   # 这里x未说明，有点问题
        return heart_beats*x+ka_lu_li
    return _line

lines = [line_conf(a, b) for a,b in two_thousand_users_data]

draw(lines)    # 心跳，卡路里

作用域

作用域是程序运行时变量可被访问的范围，定义在函数内的变量是局部变量，局部变量的作用范围只能是函数内部范围内，它不能在函数外引用。

定义在模块最外层的变量是全局变量，它是全局范围内可见的，当然在函数里面也可以读取到全局变量的。例如：

num = 10 # 全局作用域变量
def foo():
    print(num)  # 10

而在函数外部则不可以访问局部变量。例如：

def foo():
    num = 10
print(num)  # NameError: name 'num' is not defined

嵌套函数

函数不仅可以定义在模块的最外层，还可以定义在另外一个函数的内部，像这种定义在函数里面的函数称之为嵌套函数（nested function）例如：

def print_msg():
    # print_msg 是外围函数
    msg = "zen of python"

    def printer():
        # printer是嵌套函数
        print(msg)
    printer()
# 输出 zen of python
print_msg()

对于嵌套函数，它可以访问到其外层作用域中声明的非局部（non-local）变量，比如代码示例中的变量 msg可以被嵌套函数 printer 正常访问。

那么有没有一种可能即使脱离了函数本身的作用范围，局部变量还可以被访问得到呢？答案是闭包

什么是闭包

函数身为第一类对象，它可以作为函数的返回值返回，现在我们来考虑如下的例子：

def print_msg():
    # print_msg 是外围函数
    msg = "zen of python"
    def printer():
        # printer 是嵌套函数
        print(msg)
    return printer

another = print_msg()
# 输出 zen of python
another()

这段代码和前面例子的效果完全一样，同样输出 "zen of python"。不同的地方在于内部函数 printer 直接作为返回值返回了。

一般情况下，函数中的局部变量仅在函数的执行期间可用，一旦 print_msg() 执行过后，我们会认为 msg变量将不再可用。然而，在这里我们发现 print_msg 执行完之后，在调用another的时候 msg 变量的值正常输出了，这就是闭包的作用，闭包使得局部变量在函数外被访问成为可能。

看完这个例子，我们再来定义闭包，维基百科上的解释是:

在计算机科学中，闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。

这里的 another 就是一个闭包，闭包本质上是一个函数，它有两部分组成，printer 函数和变量 msg。闭包使得这些变量的值始终保存在内存中。

闭包，顾名思义，就是一个封闭的包裹，里面包裹着自由变量，就像在类里面定义的属性值一样，自由变量的可见范围随同包裹，哪里可以访问到这个包裹，哪里就可以访问到这个自由变量。

为什么要使用闭包

闭包避免了使用全局变量，此外，闭包允许将函数与其所操作的某些数据（环境）关连起来。这一点与面向对象编程是非常类似的，在面对象编程中，对象允许我们将某些数据（对象的属性）与一个或者多个方法相关联。

一般来说，当对象中只有一个方法时，这时使用闭包是更好的选择。来看一个例子：

def adder(x):
    def wrapper(y):
        return x + y
    return wrapper   # 注意，这里返回的是wrapper,不是wrapper()

adder5 = adder(5)    # 这里的adder5是不是变量，它是函数的对象，print(adder5) 输出<function wrapper at 0x10fcaf0c8>。
# 输出 15
adder5(10)   # 所以10就是adder5这个函数对象的参数。
# 输出 11     # 注意⚠️函数对象！！！面向对象编程思想
adder5(6)

这比用类来实现更优雅，此外装饰器也是基于闭包的一种应用场景。

所有函数都有一个 __closure__属性，如果这个函数是一个闭包的话，那么它返回的是一个由 cell 对象 组成的元组对象。cell 对象的cell_contents 属性就是闭包中的自由变量。

>>> adder.__closure__
>>> adder5.__closure__
(<cell at 0x103075910: int object at 0x7fd251604518>,)
>>> adder5.__closure__[0].cell_contents
5

这解释了为什么局部变量脱离函数之后，还可以在函数之外被访问的原因的，因为它存储在了闭包的 cell_contents中了。

自己继续做个实验去理解：

In [78]: def adder(x):
    ...:     def wrapper(y):
    ...:         return x - y
    ...:     return wrapper
    ...:

In [79]: adder5 = adder(5)

In [80]: adder5(10)      #  通过x - y = -5, 我们可以判断x = 5,y = 10
Out[80]: -5

In [81]: adder6(10)     #  adder5是一个变量，adder6神马都不是
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-81-ae00cfac67c3> in <module>()
----> 1 adder6(10)

NameError: name 'adder6' is not defined

In [82]: adder5(6)
Out[82]: -1

In [83]: adder(5)(10)      #  等同于 adder5(10)，这说明什么？adder将10给了里面的变量y? 待理解
Out[83]: -5       # 这就是闭包的特点，adder(10)(5)的结果是5，闭包允许函数关联的参数与内部的参数关联，这正是它的特色

类 实例 对象

面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。

最后，自己做个小实验

In [21]: def add(x):
    ...:     return x + 1
    ...:

In [22]: add(2)
Out[22]: 3

In [23]: add
Out[23]: <function __main__.add>   #  表示它是函数add,所以b就是函数的变量

In [24]: b = add

In [25]: b(2)
Out[25]: 3

In [26]: b(4)
Out[26]: 5