- 闭包：一个持有外部环境变量的函数就是闭包；闭包是一个能够访问其他函数作用域的函数
'''
简化写法
'''
def multipliers():
return [lambda x: i * x for i in range(4)]
print([m(2) for m in multipliers()])
'''
拆分一下
'''
# 拆分 multipliers()第一步：
def multipliers():
ls = [] #列表表达是拆分方法
for i in range(4): #lambda x:i*x 调用了上一层函数multipliers()的局部命名空间的变量i
ret = lambda x: i * x #这里还可以拆分
ls.append(ret)
print(i) #打印3
return ls #返回的是局部变量，不是闭包
# 拆分 multipliers()第二步：
def multipliers():
ls = []
for i in range(4):
def inner(x): #定义 inner函数使用了multipliers()的局部命名空间的变量i
return x*i
ret = inner
ls.append(ret)
print(i) #打印3
return ls #返回了函数
#加一个便于理解的代码
for i in range(4):
pass
print(i) #打印3
ret = []
for m in multipliers():
ret.append(m(2))
print (ret) # 打印 [6, 6, 6, 6]
print(multipliers()[0](2)) #打印6
'''
从python解释器开始执行之后，就在内存中开辟了一个空间，每当遇到一个变量的时候，就把变量名和值之间的对应关系记录下来。
但是当遇到函数定义的时候解释器只是象征性的将函数名读入内存，表示知道这个函数的存在了，至于函数内部的变量和逻辑解释器根本不关心。
等执行到函数调用的时候，python解释器会再开辟一块内存来存储这个函数里的内容，这个时候，才关注函数里面有哪些变量，
而函数中的变量会存储在新开辟出来的内存中。函数中的变量只能在函数的内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。
'''
'''
只有当调用闭包函数的时候它才会去引用外层函数的变量，因为在调用闭包函数之前，闭包内部的命名空间还不存在。
所以multipliers的里面存放了四个函数，当去调用的时候，for i in range(4)这个循环已经执行完毕，此时的i已经是3了，新开辟的命名空间里面的i就是3了
'''
- 顺便加一个装饰器
def wrapper(func):
def inner(request):
print('start wrapper')
r = func(request) #inner函数使用了外部的func参数，所以也是一个闭包
print('end wrapper')
return r
return inner
- 字典推导式
name = ["张三", "李四", "王五", "李六"]
sign = ["白羊座", "双鱼座", "狮子座", "处女座"]
dict1 = {i : j for i, j in zip(name, sign)} # {'张三': '白羊座', '李四': '双鱼座', '王五': '狮子座', '李六': '处女座'}
- 列表推导式（2个for循环）
nums = [[1, 3, 5, 7], [2, 4, 6, 8]]
# 使上述nums中的每个数字都取出来，放到一个新列表中，用到2个for循环
new_nums = []
for nums_a in nums:
# print(nums_a)
for i in nums_a:
new_nums.append(i)
print("new_nums的值为：{}".format(new_nums))
# 列表推导式
new_num = [i for nums_a in nums for i in nums_a]
# 从左至右，分别是外层循环到内层循环;先把里面的2个小列表遍历一遍，然后再遍历每个小列表的数字；
# 最后的表示结果的变量，写在最左侧
print("new_num的值为：{}".format(new_num))
