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

为什么要用迭代器：
优点：

1. 迭代器提供了一种不依赖于索引的取值方式，这样就可以遍历那些没有索引的可迭代对象了（字典，集合，文件）
2. 迭代器与列表比较，迭代器是惰性计算的，更节省内存

缺点：

1. 无法获取迭代器的长度，使用不如列表索引取值灵活
2. 一次性的，只能往后取值，不能倒着取值

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)的区别：

1. 如果函数内yield是表达式形式，那么必须先next(e)
2. 二者的共同之处是都可以让函数在上次暂停的位置继续运行，不一样的地方在于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)
#演示只能往后不能往前
#演示蛋下完了，母鸡就死了

母鸡下蛋的传说

母鸡下蛋的传说