python的闭包

什么是闭包：

1.闭包函数必须有内嵌函数
2.内嵌函数需要引用该嵌套函数上一级namespace中的变量
3.闭包函数必须返回内嵌函数
通过这三点，就可以创建一个闭包； python装饰器就是使用了闭包

闭包使得代码变得更加简洁
简单的闭包案例：

def fo():
    m = 3
    n = 5
    def bar():
        a = 4
        return m+n+a
    return bar
bar = fo()
print(bar())

>>> def test():
...     print("test被执行111")
...     a = 100
...     def test_in():
...         result = a + 100
...         return result
...     print("test被执行2222")
...     return test_in
... 
结果：
>>> t = test()
test被执行111
test被执行2222
>>> print(t())
200

>>> def test(number):
...     def test_in(number_in):
...         print("in test_in 函数，number_in is %d"%number_in)
...         return number+number_in
...     return test_in
... 
>>> ret = test(20)  //ret指向的是test_in方法，可以通过ret()调用
>>> print(ret(100))
in test_in 函数，number_in is 100
120
>>> print(ret(200))
in test_in 函数，number_in is 200
220
>>> 

内部函数对外部函数作用域里变量的引用（非全局变量），则称内部函数为闭包。

访问外部函数的可变类型局部变量可不加nonlocal

>>> def counter(start=0):
...     count=[start]
...     def incr():
...         count[0] += 1
...         return count[0]
...     return incr

>>> a = counter(10)
>>> a()
11
>>> a()
12
>>> b = counter(10)
>>> b()
11
>>> b()
12

访问外部函数的不可变类型局部变量要加nonlocal

>>> def counter(start=0):
...     def incr():
...         nonlocal start
...         start += 1
...         return start
...     return incr
... 
>>> c = counter(5)
>>> print(c())
6
>>> print(c())
7
>>> print(c())
8
>>> c1 = counter(50)
>>> print(c1())
51
>>> print(c1())
52

闭包的应用（y = x + 1 和 y = 2x + 1）

>>> def line_conf(a,b):
...     def line(x):
...         return a*x + b
...     return line
... 
>>> line1 = line_conf(1,1)
>>> line2 = line_conf(2,1)
>>> print(line1(5))
6
>>> print(line2(5))
11

在上面这个例子中，函数line 与变量a,b构成闭包，在创建闭包的时候，我们通过line_conf的参数a,b说明了这俩个变量的取值这样，我们就确定了函数的最终形式(y = x + 1和y = 2x + 1)。我们只需要变换参数a,b，就可以获得不同的直线表达函数。由此，我们可以看到，闭包也具有提高代码可复用性的作用。
如果没有闭包，我们需要每次创建直线函数的时候同时说明a,b,x。这样，我们就需要更多的参数传递，也减少了代码的可移植性。

闭包的扩展-函数三层嵌套

>>> def counter(start=0):
...     count=[start]
...     def incr():
...         count[0] += 1
...         def incrr():
...             count[0] += 1
...             return count[0]
...         return incrr
...     return incr
... 
>>> print(counter(10)()())
12
>>> print(counter(10)()())
12

闭包总结

1.闭包似优化了变量，原来需要类对象完成的工作，闭包也可以完成.
2.由于闭包引用了外部函数的局部变量，则外部函数的局部变量没有及时释放，消耗内存.
3.闭包的好处，使代码变得简洁，便于阅读代码。
4.闭包是理解装饰器的基础