第五篇Python之迭代器与生成器
Posted chenyuting
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了第五篇Python之迭代器与生成器相关的知识，希望对你有一定的参考价值。
1、迭代和递归等概念
循环（loop）：指的是在满足条件的情况下，重复执行同一段代码。比如，while语句，for循环。
迭代（iterate）：指的是按照某种顺序逐个访问列表中的每一项。比如，for语句。Python中，迭代永远是取出元素本身，而非元素的索引。对于有序集合，元素确实是有索引的。使用 enumerate() 函数获得索引。
递归（recursion）：指的是一个函数不断调用自身的行为。比如，以编程方式输出著名的斐波纳契数列。
遍历（traversal）：指的是按照一定的规则访问树形结构中的每个节点，而且每个节点都只访问一次。
2、迭代器协议
1） 迭代器协议是指：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个StopIteration异常，以终止迭代 （只能往后走不能往前退）
2） 可迭代对象：实现了迭代器协议的对象（如何实现：对象内部定义一个__iter__()方法）
3） 协议是一种约定，可迭代对象实现了迭代器协议，python的内部工具（如for循环，sum，min，max函数等)使用迭代器协议访问对象。
注：可以通过__next__取值，就是迭代器（遵循迭代器协议生成的都是可迭代对象，迭代器就是可迭代对象）
l=["ye","ba","er","sun"] inter_l=l.__iter__() print(inter_l.__next__()) print(next(inter_l))
3、python中强大的for循环机制
for循环的本质：循环所有对象，全都是使用迭代器协议。
for循环的原理：基于迭代器协议提供了一个统一的可以遍历所有对象的方法，即在遍历之前，先调用对象的__iter__方法将其转换成一个迭代器，然后使用迭代器协议去实现循环访问，这样所有的对象就都可以通过for循环来遍历了。
列表，字符串，元组，字典，集合，文件对象等本质上来说都不是可迭代对象，在使用for循环的时候内部是先调用他们内部的_iter_方法，使他们变成了可迭代对象，然后在使用可迭代对象的_next_方法依次循环元素，当元素循环完时，会触发StopIteration异常，for循环会捕捉到这种异常，终止迭代。
访问方式常见的有下标方式访问、迭代器协议访问、for循环访问
l=[‘a‘,‘b‘,‘c‘] #一:下标访问方式 print(l[0]) print(l[1]) print(l[2]) # print(l[3])#超出边界报错:IndexError #二:遵循迭代器协议访问方式 diedai_l=l.__iter__() print(diedai_l.__next__()) print(diedai_l.__next__()) print(diedai_l.__next__()) # print(diedai_l.__next__())#超出边界报错:StopIteration #三:for循环访问方式 #for循环l本质就是遵循迭代器协议的访问方式,先调用diedai_l=l.__iter__()方法,或者直接diedai_l=iter(l),然后依次执行diedai_l.next(),直到for循环捕捉到StopIteration终止循环 #for循环所有对象的本质都是一样的原理 for i in l:#diedai_l=l.__iter__() print(i) #i=diedai_l.next() #四:用while去模拟for循环做的事情 diedai_l=l.__iter__() while True: try: print(diedai_l.__next__()) except StopIteration: print(‘迭代完毕了,循环终止了‘) break
4. for循环的作用
对于序列类型的对象可使用下标的访问方式，但是对于非序列类型（字典，集合，文件对象等），for循环提供了访问遍历机制。
l=[1,2,3] index=0 while index < len(l): print(l[index]) index+=1
while 需要加异常处理，for默认都已经内置。
文件默认就是迭代器：
f=open(‘a.txt‘,‘r‘) f.__next__ f.__iter__ print(f) print(f.__iter__()) for line in f: #f.__iter__() print(line) i=f.__iter__() while True: try: print(next(i)) except StopIteration: break
5.生成器初识
生成器的本质：
可以理解为一种数据类型，这种数据类型自动实现了迭代器协议（其他的数据类型需要调用自己内置的__iter__方法），所以生成器就是可迭代对象。
生成器分类及在python中的表现形式：（Python有两种不同的方式提供生成器）
1）生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
2）生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表
生成器的优点：
Python使用生成器对延迟操作提供了支持。所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果。这也是生成器的主要好处。
生成器小结：
1）是可迭代对象
2）现了延迟计算,省内存啊
3）生成器本质和其他的数据类型一样，都是实现了迭代器协议，只不过生成器附加了一个延迟计算省内存的好处，其余的可迭代对象可没有这点好处！！！
可迭代对象：只要对象本身有__iter__方法，那它就是可迭代的。 # 只有内置了iter方法就是可迭代的对象。
d={‘a‘:1,‘b‘:2,‘c‘:3}
d.__iter__() # iter(d)
执行对象下的__iter__方法，得到的结果就是迭代器 i=d.__iter__()
d={‘a‘:1,‘b‘:2,‘c‘:3}
i=iter(d)
while True:
try:
print(next(i))
except StopIteration: # StopIteration 不能叫做错误，是一个结束信号。
break
l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘] #列表也可以使用迭代器
i=iter(l) #i=l.__iter__()
while True:
try:
print(next(i))
except StopIteration:
break
d={‘a‘:1,‘b‘:2,‘c‘:3}
d.__iter__
for k in d: #d.__iter__() # for 循环
print(k)
s={1,2,3,4}
for i in s:
print(i)
为什么要用迭代器：
优点：
- 迭代器提供了一种不依赖于索引的取值方式，这样就可以遍历那些没有索引的可迭代对象了（字典，集合，文件）
- 迭代器与列表比较，迭代器是惰性计算的，更节省内存
缺点：
- 无法获取迭代器的长度，使用不如列表索引取值灵活
- 一次性的，只能往后取值，不能倒着取值
from collections import Iterable,Iterator s=‘hello‘ l=[1,2,3] t=(1,2,3) d={‘a‘:1} set1={1,2,3,4} f=open(‘a.txt‘) s.__iter__() l.__iter__() t.__iter__() d.__iter__() set1.__iter__() f.__iter__() # 都是可迭代的 print(isinstance(s,Iterable)) #True print(isinstance(l,Iterable)) #True print(isinstance(t,Iterable)) #True print(isinstance(d,Iterable)) #True print(isinstance(set1,Iterable)) #True print(isinstance(f,Iterable)) #True # 查看是否是迭代器 print(isinstance(s,Iterator)) #False print(isinstance(l,Iterator)) #False print(isinstance(t,Iterator)) #False print(isinstance(d,Iterator)) #False print(isinstance(set1,Iterator)) #False print(isinstance(f,Iterator)) #True
6、 生成器函数
e.send与next(e)的区别：
- 如果函数内yield是表达式形式，那么必须先next(e)
- 二者的共同之处是都可以让函数在上次暂停的位置继续运行，不一样的地方在于send在触发下一次代码的执行时，会顺便给yield传一个值。
def lay_eggs(num): egg_list=[] for egg in range(num): egg_list.append(‘蛋%s‘ %egg) return egg_list yikuangdan=lay_eggs(10) #我们拿到的是蛋 print(yikuangdan) def lay_eggs(num): for egg in range(num): res=‘蛋%s‘ %egg yield res print(‘下完一个蛋‘) laomuji=lay_eggs(10)#我们拿到的是一只母鸡 print(laomuji) print(laomuji.__next__()) print(laomuji.__next__()) print(laomuji.__next__()) egg_l=list(laomuji) print(egg_l) #演示只能往后不能往前 #演示蛋下完了，母鸡就死了
生成器与return有何区别？
return只能返回一次函数就彻底结束了，而yield能返回多次值。函数在暂停以及继续下一次运行时的状态是由yield保存。
yield把函数变成生成器-->迭代器
from collections import Iterator #生成器就是一个函数，这个函数内包含有yield这个关键字 def test(): print(‘one‘) yield 1 #return 1 print(‘two‘) yield 2 #return 2 print(‘three‘) yield 3 #return 2 print(‘four‘) yield 4 #return 2 print(‘five‘) yield 5 #return 2 g=test() print(g) print(isinstance(g,Iterator)) g.__iter__() # g.__next__() # res=next(g) # print(res) # # res=next(g) # print(res) # # res=next(g) # print(res) # # res=next(g) # print(res) for i in g: print(i)
next触发函数的运行。函数变成迭代器，有执行效果，同时可以向外拉值。next一下函数执行一下。
def countdown(n): print(‘start coutdown‘) while n > 0: yield n #1 n-=1 print(‘done‘) g=countdown(5) # print(g) # print(next(g)) # print(next(g)) # print(next(g)) # print(next(g)) # print(next(g)) # print(next(g)) # for i in g: #iter(g) # print(i) # while True: # try: # print(next(g)) # except StopIteration: # break # # def func(): # n=0 # while True: # yield n # n+=1 # # f=func() # print(next(f))
import time def tail(file_path): with open(file_path,‘r‘) as f: f.seek(0,2) while True: line=f.readline() if not line: time.sleep(0.3) continue else: # print(line) yield line tail(‘/tmp/a.txt‘)
#加颜色 g=tail(‘/tmp/a.txt‘) for line in g: if ‘error‘ in line: print(‘\\033[45m%s\\033[0m‘ %line)
#/usr/bin/env python import time #定义阶段：定义俩生成器函数 def tail(file_path): with open(file_path,‘r‘) as f: f.seek(0,2) while True: line=f.readline() if not line: time.sleep(0.3) # print(‘====>‘) continue else: #print(line,end=‘‘) yield line def grep(pattern,lines): for line in lines: if pattern in line: yield line #调用阶段：得到俩生成器对象 g1=tail(‘/tmp/a.txt‘) g2=grep(‘error‘,g1) #next触发执行g2生成器函数 for i in g2: print(i)
#如果在一个函数内部yield的使用方式是表达式形式的话，如x=yield，那么该函数成为协程函数 def eater(name): print(‘%s start to eat food‘ %name) food_list=[] while True: food=yield food_list print(‘%s get %s ,to start eat‘ %(name,food)) food_list.append(food) print(‘done‘) e=eater(‘钢蛋‘) # print(e) print(next(e)) print(e.send(‘包子‘)) print(e.send(‘韭菜馅包子‘)) print(e.send(‘大蒜包子‘)) #为什么叫协程？ #协程怎么用？
7、 生成器表达式（三元表达式）和列表解析
name=‘alex‘ name=‘linhaifeng‘ res=‘SB‘ if name == ‘alex‘ else ‘shuai‘ print(res)
egg_list=[‘鸡蛋%s‘ %i for i in range(10)] #列表解析 laomuji=(‘鸡蛋%s‘ %i for i in range(10)) #生成器表达式 print(laomuji) print(next(laomuji)) #next本质就是调用__next__ print(laomuji.__next__()) print(next(laomuji))
总结：
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。例如， sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和：
sum(x ** 2 for x in xrange(4))
而不用多此一举的先构造一个列表：
sum([x ** 2 for x in xrange(4)])
8、生成器总结
综上已经对生成器有了一定的认识，下面我们以生成器函数为例进行总结
- 语法上和函数类似：生成器函数和常规函数几乎是一样的。它们都是使用def语句进行定义，差别在于，生成器使用yield语句返回一个值，而常规函数使用return语句返回一个值
- 自动实现迭代器协议：对于生成器，Python会自动实现迭代器协议，以便应用到迭代背景中（如for循环，sum函数）。由于生成器自动实现了迭代器协议，所以，我们可以调用它的next方法，并且，在没有值可以返回的时候，生成器自动产生StopIteration异常
- 状态挂起：生成器使用yield语句返回一个值。yield语句挂起该生成器函数的状态，保留足够的信息，以便之后从它离开的地方继续执行
优点一：生成器的好处是延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这对于大数据量处理，将会非常有用。
sum([i for i in range(100000000)]) #列表解析：内存占用大,机器容易卡死 sum(i for i in range(100000000)) #生成器表达式：几乎不占内存
优点二：生成器还能有效提高代码可读性
def index_words(text): result = [] if text: result.append(0) for index, letter in enumerate(text, 1): if letter == ‘ ‘: result.append(index) return result print(index_words(‘hello alex da sb‘))
def index_words(text): if text: yield 0 for index, letter in enumerate(text, 1): if letter == ‘ ‘: yield index g=index_words(‘hello alex da sb‘) print(g) print(g.__next__()) print(g.__next__()) print(g.__next__()) print(g.__next__()) print(g.__next__())#报错
这里，至少有两个充分的理由说明 ，使用生成器比不使用生成器代码更加清晰：
- 使用生成器以后，代码行数更少。大家要记住，如果想把代码写的Pythonic，在保证代码可读性的前提下，代码行数越少越好
- 不使用生成器的时候，对于每次结果，我们首先看到的是result.append(index)，其次，才是index。也就是说，我们每次看到的是一个列表的append操作，只是append的是我们想要的结果。使用生成器的时候，直接yield index，少了列表append操作的干扰，我们一眼就能够看出，代码是要返回index。
合理使用生成器，能够有效提高代码可读性。只要大家完全接受了生成器的概念，理解了yield语句和return语句一样，也是返回一个值。那么，就能够理解为什么使用生成器比不使用生成器要好，能够理解使用生成器真的可以让代码变得清晰易懂。生成器只（迭代）遍历一次，如需要重复读取，需要保存数据，再次获取。
人口信息.txt文件内容 {‘name‘:‘北京‘,‘population‘:10} {‘name‘:‘南京‘,‘population‘:100000} {‘name‘:‘山东‘,‘population‘:10000} {‘name‘:‘山西‘,‘population‘:19999} def get_provice_population(filename): with open(filename) as f: for line in f: p=eval(line) #提取出来的line都是字符串形式，需要使用eval提取起数据结构 yield p[‘population‘] gen=get_provice_population(‘人口信息.txt‘) all_population=sum(gen) for p in gen: print(p/all_population) 执行上面这段代码，将不会有任何输出，这是因为，生成器只能遍历一次。在我们执行sum语句的时候，就遍历了我们的生成器，当我们再次遍历我们的生成器的时候，将不会有任何记录。所以，上面的代码不会有任何输出。 因此，生成器的唯一注意事项就是：生成器只能遍历一次。
def test(): for i in range(4): yield i g=test() g1=(i for i in g) g2=(i for i in g1) print(list(g1)) print(list(g2))
def add(n,i): return n+i def test(): for i in range(4): yield i g=test() for n in [1,10]: g=(add(n,i) for i in g) print(list(g))
import os def init(func): def wrapper(*args,**kwargs): g=func(*args,**kwargs) next(g) return g return wrapper @init def list_files(target): while 1: dir_to_search=yield for top_dir,dir,files in os.walk(dir_to_search): for file in files: target.send(os.path.join(top_dir,file)) @init def opener(target): while 1: file=yield fn=open(file) target.send((file,fn)) @init def cat(target): while 1: file,fn=yield for line in fn: target.send((file,line)) @init def grep(pattern,target): while 1: file,line=yield if pattern in line: target.send(file) @init def printer(): while 1: file=yield if file: print(file) g=list_files(opener(cat(grep(‘python‘,printer())))) g.send(‘/test1‘)
【参考文档】
python基础之迭代器协议和生成器：https://www.cnblogs.com/luchuangao/p/6685626.html
迭代器协议和生成器：https://www.cnblogs.com/chenice/articles/6135714.html
以上是关于第五篇Python之迭代器与生成器的主要内容，如果未能解决你的问题，请参考以下文章