python基础之迭代器协议和生成器
迭代器和生成器补充：http://www.cnblogs.com/luchuangao/p/6847081.html
一 递归和迭代
略
二 什么是迭代器协议
1.迭代器协议是指：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个StopIteration异常，以终止迭代 （只能往后走不能往前退）
2.可迭代对象：实现了迭代器协议的对象（如何实现：对象内部定义一个__iter__()方法）
3.协议是一种约定，可迭代对象实现了迭代器协议，python的内部工具（如for循环，sum，min，max函数等)使用迭代器协议访问对象。
注：可以通过__next__取值，就是迭代器
三 python中强大的for循环机制
for循环的本质：循环所有对象，全都是使用迭代器协议。
正本清源：
很多人会想，for循环的本质就是遵循迭代器协议去访问对象，那么for循环的对象肯定都是迭代器了啊，没错，那既然这样，for循环可以遍历（字符串，列表，元组，字典，集合，文件对象），那这些类型的数据肯定都是可迭代对象啊？但是，我他妈的为什么定义一个列表l=[1,2,3,4]没有l.next()方法，打脸么。
(字符串，列表，元组，字典，集合，文件对象）这些都不是可迭代对象，只不过在for循环式，调用了他们内部的__iter__方法，把他们变成了可迭代对象
然后for循环调用可迭代对象的__next__方法去取值，而且for循环会捕捉StopIteration异常，以终止迭代
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
四 为何要有for循环
基于上面讲的列表的三种访问方式，聪明的你立马看除了端倪，于是你不知死活大声喊道，你这不逗我玩呢么，有了下标的访问方式，我可以这样遍历一个列表啊
l=[1,2,3] index=0 while index < len(l): print(l[index]) index+=1 #要毛线for循环，要毛线for循环，要毛线for循环
没错，序列类型字符串，列表，元组都有下标，你用上述的方式访问，perfect！但是你可曾想过非序列类型像字典，集合，文件对象的感受，所以嘛，年轻人，for循环就是基于迭代器协议提供了一个统一的可以遍历所有对象的方法，即在遍历之前，先调用对象的__iter__方法将其转换成一个迭代器，然后使用迭代器协议去实现循环访问，这样所有的对象就都可以通过for循环来遍历了，而且你看到的效果也确实如此，这就是无所不能的for循环，觉悟吧，年轻人
五 生成器初探
什么是生成器？
可以理解为一种数据类型，这种数据类型自动实现了迭代器协议（其他的数据类型需要调用自己内置的__iter__方法），所以生成器就是可迭代对象
生成器分类及在python中的表现形式：（Python有两种不同的方式提供生成器）
1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表
为何使用生成器之生成器的优点
Python使用生成器对延迟操作提供了支持。所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果。这也是生成器的主要好处。
生成器小结：
1.是可迭代对象
2.实现了延迟计算,省内存啊
3.生成器本质和其他的数据类型一样，都是实现了迭代器协议，只不过生成器附加了一个延迟计算省内存的好处，其余的可迭代对象可没有这点好处，记住喽！！！
列表循环：
l=['a','b','c','d','e']
i=0
while i < len(l):
print(l[i])
i+=1
for i in range(len(l)):
print(l[i])
集合和字典不是序列，没有下标，不能通过索引取值，这就用到了迭代器的原因之一。
可迭代对象：只要对象本身有__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
# for 循环
d={'a':1,'b':2,'c':3}
d.__iter__
for k in d: #d.__iter__()
print(k)
s={1,2,3,4}
for i in s:
print(i)
补充：try 监控 except捕捉，捕捉错误信息得。
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
为什么要用迭代器：
优点：
- 迭代器提供了一种不依赖于索引的取值方式，这样就可以遍历那些没有索引的可迭代对象了（字典，集合，文件）
- 迭代器与列表比较，迭代器是惰性计算的，更节省内存
缺点：
- 无法获取迭代器的长度，使用不如列表索引取值灵活
- 一次性的，只能往后取值，不能倒着取值
l=[1,2,3]
print(len(l))
i=iter(l)
print(next(i))
print(next(i))
print(next(i))
for x in i:
print(x)
# for x in i:
# print(x)
查看是不是字符串类型：
>>> type('aaa') is str
True
>>> isinstance('aaa',str)
True
>>>
#判断是不是字符串类型
查看可迭代对象与迭代器对象：
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))
print(isinstance(l,Iterable))
print(isinstance(t,Iterable))
print(isinstance(d,Iterable))
print(isinstance(set1,Iterable))
print(isinstance(f,Iterable))
# 查看是否是迭代器
print(isinstance(s,Iterator))
print(isinstance(l,Iterator))
print(isinstance(t,Iterator))
print(isinstance(d,Iterator))
print(isinstance(set1,Iterator))
print(isinstance(f,Iterator))
六 生成器函数
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到底干了什么事情：
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))
应用1：
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)
应用2：
#/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('大蒜包子'))
#为什么叫协程？
#协程怎么用？
七 生成器表达式和列表解析
#三元表达式 name='alex' name='linhaifeng' res='SB' if name == 'alex' else 'shuai' print(res)
#老男孩由于峰哥的强势加盟很快走上了上市之路,alex思来想去决定下几个鸡蛋来报答峰哥 egg_list=['鸡蛋%s' %i for i in range(10)] #列表解析 #峰哥瞅着alex下的一筐鸡蛋,捂住了鼻子,说了句:哥,你还是给我只母鸡吧,我自己回家下 laomuji=('鸡蛋%s' %i for i in range(10))#生成器表达式 print(laomuji) print(next(laomuji)) #next本质就是调用__next__ print(laomuji.__next__()) print(next(laomuji)) 峰哥与alex的故事
总结：
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。例如， sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和：
sum(x ** 2 for x in xrange(4))
而不用多此一举的先构造一个列表：
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))#几乎不占内存
优点二：生成器还能有效提高代码可读性
#求一段文字中，每个单词出现的位置 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) yield p['population'] gen=get_provice_population('人口信息.txt') all_population=sum(gen) for p in gen: print(p/all_population) 执行上面这段代码，将不会有任何输出，这是因为，生成器只能遍历一次。在我们执行sum语句的时候，就遍历了我们的生成器，当我们再次遍历我们的生成器的时候，将不会有任何记录。所以，上面的代码不会有任何输出。 因此，生成器的唯一注意事项就是：生成器只能遍历一次。
#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' 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') 协程应用：grep -rl /dir
