内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力

def lazy_sum(*args):

def sum():
    ax = 0
    for n in args:
        ax = ax + n
    return ax
return sum

调用lazy_sum()时，返回的并不是求和结果，而是求和函数:

f = lazy_sum(1, 3, 5, 7, 9)
f
<function lazy_sum..sum at 0x101c6ed90>

调用函数f时，才是真正计算求和的结果

f()
25

当我们调用lazy_sum()时，每次调用都会返回一个新的函数，则f1()和f2()的调用结果互不影响

f1 = lazy_sum(1, 3, 5, 7, 9)
f2 = lazy_sum(1, 3, 5, 7, 9)
f1==f2
False

闭包

辅助理解资料https://zhuanlan.zhihu.com/p/453787908

返回的函数在其定义内部引用了局部变量args，一个函数返回了一个函数后，其内部的局部变量还被新函数引用，返回的函数并没有立刻执行，而是直到调用了f()才执行。

def count():

fs = []
for i in range(1, 4):
    def f():
         return i*i
    fs.append(f)
return fs

f1, f2, f3 = count()

上面的例子中，每次循环，都创建了一个新的函数，然后，把创建的3个函数都返回了。调用上述三个函数，结果全部都是9，原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。

返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

若一定要引用循环变量，方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：

def count():
def f(j):
def g():
return j*j
return g
fs = []
for i in range(1, 4):
fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
return fs

nonlocal

使用闭包，就是内层函数引用了外层函数的局部变量。如果只是读外层变量的值，我们会发现返回的闭包函数调用一切正常

def inc():
    x = 0
    def fn():
        # 仅读取x的值:
        return x + 1
    return fn
	f = inc()
	print(f()) # 1
	print(f()) # 1

但如果对外层变量赋值，由于Python解释器会把x当作函数fn()的局部变量，它会报错，原因是：x作为局部变量并没有初始化，直接计算x+1是不行的。但我们其实是想引用inc()函数内部的x，所以需要在fn()函数内部加一个nonlocal x的声明。加上这个声明后，解释器把fn()的x看作外层函数的局部变量，它已经被初始化了，可以正确计算x+1。

def inc():
    x = 0
    def fn():
        # nonlocal x
        x = x + 1
        return x
    return fn

f = inc()
print(f()) # 1
print(f()) # 2

使用闭包时，对外层变量赋值前，需要先使用nonlocal声明该变量不是当前函数的局部变量