fun = [lambda x: x*i for i in range(4)]
for item in fun:
print(item(1))
上述式子的输出结果：
预计结果为：0, 2, 4, 6
实际输出为：3, 3, 3, 3
原理：i 在外层作用域
lambda x: x*i为内层（嵌）函数，他的命名空间中只有 {'x': 1} 没有 i ，
所以运行时会向外层函数（这儿是列表解析式函数 [ ]）的命名空间中请求 i
而当列表解析式运行时，列表解析式命名空间中的 i 经过循环依次变化为 0-->1-->2-->3 最后固定为 3 ，
所以当lambda x: x*i内层函数运行时，去外层函数取 i 每次都只能取到 3解决办法：变闭包作用域为局部作用域。
给内层函数lambda x: x*i增加参数，命名空间中有了用来存储每次的 i ,
即改成[lambda x, i=i: x*i for i in range(4)]这样每一次，内部循环生成一个lambda 函数时，
都会把 --i--作为默认参数传入lambda的命名空间
循环4次实际lambda表达式为：
第一次：lambda x, i=0 第二次：lambda x, i=1 第三次：lambda x, i=2 第四次：lambda x, i=3
fun = [lambda x, i=i: x*i for i in range(4)]
for item in fun:
print(item(1))
#输出结果为：
0
1
2
3
函数fun = [lambda x: x*i for i in range(4)]等价于：如下函数
def func():
fun_lambda_list = []
for i in range(4):
def lambda_(x):
return x*i
fun_lambda_list.append(lambda_)
return fun_lambda_list
查看该函数命名空间及 I 值变化：
def func():
fun_lambda_list = []
for i in range(4):
def lambda_(x):
print('Lambda函数中 i {} 命名空间为：{}:'.format(i, locals()))
return x*i
fun_lambda_list.append(lambda_)
print('外层函数 I 为：{} 命名空间为:{}'.format(i, locals()))
return fun_lambda_list
fl = func()
fl[0](1)
fl[1](1)
fl[2](1)
fl[3](1)
#运行结果为：为了排版美观，我已将输出lambda_函数地址改名为：lam函数1 2 3
外层函数I为：0 命名空间为:{'i': 0, 'lambda_': lam函数1 'fun_lambda_list': [lam函数1]}
外I：1 命空:{'i': 1, 'lambda_': lam函数2, 'fun_lambda_list': [lam函数1, lam函数2]}
外I：2 命空:{'i': 2, 'lambda_': lam函数3, 'fun_lambda_list': [lam函数1, lam函数2, lam函数3]}
外I：3 命空:{'i': 3, 'lambda_': lam函数4, 'fun_lambda_list': [lam函数1, lam函数2, lam函数3, lam函数4]}
Lambda函数中 i 3 命名空间为：{'i': 3, 'x': 1}:
Lambda函数中 i 3 命名空间为：{'i': 3, 'x': 1}:
Lambda函数中 i 3 命名空间为：{'i': 3, 'x': 1}:
Lambda函数中 i 3 命名空间为：{'i': 3, 'x': 1}:
可以看见：就像上面所说的：四次循环中外层函数命名空间中的 i 从 0-->1-->2-->3 最后固定为3，
而在此过程中内嵌函数-Lambda函数中因为没有定义 i 所以只有Lambda 函数动态运行时，
在自己命名空间中找不到 i 才去外层函数复制 i = 3 过来，结果就是所有lambda函数的 i 都为 3，
导致得不到预计输出结果：0，1，2，3 只能得到 3, 3, 3, 3
- 解决办法：变闭包作用域为局部作用域。
def func():
fun_lambda_list = []
for i in range(4):
def lambda_(x, i= i):
print('Lambda函数中 i {} 命名空间为：{}:'.format(i, locals()))
return x*i
fun_lambda_list.append(lambda_)
return fun_lambda_list
fl = func()
res = []
res.append(fl[0](1))
res.append(fl[1](1))
res.append(fl[2](1))
res.append(fl[3](1))
print(res)
#输出结果为：
Lambda函数中 i 0 命名空间为：{'x': 1, 'i': 0}:
Lambda函数中 i 1 命名空间为：{'x': 1, 'i': 1}:
Lambda函数中 i 2 命名空间为：{'x': 1, 'i': 2}:
Lambda函数中 i 3 命名空间为：{'x': 1, 'i': 3}:
[0, 1, 2, 3]
给内层函数 lambda_增加默认参数，命名空间中有了用来存储每次的 i , 即改成 def lambda_(x, i=i) : 这样每一次，
内部循环生成一个lambda 函数时，都会把 i 作为默认参数传入lambda的命名空间
循环4次实际lambda表达式为：
第一次：lambda_( x, i=0) 第二次：lambda_(x, i=1) 第三次：lambda_(x, i=2) 第四次：lambda_(x, i=3)
这样我们就能得到预计的结果：0, 1, 2, 3
fun = [lambda x,i=i: x*i for i in range(4)]
只有函数、类、模块会产生作用域，代码块不会产生作用域。作用域按照变量的定义位置可以划分为4类：
Local(函数内部)局部作用域
Enclosing（嵌套函数的外层函数内部）嵌套作用域（闭包）
Global（模块全局）全局作用域
Built-in（内建）内建作用域
python解释器查找变量时，会按照顺序依次查找局部作用域--->嵌套作用域--->全局作用域--->内建作用域，在任意一个作用域中找到变量则停止查找，所有作用域查找完成没有找到对应的变量，则抛出 NameError: name 'xxxx' is not defined的异常。