迭代器 生成器

一 什么是迭代器协议

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异常，以终止迭代

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

 

Python的Iterator对象表示的是一个数据流，Iterator对象能够被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。能够把这个数据流看作是一个有序序列，但咱们却不能提早知道序列的长度，只能不断经过next()函数实现按需计算下一个数据，因此Iterator的计算是惰性的，只有在须要返回下一个数据时它才会计算。

Iterator甚至能够表示一个无限大的数据流，例如全体天然数。而使用list是永远不可能存储全体天然数的。

小结

凡是可做用于for循环的对象都是Iterable类型；

凡是可做用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过能够经过iter()函数得到一个Iterator对象。

Python的for循环本质上就是经过不断调用next()函数实现的。

 

三 生成器

经过列表生成式，咱们能够直接建立一个列表。可是，受到内存限制，列表容量确定是有限的。并且，建立一个包含100万个元素的列表，不只占用很大的存储空间，若是咱们仅仅须要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

因此，若是列表元素能够按照某种算法推算出来，那咱们是否能够在循环的过程当中不断推算出后续的元素呢？这样就没必要建立完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要建立一个generator，有不少种方法。第一种方法很简单，只要把一个列表生成式的[]改为()，就建立了一个generator

什么是生成器？

能够理解为一种数据类型，这种数据类型自动实现了迭代器协议（其余的数据类型须要调用本身内置的__iter__方法），因此生成器就是可迭代对象

 

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

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

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

 

为什么使用生成器之生成器的优势

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

 

生成器小结：

1.是可迭代对象

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

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

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)
#演示只能日后不能往前
#演示蛋下完了，母鸡就死了

母鸡下蛋的传说

yield

 

 

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

• 语法上和函数相似：生成器函数和常规函数几乎是同样的。它们都是使用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__())#报错

使用迭代器

 

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

1. 使用生成器之后，代码行数更少。你们要记住，若是想把代码写的Pythonic，在保证代码可读性的前提下，代码行数越少越好
2. 不使用生成器的时候，对于每次结果，咱们首先看到的是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语句的时候，就遍历了咱们的生成器，当咱们再次遍历咱们的生成器的时候，将不会有任何记录。因此，上面的代码不会有任何输出。

所以，生成器的惟一注意事项就是：生成器只能遍历一次。

人口信息

View Code