Python闭包

解释：如果在一个函数的内部定义了另一个函数，外部的我们叫他外函数，内部的我们叫他内函数。

闭包：在一个外函数中定义了一个内函数，内函数里使用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。

闭包(Closure)是词法闭包(Lexical Closure)的简称，是函数式编程的重要语法结构。
如果一个函数里定义了一个内部函数，这个函数引用了外部函数的相关参数或变量，外部函数最终把这个内部函数返回了，
那么这个内部函数被称为闭包。举个例子：
def func(x):       
    def inner(y):               
        return x + y
    return inner

f = func(2)
print(f)
print(f(8))
print(func(2)(8)) 

 

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

#将函数作为返回值返回，也是一种高阶函数
#这种高阶函数我们也称为叫做闭包，通过闭包可以创建一些只有当前函数能访问的变量
#可以将一些私有的数据藏到的闭包中
def outer():
    a = 10
    # 函数内部再定义一个函数
    def inner():
        print('我是outer', a)
    # 将内部函数 inner作为返回值返回
    return inner

#r是一个函数对象，是调用fn()后返回的函数对象
#这个函数是在fn()内部定义，并不是全局函数
#所以这个函数总是能访问到fn()函数内的变量
#外函数返回了内函数的引用
fn = outer()
#r()相当于调用了inner()函数
print("outer引用地址：", outer)
print("inner引用地址：", fn)
fn()

说明上述代码：

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

现在有一组数据，既要计算每个数据的二次方，又要计算每个数据的三次方。示例如下:

from math import pow

data = [1,2,3,4,5,6]
def get_result(n):
    def do_pow(x):
        return pow(x,n)
    return do_pow
    
pow_2 = get_result(2)
pow_3 = get_result(3)
for i in data:
    pow_2(i)
    pow_3(i)

注意：

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

在闭包中外函数把临时变量绑定给内函数

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

def outer(num):
    a = num
    # 函数内部再定义一个函数
    def inner():
        print('我是outer', a)
    # 将内部函数 inner作为返回值返回
    return inner
    
fn1 = outer(10)
fn2 = outer(20)
print("inner引用地址：", fn1)
fn1()
print("inner引用地址：", fn2)
fn2()

上面的代码中，两次调用外部函数outer，分别传入的值是10和20。内部函数只定义了一次，可以发现调用的时候，内部函数是能识别外函数的临时变量是不一样的。

Python中一切都是对象，虽然函数只定义了一次，但是外函数在运行的时候，实际上是按照里面代码执行的，外函数里创建了一个函数，我们每次调用外函数，它都创建一个内函数，虽然代码一样，但是却创建了不同的对象，并且把每次传入的临时变量数值绑定给内函数，再把内函数引用返回。

所以我们每次调用外函数，都返回不同的实例对象的引用，他们的功能是一样的，但是它们实际上不是同一个函数对象。【其实这也间接的解释了为什么函数可以作为参数传递】

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

使用闭包注意点：

（1）闭包无法修改外部函数的局部变量。示例如下：

def func():
    x = 0
    def inner():
        x = 1
        print('inner x:',x)
    print('func x before run inner:',x)
    inner()
    print('func x after run inner:', x)
    
func()

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

• global声明全局变量。全局变量是可变类型数据的时候可以修改。

• 在闭包内函数也是类似的情况。在内函数中想修改闭包变量（外函数绑定给内函数的局部变量）的时候，在Python3中，可以用nonlocal关键字声明一个变量， 表示这个变量不是局部变量空间的变量，需要向上一层变量空间找这个变量。

• def outer(num):
      a = num
      b = 10  # a和b都是闭包变量
      print("原始a值为", a)
      # inner内函数
      def inner():
          # 内函数中想修改闭包变量
          # nonlocal关键字声明变量
          nonlocal a
          a = a + b
          print('我是outer的a', a)
      # 将内部函数 inner作为返回值返回
      return inner
      
  fn1 = outer(10)
  fn1()

需要注意：还有一点需要注意，闭包变量实际上只有一份，每次调用一份闭包变量。 

def outer(num):
    a = num
    b = 10  # a和b都是闭包变量
    print("原始a值为", a)
    # inner内函数
    def inner():
        # 内函数中想修改闭包变量
        # nonlocal关键字声明变量
        nonlocal a
        a += b
        print('我是outer的a', a)
    # 将内部函数 inner作为返回值返回
    return inner
fn1 = outer(10)
fn1()
fn1()
fn1()

def func():
    x = 10
    def inner():
        nonlocal x   #把x声明为非局部变量
        x = 2*x
        print(x)
    return inner
func()()