python 闭包迭代器生成器列表和生成器推导式详解
Posted 胖虎是只mao
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python 闭包迭代器生成器列表和生成器推导式详解相关的知识，希望对你有一定的参考价值。
一、函数名的运用（第一类对象）
函数名是一个变量，但它是一个特殊的变量，与括号配合可以执行函数的变量。
1，函数名的内存地址
def func():
print("呵呵")
print(func) # 结果为：<function func at 0x00000000029299D8> 打印出func的内存地址
2，函数名可以赋值给其他变量
def func():
print("呵呵")
a = func # 把函数当成一个变量赋值给另一个变量
a() # 函数调用 func()
3，函数名可以当做容器类的元素
def func1():
print("呵呵")
def func2():
print("呵呵")
def func3():
print("呵呵")
lst = [func1 , func2 , func3]
for i in lst:
i() # 通过for循环依次执行三个函数
4，函数名可以当做函数的参数
要想在一个函数体内部 调用另一个外部的函数，可以用此方法
def func():
print("吃了么")
def func2(fn):
print("我是func2")
fn() # 执行传递过来的fn
print("我是func2")
func2(func) # 把函数名func当成参数传递给func2的参数fn
5，函数名可以作为函数的返回值
def func_1():
print("这里是函数1")
def func_2():
print("这里是函数2")
print("这里是函数1")
return func_2
fn = func_1()
# 执行函数1，函数1返回的是函数2，这时fn指向的就是上面函数2
# 结果为：
# 这里是函数1
# 这里是函数1
fn() # 执行上面返回的函数2
# 结果为：
# 这里是函数2
二、闭包
什么是闭包？闭包就是内层函数对外层函数（非全局）的变量的引用（重要，实际项目中可用到），如下示例：
def func():
a = 10
def inner():
print(a) # 闭包
inner()
func() # 结果为：10
我们可以用__closure__来检测函数是不是闭包，函数名.__closure__返回cell就是闭包，返回None就不是闭包。
def func():
a = 10
def inner():
print(a)
inner()
print(inner.__closure__) # (<cell at 0x00000000025875B8: int object at 0x0000000058E26D40>,)
func()
问题：如何在函数外边调用内部函数呢？（重要，实际项目中可用到）具体示例如下：
def outer():
a = 'hello'
# 内部函数
def inner():
print(a)
return inner
fn = outer() # 访问外部函数，获取到内部函数的内存地址
fn() # 访问内部函数
那如果多层嵌套呢？很简单，只需要一层一层的往外层返回就行了，具体示例如下：
def func1():
def func2():
def func3():
print("嘿嘿")
return func3
return func2
func1()()() # 执行func3，结果为：嘿嘿
由它我们可以引出闭包的好处，由于我们在外界可以访问内部函数，那这个时候内部函数访问的时间和时机就不一定了，因为在外部，我可以选择在任意的时间去访问内部函数，这个时候，想一想，我们之前说过，如果一个函数执行完毕，则这个函数中的变量以及局部命名空间中内容将会被销毁，在闭包中，如果变量被销毁了，那内部函数将不能正常执行，所以，python规定：如果你在内部函数中访问了外层函数中的变量，那么这个变量将不会消亡，将会常驻在内存中，也就是说，使用闭包，可以保证外层函数中的变量在内存中常驻。(重要，实际项目中使用)这样做有什么好处呢？有非常大的好处，下面来看一个简单的关于爬虫的代码：
from urllib.request import urlopen
def but():
content = urlopen("http://www.xiaohua100.cn/index.html").read()
def get_content():
return content
return get_content
fn = but() # 这个时候就开始加载校花100的内容
# 后面需要用到这里面的内容就不需要再执行非常耗时的网络连接操作了
content = fn() # 获取内容
print(content)
content2 = fn() # 重新获取内容
print(content2)
综上可得：闭包的作用就是让一个变量能够常驻内存，供后面的程序使用。
闭包补充：有如下代码示例：
def func():
a = "hello"
def inner():
print(a)
return inner
func()() # 耗时，因为想要执行内层函数inner就要先执行一遍外层函数func，没有用到闭包的好处：外层函数变量常驻内存
fn = func() # 先执行外层函数func，因为是闭包，所以外层函数变量a常驻内存
fn() # 直接执行内层函数inner，用到了闭包的好处，并且后面程序随时可以直接通过fn()执行内层函数,而不用执行外层函数
以上是 func()()和 fn = func() ; fn()区别
三，迭代器
我们之前一直在用可迭代对象进行迭代操作，那么到底什么是可迭代对象？首先我们先回顾一下目前我们所熟知的可迭代对象有哪些，有str，list，tuple，dict，set，那为什么我们可以称它们为可迭代对象呢？因为它们都遵循了可迭代协议，什么是可迭代协议？首先我们看下面一段错误代码：
# 正确
s = 'abc'
for c in s:
print(c)
# 错误
for i in 123:
print(i)
# 结果：
# Traceback (most recent call last):
# File "E:/pythonDemo/1-basis/test10.py", line 107, in <module>
# for i in 123:
# TypeError: 'int' object is not iterable
注意看报错信息中有这样一句话：‘int’ object is not iterable，翻译过来就是整数类型对象是不可迭代的，iterable表示可迭代的，表示可迭代协议，那么如何进行验证你的数据类型是否符合可迭代协议，我们可以通过dir函数来查看类中定义好的所有方法。具体示例如下：
s = "我的哈哈哈"
print(dir(s)) # 可以打印对象中的方法和函数
print(dir(str)) # 也可以打印类中声明的方法和函数
在打印结果中，寻找__iter__，如果能找到，那么这个类的对象就是一个可迭代对象。我们发现在字符串中可以找到__iter__，继续看一下list，tuple，dict，set，具体如下：
print(dir(list))
print(dir(tuple))
print(dir(dict))
print(dir(set))
print(dir(open("test9.py"))) # 文件对象
我们发现这几个可以进行for循环的东西都有__iter__函数，包括range也有，可以自己试一下。
综上可知，通过寻找__iter__可以查看一个对象是否是可迭代对象，除此之外，我们还可以通过isinstence()函数来查看一个对象是什么类型的，具体示例如下：
ls = [1,2,3]
ls_iter = ls.__iter__() # 获取列表ls的迭代器
from collections import Iterable
from collections import Iterator
print(isinstance(ls,Iterable)) # True ls是可迭代对象的一个实例
print(isinstance(ls,Iterator)) # False ls不是迭代器的一个实例
print(isinstance(ls_iter,Iterable)) # True ls_iter是可迭代对象的一个实例
print(isinstance(ls_iter,Iterator)) # True ls_iter是迭代器的一个实例
综上，我们可以确定，如果对象中有__iter__函数，那么我们认为这个对象遵守了可迭代协议，就可以获取到相应的迭代器，上面代码中的__iter__就是帮我们获取到对象的迭代器，我们使用迭代器中的__next__()来获取到一个迭代器中的元素，那么我们之前讲的for循环的工作原理到底是什么呢？继续看下面代码：
s = "我爱北京天安门"
c = s.__iter__() # 获取迭代器
print(c.__next__()) # 使用迭代器进行迭代，获取一个元素：我
print(c.__next__()) # 爱
print(c.__next__()) # 北
print(c.__next__()) # 京
print(c.__next__()) # 天
print(c.__next__()) # 安
print(c.__next__()) # 门
print(c.__next__()) # StopIteration
for循环如下：
for i in [1,2,3]:
print(i)
下面使用while循环+迭代器来模拟for循环（必须要掌握）：
lst = [1,2,3]
lst_iter = lst.__iter__()
while 1:
try:
i = lst_iter.__next__()
print(i)
except StopIteration:
break
总结：
Iterable：可迭代对象，内部包含__iter__()函数，不包含__next__()函数；
Iterator：迭代器，内部包含__iter__()函数，同时包含__next__()函数；
-
1）可迭代对象包含迭代器。
-
2）如果一个对象拥有__iter__方法，其是可迭代对象；如果一个对象拥有next方法，其是迭代器。
-
3）定义可迭代对象，必须实现__iter__方法；定义迭代器，必须实现__iter__和next方法。
迭代器特点：
1，节省内存（下篇生成器中介绍）； 2，惰性机制（遇到__next__才取一个）； 3，不能反复，只能向下执行；我们可以把要迭代的内容当成子弹，然后呢，获取到迭代器
__iter__()，就把子弹都装在弹夹中，然后发射就是__next__()把每一个子弹（元素）打出来，也就是说，for循环的时候，一开始是__iter__()来获取迭代器，后面每次获取元素都是通过__next__()来完成的，当程序遇到StopIteration将结束循环。
三者简要关系图：
四、生成器
什么是生成器？生成器的实质就是迭代器。
生成器的特点和迭代器一样，取值方式也和迭代器一样。
生成器一般由生成器函数或者生成器表达式来创建，生成器其实就是手写的迭代器。
在python中有三种方式来获取生成器：
1 ，通过生成器函数获取生成器；
2，通过各种推导式来实现生成器；
3，通过生成器表达式来创建生成器；
五、生成器函数
首先，我们先看一个很简单的函数，如下：
def func():
print("111")
return 222
ret = func()
print(ret)
# 结果为：
# 111
# 222
将上面函数中的return换成yield就是生成器，如下示例：
def func():
print("111")
yield 222
ret = func()
print(ret)
# 结果为：<generator object func at 0x0000000002793CA8>
可以看出运行结果和上面不一样，为什么呢？由于函数中存在了yield，那么这个函数就是一个生成器函数。这个时候，我们再执行这个函数的时候，就不再是函数的执行了，而是获取这个生成器。如何使用呢？想想迭代器，生成器的本质是迭代器，所以，我们可以直接执行__next__()来执行以下生成器，如下代码示例：
def func():
print("111")
yield 222
gener = func() # 这个时候函数不会执行，而是获取到生成器
ret = gener.__next__() # 这个时候才会执行，yield的作用和return一样，也是返回数据
print(ret)
# 结果为：
# 111
# 222
那么我们可以看到，yield和return的效果是一样的，有什么区别呢？yield是分段来执行一个函数，return是直接停止执行函数。
当程序运行完最后一个yield，那么后面继续进行__next__()程序会报错，具体如下代码示例：
def func():
print("111")
yield 222
print("222")
yield 444
gener = func()
ret = gener.__next__()
print(ret)
ret2 = gener.__next__()
print(ret2)
ret3 = gener.__next__()
print(ret3)
# 结果为：
# 111
# Traceback (most recent call last):
# 222
# File "E:/pythonDemo/1-basis/test13.py", line 50, in <module>
# 222
# 444
# ret3 = gener.__next__()
# StopIteration
好了生成器说完了，生成器有什么作用呢？我们来看这样一个需求，学校向JACK JONES订购10000套学生服，JACK JONES就比较实在，直接造出来10000套衣服，如下代码：
def cloth():
lst = []
for i in range(10000):
lst.append("衣服"+str(i))
return lst
cl = cloth()
但是呢，问题来了，学校现在没有这么多学生，一次性给学校这么多，该往哪里放，很尴尬啊！最好的效果是什么样呢？我要1套，你给我1套，一共10000套，是不是最完美的。如下代码：
def cloth():
for i in range(10000):
yield "衣服"+str(i)
cl = cloth()
print(cl.__next__())
print(cl.__next__())
print(cl.__next__())
print(cl.__next__())
分析：第一种是直接一次性全部拿出来，会很占用内存，第二种使用生成器，一次就一个，用多少生成多少，生成器是一个一个的指向下一个，不会回去，__next__()到哪，指针就指到哪儿，下一次继续获取指针指向的值。
接下来我们来看send()方法，send和__next__()一样都可以让生成器执行到下一个yield，如下代码：
def eat():
print("我吃什么啊")
a = yield "馒头"
print("a=",a)
b = yield "大饼"
print("b=",b)
c = yield "韭菜盒子"
print("c=",c)
yield "GAME OVER"
gen = eat() # 获取生成器
ret1 = gen.__next__()
print(ret1)
ret2 = gen.send("胡辣汤")
print(ret2)
ret3 = gen.send("狗粮")
print(ret3)
ret4 = gen.send("猫粮")
print(ret4)
send()和__next__()的区别：
1，send()和__next__()都是让生成器向下走一次；
2，send()可以给上一个yield的位置传递值，不能给最后一个yield发送值，在第一次执行生成器代码的时候不能使用send()。
生成器可以使用for循环来循环获取内部的元素：
def func():
print(111)
yield 222
print(333)
yield 444
print(555)
yield 666
gen = func()
for i in gen:
print(i)
# 结果为：
# 111
# 222
# 333
# 444
# 555
# 666
六，推导式、生成器表达式
首先我们先看一下这样的代码，给出一个列表，通过循环，向列表中添加1-13:，代码如下：
lst = []
for i in range(1,14):
lst.append(i)
print(lst)
将上面替换成列表推导式，如下：
lst = [i for i in range(1,14)]
print(lst)
列表推导式是通过一行来构建你要的列表，列表推导式看起来代码简单，但是出现错误之后很难排查。
列表推导式的常用写法：[结果 for 变量 in 可迭代对象]
例：从python1期到python15期写入列表lst，代码如下：
lst = ["python%s" % i for i in range(1,16)]
print(lst)
我们还可以对列表中的数据进行筛选：筛选模式：[结果 for 变量 in 可迭代对象 if条件]，具体如下例：
# 获取1-100内所有偶数
lst = [i for i in range(1,101) if i % 2 == 0]
print(lst)
生成器表达式和列表推导式的语法基本上是一样的，只是把[]替换成()，具体如下：
gen = (i for i in range(10))
print(gen) # 结果为：<generator object <genexpr> at 0x00000000021F3E60>
可以看到打印的结果就是一个生成器，我们可以使用for循环来循环这个生成器，具体如下：
gen = ("麻花藤我第%s次爱你" % i for i in range(10))
for i in gen:
print(i)
生成器表达式也可以进行筛选，具体如下：
# 获取1-100内能被3整除的数
gen = (i for i in range(1,100) if i % 3 == 0)
for num in gen:
print(num)
# 100以内能被3整除的数的平方
gen = (i * i for i in range(100) if i % 3 == 0)
for num in gen:
print(num)
# 寻找名字中带有两个e的人的名字
names = [
['Tom','Billy','Jefferson','Andrew','Wesley','Steven'],
['Alice','Jill','Ana','Wendy','Jennifer','Sherry','Eva']
]
# 不用推导式和表达式
result = []
for first in names:
for name in first:
if name.count("e") == 2:
result.append(name)
print(result)
# 生成器表达式
gen = (name for first in names for name in first if name.count("e") == 2)
for name in gen:
print(name)
总结：
生成器表达式和列表推导式的区别：
1，列表推导式比较耗内存，一次性加载，生成器表达式几乎不占用内存，使用的时候才分配和使用内存；
2，得到的值不一样，列表推导式得到的是一个列表，生成器表达式获取的是一个生成器；
举个栗子：同样一篮子鸡蛋，列表推导式：直接拿到一篮子鸡蛋；生成器表达式：拿到一个老母鸡，需要鸡蛋就给你下鸡蛋。
生成器的惰性机制：生成器只有在访问的时候才取值，说白了，你找他要他才给你值，不找他要，他是不会执行的。
def func():
print(111)
yield 222
g = func() # 生成器g
g1 = (i for i in g) # 生成器g1，但是g1的数据来源于g
g2 = (i for i in g1) # 生成器g2，数据来源于g1
print(list(g)) # 获取g中的数据，这时func()才会被执行，打印111，获取到222，g完毕
print(list(g1)) # 获取g1中的数据，g1的数据来源是g，但是g已经取完了，g1也就没有数据了
print(list(g2)) # 和g1同理
深坑：生成器，要值的时候才拿值！
字典推导式：根据名字应该也能猜到，推导出来的是字典，具体如下：
# 把字典中的key和value互换
dic = {'a':1,"b":2}
new_dic = {v:k for k,v in dic.items()}
print(new_dic)
# 在以下list中，从lst1中获取的数据和lst2中相对应的位置的数据组成一个新字典
lst1 <以上是关于python 闭包迭代器生成器列表和生成器推导式详解的主要内容，如果未能解决你的问题，请参考以下文章