Python学习之路8?迭代器协议和生成器

Posted 2020-09-21

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python学习之路8?迭代器协议和生成器相关的知识，希望对你有一定的参考价值。

一什么是迭代器协议

1.迭代器协议是指：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个StopIteration异常，以终止迭代（只能往后走不能往前退）

2.可迭代对象：实现了迭代器协议的对象（如何实现：对象内部定义一个__iter__()方法）

3.协议是一种约定，可迭代对象实现了迭代器协议，python的内部工具（如for循环，sum，min，max函数等)使用迭代器协议访问对象。

二 python中强大的for循环机制

for循环的本质：循环所有对象，全都是使用迭代器协议。

正本清源：

很多人会想，for循环的本质就是遵循迭代器协议去访问对象，那么for循环的对象肯定都是迭代器了啊，没错，那既然这样，for循环可以遍历（字符串，列表，元组，字典，集合，文件对象），那这些类型的数据肯定都是可迭代对象啊？但是，我他妈的为什么定义一个列表l=[1,2,3,4]没有l.next()方法，打脸么。

(字符串，列表，元组，字典，集合，文件对象）这些都不是可迭代对象，只不过在for循环式，调用了他们内部的__iter__方法，把他们变成了可迭代对象

然后for循环调用可迭代对象的__next__方法去取值，而且for循环会捕捉StopIteration异常，以终止迭代

 1 l=[‘a‘,‘b‘,‘c‘]
 2 #一:下标访问方式
 3 print(l[0])
 4 print(l[1])
 5 print(l[2])
 6 # print(l[3])#超出边界报错:IndexError
 7 
 8 #二:遵循迭代器协议访问方式
 9 diedai_l=l.__iter__()
10 print(diedai_l.__next__())
11 print(diedai_l.__next__())
12 print(diedai_l.__next__())
13 # print(diedai_l.__next__())#超出边界报错:StopIteration
14 
15 #三:for循环访问方式
16 #for循环l本质就是遵循迭代器协议的访问方式,先调用diedai_l=l.__iter__()方法,或者直接diedai_l=iter(l),然后依次执行diedai_l.next(),直到for循环捕捉到StopIteration终止循环
17 　 #for循环所有对象的本质都是一样的原理
18 
19 for i in l:#diedai_l=l.__iter__()
20     print(i) #i=diedai_l.next()
21 
22 #四:用while去模拟for循环做的事情
23 diedai_l=l.__iter__()
24 while True:
25     try:
26         print(diedai_l.__next__())
27     except StopIteration:
28         print(‘迭代完毕了,循环终止了‘)
29         break

三为何要有for循环

基于上面讲的列表的三种访问方式，一定会想有了下标的访问方式，我可以这样遍历一个列表啊

1 l=[1,2,3]
2 
3 index=0
4 while index < len(l):
5     print(l[index])
6     index+=1
7 
8 #要毛线for循环，要毛线for循环，要毛线for循环

没错，序列类型字符串，列表，元组都有下标，你用上述的方式访问，perfect！但是你可曾想过非序列类型像字典，集合，文件对象的感受，所以嘛，for循环就是基于迭代器协议提供了一个统一的可以遍历所有对象的方法，即在遍历之前，先调用对象的__iter__方法将其转换成一个迭代器，然后使用迭代器协议去实现循环访问，这样所有的对象就都可以通过for循环来遍历了，这就是无所不能的for循环

四生成器初探

什么是生成器？

可以理解为一种数据类型，这种数据类型自动实现了迭代器协议（其他的数据类型需要调用自己内置的__iter__方法），所以生成器就是可迭代对象

生成器分类及在python中的表现形式：（Python有两种不同的方式提供生成器）

1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行

2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表

为何使用生成器之生成器的优点

Python使用生成器对延迟操作提供了支持。所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果。这也是生成器的主要好处。

生成器小结：

1.是可迭代对象

2.实现了延迟计算,省内存啊

3.生成器本质和其他的数据类型一样，都是实现了迭代器协议，只不过生成器附加了一个延迟计算省内存的好处，其余的可迭代对象可没有这点好处，记住喽！！！

五生成器函数

 1 def lay_eggs(num):
 2     egg_list=[]
 3     for egg in range(num):
 4         egg_list.append(‘蛋%s‘ %egg)
 5     return egg_list
 6 
 7 yikuangdan=lay_eggs(10) #我们拿到的是蛋
 8 print(yikuangdan)
 9 
10 
11 def lay_eggs(num):
12     for egg in range(num):
13         res=‘蛋%s‘ %egg
14         yield res
15         print(‘下完一个蛋‘)
16 
17 laomuji=lay_eggs(10)#我们拿到的是一只母鸡
18 print(laomuji)
19 print(laomuji.__next__())
20 print(laomuji.__next__())
21 print(laomuji.__next__())
22 egg_l=list(laomuji)
23 print(egg_l)
24 #演示只能往后不能往前
25 #演示蛋下完了，母鸡就死了

母鸡下蛋的传说

六生成器表达式和列表解析

1 #三元表达式
2 name=‘alex‘
3 name=‘linhaifeng‘
4 res=‘SB‘ if name == ‘alex‘ else ‘shuai‘
5 print(res)

 1 #lxh的公司由于yyp的强势加盟很快走上了上市之路,lxh思来想去决定下几个鸡蛋来报答yyp
 2 
 3 egg_list=[‘鸡蛋%s‘ %i for i in range(10)] #列表解析
 4 
 5 #yyp瞅着lxh下的一筐鸡蛋,摇了摇头,说了句:哥,你还是给我只母鸡吧,我自己回家下
 6 
 7 laomuji=(‘鸡蛋%s‘ %i for i in range(10))#生成器表达式
 8 print(laomuji)
 9 print(next(laomuji)) #next本质就是调用__next__
10 print(laomuji.__next__())
11 print(next(laomuji))

两个人男人之间的故事

总结：

1.把列表解析的[]换成()得到的就是生成器表达式

2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存

3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。例如， sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和：

1 sum(x ** 2 for x in xrange(4))

而不用多此一举的先构造一个列表：

1 sum([x ** 2 for x in xrange(4)])

七生成器总结

综上已经对生成器有了一定的认识，下面我们以生成器函数为例进行总结

语法上和函数类似：生成器函数和常规函数几乎是一样的。它们都是使用def语句进行定义，差别在于，生成器使用yield语句返回一个值，而常规函数使用return语句返回一个值
自动实现迭代器协议：对于生成器，Python会自动实现迭代器协议，以便应用到迭代背景中（如for循环，sum函数）。由于生成器自动实现了迭代器协议，所以，我们可以调用它的next方法，并且，在没有值可以返回的时候，生成器自动产生StopIteration异常
状态挂起：生成器使用yield语句返回一个值。yield语句挂起该生成器函数的状态，保留足够的信息，以便之后从它离开的地方继续执行

优点一：生成器的好处是延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这对于大数据量处理，将会非常有用。

1 #列表解析
2 sum([i for i in range(100000000)])#内存占用大,机器容易卡死
3 
4 #生成器表达式
5 sum(i for i in range(100000000))#几乎不占内存

优点二：生成器还能有效提高代码可读性

 1 #求一段文字中，每个单词出现的位置
 2 def index_words(text):
 3     result = []
 4     if text:
 5         result.append(0)
 6     for index, letter in enumerate(text, 1):
 7         if letter == ‘ ‘:
 8             result.append(index)
 9     return result
10 
11 print(index_words(‘hello alex da sb‘))

不使用迭代器

 1 #求一段文字中每个单词出现的位置
 2 def index_words(text):
 3     if text:
 4         yield 0
 5     for index, letter in enumerate(text, 1):
 6         if letter == ‘ ‘:
 7             yield index
 8 
 9 g=index_words(‘hello alex da sb‘)
10 print(g)
11 print(g.__next__())
12 print(g.__next__())
13 print(g.__next__())
14 print(g.__next__())
15 print(g.__next__())#报错

使用迭代器

这里，至少有两个充分的理由说明，使用生成器比不使用生成器代码更加清晰：

使用生成器以后，代码行数更少。大家要记住，如果想把代码写的Pythonic，在保证代码可读性的前提下，代码行数越少越好
不使用生成器的时候，对于每次结果，我们首先看到的是result.append(index)，其次，才是index。也就是说，我们每次看到的是一个列表的append操作，只是append的是我们想要的结果。使用生成器的时候，直接yield index，少了列表append操作的干扰，我们一眼就能够看出，代码是要返回index。

这个例子充分说明了，合理使用生成器，能够有效提高代码可读性。只要大家完全接受了生成器的概念，理解了yield语句和return语句一样，也是返回一个值。那么，就能够理解为什么使用生成器比不使用生成器要好，能够理解使用生成器真的可以让代码变得清晰易懂。

注意事项：生成器只能遍历一次（母鸡一生只能下一定数量的蛋，下完了就死掉了）

 1 人口信息.txt文件内容
 2 {‘name‘:‘北京‘,‘population‘:10}
 3 {‘name‘:‘南京‘,‘population‘:100000}
 4 {‘name‘:‘山东‘,‘population‘:10000}
 5 {‘name‘:‘山西‘,‘population‘:19999}
 6 
 7 def get_provice_population(filename):
 8     with open(filename) as f:
 9         for line in f:
10             p=eval(line)
11             yield p[‘population‘]
12 gen=get_provice_population(‘人口信息.txt‘)
13 
14 all_population=sum(gen)
15 for p in gen:
16     print(p/all_population)
17 执行上面这段代码，将不会有任何输出，这是因为，生成器只能遍历一次。在我们执行sum语句的时候，就遍历了我们的生成器，当我们再次遍历我们的生成器的时候，将不会有任何记录。所以，上面的代码不会有任何输出。
18 
19 因此，生成器的唯一注意事项就是：生成器只能遍历一次。

 1 import os
 2 
 3 def init(func):
 4     def wrapper(*args,**kwargs):
 5         g=func(*args,**kwargs)
 6         next(g)
 7         return g
 8     return wrapper
 9 
10 @init
11 def list_files(target):
12     while 1:
13         dir_to_search=yield
14         for top_dir,dir,files in os.walk(dir_to_search):
15             for file in files:
16                 target.send(os.path.join(top_dir,file))
17 @init
18 def opener(target):
19     while 1:
20         file=yield
21         fn=open(file)
22         target.send((file,fn))
23 @init
24 def cat(target):
25     while 1:
26         file,fn=yield
27         for line in fn:
28             target.send((file,line))
29 
30 @init
31 def grep(pattern,target):
32     while 1:
33         file,line=yield
34         if pattern in line:
35             target.send(file)
36 @init
37 def printer():
38     while 1:
39         file=yield
40         if file:
41             print(file)
42 
43 g=list_files(opener(cat(grep(‘python‘,printer()))))
44 
45 g.send(‘/test1‘)
46 
47 协程应用：grep -rl /dir

协程应用

总结：yield的功能是什么？

1.yield是为函数定制__iter__和__next__方法，就是提供一种自定义迭代器的优雅的方法

2.就相当于return，但是可以返回多次

3.生成器本质就是一个数据流，next（生成器）才触发生成器函数的一次执行，下一次next会从上一次暂停的位置继续执行，直到重新遇到一个新的yield。

八迭代器

#迭代：更新换代描述的是一个重复的过程 for while

 1 lis=[4,5,6]
 2 i=0
 3 while i<len(lis):
 4     print(lis[i])
 5     i+=1
 6 
 7 for i in range(len(lis)):
 8     print(lis[i])
 9 
10 #输出结果：
11 4
12 5
13 6
14 4
15 5
16 6

针对没有下标的数据类型，我们在想迭代他们的话，就必须提供一种不按照下标取值的方式，python针对这种情况，已经为很多很多的数据类型内置了一个__iter__的方法

1 d={‘a‘:1,‘b‘:2}
2 print(d.__iter__())
3 print([].__iter__())
4 #输出结果：
5 <dict_keyiterator object at 0x000000000214B728>
6 <list_iterator object at 0x0000000002859400>

数据类型凡是有__iter__方法的都是可迭代的iterable，执行这个方法得到结果就是迭代器iterator，凡是iterator都内置一个__next__方法

 1 d={‘a‘:1,‘b‘:2}
 2 i=d.__iter__()
 3 print(i)
 4 print(i.__next__())
 5 print(i.__next__())
 6 print(i.__next__())
 7 
 8 输出结果：
 9 <dict_keyiterator object at 0x000000000220B778>
10 a
11 b
12     print(i.__next__())
13 StopIteration               #这个不是报错是字典没有值了

迭代的认识（针对列表）

 1 l=[1,2,3,4,5]
 2 i=iter(l)
 3 while l:
 4     try:
 5         print(next(i)) #i.__next__()
 6     except StopIteration as e:
 7         break
 8 
 9 for i in l:#l.__iter__()
10     print(i)
11     
12 #输出结果：
13 1
14 2
15 3
16 4
17 5
18 1
19 2
20 3
21 4
22 5

迭代器牛逼之处：针对没有下边的数据类型：（字典，文件等）

字典：

 1 dic={‘a‘:1,‘b‘:2,‘c‘:3}
 2 d=iter(dic)
 3 while d:
 4     try:
 5         print(dic[next(d)])
 6     except StopIteration:
 7         break
 8 
 9 for i in dic:
10     print(dic[i])
11 
12 # 输出结果：
13 1
14 2
15 3
16 1
17 2
18 3

文件：

1 f=open(‘text‘,‘r‘)
2 print(f)
3 for i in f: #i=f.__iter__()
4     print(i)
5 
6 输出结果：
7 <_io.TextIOWrapper name=‘text‘ mode=‘r‘ encoding=‘cp936‘>
8 yyp
9 sy

for，while之所以能够循环字典，文件，是因为内置用了迭代器的方法

迭代器的优点：

1.提供了一种统一的迭代方式

2.惰性计算，省内存

迭代器的缺点：

1.迭代器看起来就像是一个序列，但是你永远无法预知迭代器的长度

2.不能倒着走，而且是一次性的，只能走一遍

迭代器（Iterator），可迭代的（Iterable）

 1 from collections import Iterator,Iterable
 2 print(isinstance(‘zzl‘,Iterable))
 3 print(isinstance({},Iterable))
 4 print(isinstance((),Iterable))
 5 
 6 print(isinstance({}.__iter__(),Iterator))
 7 f=open(‘text‘,‘r‘)
 8 print(isinstance(f,Iterator))
 9 print(isinstance(f,Iterable))
10 
11 输出结果：
12 True
13 True
14 True
15 True
16 True
17 True