python 闭包理解

网络上大家对闭包的定义一般是说“能够读取外部函数变量的函数”，一直感觉这个有点理解上不是那么自然。这里以python3为例，通过简单的实践解析下它里面的闭包到底是个什么样的东西。

先来个简单的例子：

def func_wrapper(a):
    
    def func1(x):
        return a*x
    
    def func2(x):
        return x
    
    return func1, func2

if __name__ == '__main__':
    funcs = func_wrapper(10)
    for i in funcs:
        print('{}: {}'.format(i.__name__, i.__closure__))
        if i.__closure__ is not None:
            for j in i.__closure__:
                print(j.cell_contents)

输出：

func1: (<cell at 0x039ACEF0: int object at 0x7A67D940>,)
10
func2: None

从这个例子可以清楚看到，只有使用了外部变量的内部函数才会产生闭包。而且，从python对闭包的实现上来看，闭包理解为绑定到内部函数上的外部变量集合会比较合适。函数都有一个__closure__属性，如果函数绑定了一个闭包集合，以后使用到相关外部变量都会从这里面取。外部函数的__closure__属性永远为None。此时，你可能还有疑问，使用到全局变量的函数会不会产生闭包呢，看下面这个例子：

g_a = 100

def func_wrapper(a):
    def func(x):
        return g_a*x
    return func

if __name__ == '__main__':
    func = func_wrapper(10)
    print(func.__closure__)

输出

None

很明显，全局变量并不在闭包的考虑范围。说到这里，关于python的闭包，应该有个大概的概念了。我们再深入看一下它的细节。再来一个例子：

def func_wrapper():
    a = 10
    def func1():
        a = 100
        print('{}: {}'.format('func1', a))
        return a
    
    def func2():
        print('{}: {}'.format('func2', a))        
        return a
    
    return func1,func2

if __name__ == '__main__':
    func = func_wrapper()
    for i in func:
        i()
        print(i.__closure__)
        if i.__closure__ is not None:
            for j in i.__closure__:
                print(j.cell_contents)

输出

func1: 100
None
func2: 10
(<cell at 0x03AACFB0: int object at 0x7A67D940>,)
10

我们看到对func2产生了闭包集{a}，而func1没有产生闭包；因为在python3中，不能直接对外部变量进行写
，如果直接写，它会认为你在重新定义一个内部函数的局部变量，并在接下来的访问中隐藏对外部同名变量的访问。如果确实需要写外部变量，需要先在使用前声明，使用nonlocal关键字，上面例子可以修改下：

def func_wrapper():
    a = 10
    def func1():
    	nonlocal a
        a = 100
        print('{}: {}'.format('func1', a))
        return a
    
    def func2():
        print('{}: {}'.format('func2', a))        
        return a
    
    return func1,func2

输出：

func1: 100
(<cell at 0x03ABCFD0: int object at 0x7A67DEE0>,)
100
func2: 100
(<cell at 0x03ABCFD0: int object at 0x7A67DEE0>,)
100

可以看到，此时对func1也产生了闭包。你也许会问了，我能不能在内部函数中开始一段使用自己的局部变量，后面一段才开始使用同名的外部变量，如：

def func_wrapper():
    a = 10
    def func1():
        a = 100
       	print(a)
        nonlocal a
        print('{}: {}'.format('func1', a))
        return a
    
    def func2():
        print('{}: {}'.format('func2', a))        
        return a
    
    return func1,func2

输出：

SyntaxError: name 'a' is used prior to nonlocal declaration

答案是Noway，如果真想这么写只能说明你代码命名规范有问题。下面我们探讨另一个问题，外部函数中的变量对于它产生的闭包是共享的吗？还是先来示例：

def func_wrapper():
    a = 100
    def func():
        nonlocal a
        print('a: {}'.format(a))
        a += 200
    
    return func


if __name__ == '__main__':
    func1 = func_wrapper()
    func2 = func_wrapper()
    func1()
    func2()

很明显，外部函数的每次调用产生的闭包毫无关系，这也很容易理解，每次外部函数调用都会使用新的堆栈，调用完成就销毁。那么同一次外部函数调用下产生的多个函数之间对外部变量的访问是否是共享的呢，看例子：

def func_wrapper():
    a = 10
    
    def func1():
        nonlocal a
        print('a: {}'.format(a))
        a = 99
        return a
    
    def func2():
        nonlocal a
        print('a: {}'.format(a))
        a = 88
        return a
    
    return func1, func2


if __name__ == '__main__':
    funcs = func_wrapper()
    funcs[0]()
    funcs[1]()
    funcs[0]()

输出

a: 10
a: 99
a: 88

从输出上看，他们是共享的。我们再探究下细节，看下引用的a的地址是否一致：

def func_wrapper():
    a = 10
    
    def func1():
        nonlocal a
        print('a: {}, id(a): {}'.format(a, id(a)))
        a = 99
        return a
    
    def func2():
        nonlocal a
        print('a: {}, id(a): {}'.format(a, id(a)))
        a = 88
        return a
    
    return func1, func2

输出：

a: 10, id(a): 2053626176
a: 99, id(a): 2053627600
a: 88, id(a): 2053627424

这个例子不太好，没有抓住要说明的重点还容易让人搞混，id不同是python的实现方式决定的，你可以在python shell下试下，对变量每次赋值都会有一个新的id值（对于数字或者字符串常量，python应该已经初始化好了一些变量，放在初始化好的内存地址了，所以只要值相同id会相同，但是你自己定义的类的实例、列表、字典，每次初始化一个，不管值内容相不相同id肯定是不一样的），这里只是为了对比后面例子列出来下。我们重点来看这个例子：

def func_wrapper():
    a = []
    
    def func1():
        nonlocal a
        print('a: {}, id(a): {}'.format(a, id(a)))
        a.append(100)
        return a
    
    def func2():
        nonlocal a
        print('a: {}, id(a): {}'.format(a, id(a)))
        a.append(99)
        return a
    
    return func1, func2

输出

a: [], id(a): 29050320
a: [100], id(a): 29050320
a: [100, 99], id(a): 29050320
a: [100, 99, 100], id(a): 29050320

这里可以清楚看到，对于同一次外部函数调用下产生的不同内部函数闭包中对变量是共享的。