第26篇：闭包

学习目标：掌握闭包相关知识点

在之前的课程中，我们讲到过关于函数的知识，接下来的两篇文章来学函数的两个高阶应用，闭包和装饰器，这两个也属于Python的核心特色，学了这两个高阶功能，我们就可以做更多事情了。本节为闭包的介绍。

一、闭包的定义

如果在一个函数的内部定义了另一个函数，外部的函数叫它外函数，内部的函数叫它内函数。

二、闭包的条件

1. 在一个外函数中定义了一个内函数。
2. 内函数里运用了外函数的临时变量。
3. 并且外函数的返回值是内函数的引用。

一般情况下，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。但是闭包是一种特殊情况，如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束。

三、闭包示例

来看一段代码

# 闭包函数的实例
# outer是外部函数 a和b都是外函数的临时变量
def outer(a):
    print('1'.center(10, '-'))
    # 在函数内部再定义⼀个函数， 并且这个函数⽤到了外边函数的变量， 那么将这个函数成为闭包
    b = 10

    # inner是内函数
    def inner():
        print('2'.center(10, '-'))
        # 在内函数中 用到了外函数的临时变量
        print(a + b)

    print('3'.center(10, '-'))
    # 外函数的返回值是内函数的引用
    return inner


if __name__ == '__main__':
    # 在这里我们调用外函数传入参数5
    # 此时外函数两个临时变量 a是5 b是10 ，并创建了内函数，然后把内函数的引用返回存给了dem
    # 外函数结束的时候发现内部函数将会用到自己的临时变量，这两个临时变量就不会释放，会绑定给这个内部函数
    demo = outer(5)
    # 我们调用内部函数，看一看内部函数是不是能使用外部函数的临时变量
    # demo存了外函数的返回值，也就是inner函数的引用，这里相当于执行inner函数
    demo()  
    """
    ----1-----
    ----3-----
    ----2-----
    15
    """
    demo2 = outer(7)
    demo2()
    """
    ----1-----
    ----3-----
    ----2-----
    17
    """

上面例子是一个最简单的很典型的闭包。

A 外函数返回了内函数的引用

　　引用是什么？在python中一切都是对象，包括整型数据1，1.23，函数，都是对象。

　　当我们进行a=1的时候，实际上在内存当中有一个地方存了值1，然后用a这个变量名存了1所在内存位置的引用。引用就类似于c语言里的指针，引用也可以理解成地址。a只不过是一个变量名字，a里面存的是1这个数值所在的地址，就是a里面存了数值1的引用。

　　相同的道理，在python中定义一个函数def demo(): 的时候，内存当中会开辟一些空间，存下这个函数的代码、内部的局部变量等等。这个demo只不过是一个变量名字，它里面存了这个函数所在位置的引用而已。我们还可以进行x = demo， y = demo， 这样的操作就相当于，把demo里存的东西赋值给x和y，这样x 和y 都指向了demo函数所在的引用，在这之后我们可以用x() 或者 y() 来调用我们自己创建的demo() ，调用的实际上根本就是一个函数，x、y和demo三个变量名存了同一个函数的引用。

　　返回内函数，对于闭包，在外函数outer中 最后return inner，在调用外函数 demo = outer() 的时候，outer返回了inner，inner是一个函数的引用，这个引用被存入了demo中。所以接下来再进行使用demo() 的时候，相当于使用了inner函数。

　　一个函数，如果函数名后紧跟一对括号，说明现在就要调用这个函数，如果不跟括号，只是一个函数的名字，里面存了函数所在位置的引用。

B 外函数把临时变量绑定给内函数

　　一个函数结束的时候，会把自己的临时变量都释放给内存，之后变量都不存在了。一般情况下，确实是这样的。但是闭包是一个特别的情况。外部函数发现，自己的临时变量会在将来的内部函数中用到，自己在结束的时候，返回内函数的同时，会把外函数的临时变量和内函数绑定在一起。所以外函数已经结束了，调用内函数的时候仍然能够使用外函数的临时变量。

　　在以上实际例子中，两次调用外部函数outer,分别传入的值是5和7。内部函数只定义了一次，我们发现调用的时候，内部函数是能识别外函数的临时变量是不一样的。python中一切都是对象，虽然函数我们只定义了一次，但是外函数在运行的时候，实际上是按照里面代码执行的，外函数里创建了一个函数，我们每次调用外函数，它都创建一个内函数，虽然代码一样，但是却创建了不同的对象，并且把每次传入的临时变量数值绑定给内函数，再把内函数引用返回。虽然内函数代码是一样的，但其实，我们每次调用外函数，都返回不同的实例对象的引用，他们的功能是一样的，但是它们实际上不是同一个函数对象。

四、闭包修改局部变量和全局变量

先来看一个例子

x = 0

def outer():
    x = 1
    def inner():
        x = 2
        print("inner:", x)
    inner()
    print("outer:", x)

outer()
print("global:", x)

# inner: 2
# outer: 1
# global: 0

全局变量是定义在函数和类外的变量，局部变量是定义在函数内（闭包中的外函数）的变量，在闭包内函数中，可以随意使用外函数绑定来的临时变量，但是如果想修改外函数临时变量或全局变量数值的时候发现出问题了！

闭包内函数修改全局变量

在基本的python语法当中，一个函数可以随意读取全局数据，但是要修改全局数据的时候有两种方法:

1. global 声明全局变量

2. 全局变量是可变类型数据的时候可以修改

示例1：声明global

x = 0

def outer():
    x = 1
    def inner():
        global x
        x = 2
        print("inner:", x)
    inner()
    print("outer:", x)

outer()
print("global:", x)
# inner: 2
# outer: 1
# global: 2

示例2：全局变量为可变类型变量

x = [1]

def outer():
    x = [2]
    def inner():
        x.append(3)
        print("inner:", x)
    inner()
    print("outer:", x)

outer()
print("global:", x)
# inner: [2, 3]
# outer: [2, 3]
# global: [1]

闭包内函数修改外函数局部变量

在闭包内函数也是类似的情况。在内函数中想修改闭包变量（外函数绑定给内函数的局部变量）的时候：

1. 可以用nonlocal 关键字声明一个变量， 表示这个变量不是局部变量空间的变量，需要向上一层变量空间找这个变量。

2. 可以把闭包变量改成可变类型数据进行修改，比如列表。

# 修改闭包变量的实例
# outer是外部函数 a和b都是外函数的临时变量
def outer(a):
    b = 10  # a和b都是闭包变量
    c = [a]  # 这里对应修改闭包变量的方法2

    # inner是内函数
    def inner():
        # 内函数中想修改闭包变量
        # 方法1 nonlocal关键字声明
        nonlocal b

        b += 1
        # 方法二，把闭包变量修改成可变数据类型 比如列表
        c[0] += 1
        print(c[0])
        print(b)
    # 外函数的返回值是内函数的引用
    return inner


if __name__ == '__main__':
    demo = outer(5)
    demo()  # 6 11

从上面代码中能看出来，在内函数中，分别对闭包变量进行了修改，打印出来的结果也确实是修改之后的结果。以上两种方法就是内函数修改闭包变量的方法。

五、闭包的应用

应用实例

有一点需要注意：使用闭包的过程中，一旦外函数被调用一次返回了内函数的引用，虽然每次调用内函数，是开启一个函数执行过后消亡，但是闭包变量实际上只有一份，每次开启内函数都在使用同一份闭包变量。例子如下：

def outer(x):
    def inner(y):
        nonlocal x
        x += y
        return x
    return inner


if __name__ == '__main__':
    a = outer(10)
    print(a(1))  # 11
    print(a(3))  # 14

两次分别打印出11和14，由此可见，每次调用inner的时候，使用的闭包变量x实际上是同一个。

再来看一个例子，闭包可以应用在求解指定线性方程中某个点的y值

def linear(a, b):
    def inner(x):
        print(a * x + b)

    return inner


if __name__ == '__main__':
    ll = linear(5, 5)
    ll(0)  # 5
    ll2 = linear(3, 4)
    ll2(0) # 4

应用领域

• 装饰器：装饰器是做什么的？其中一个应用就是，我们工作中写了一个登录功能，我们想统计这个功能执行花了多长时间，我们可以用装饰器装饰这个登录模块，装饰器帮我们完成登录函数执行之前和之后取时间。
• 面向对象！经历了上面的分析，我们发现外函数的临时变量送给了内函数。大家回想一下类对象的情况，对象有好多类似的属性和方法，所以我们创建类，用类创建出来的对象都具有相同的属性方法。闭包也是实现面向对象的方法之一。在python当中虽然我们不这样用，在其他编程语言入比如javaScript中，经常用闭包来实现面向对象编程

简单的总结

本节主要围绕闭包做了一些相关知识及应用的介绍，下一篇，我们将对闭包的一个重要应用，装饰器，进行详细说明。