迭代器-生成器

　　　　迭代器-生成器

　　楔子：

　　假如我现在有一个列表l=['a','b','c','d','e']，我想取列表中的内容，有几种方法？
　　首先，我们可以通过索引取值l[0]，其次我们是不是还可以用for循环来取值？
　　你有没有仔细考虑过，乜可以去到任意位置的值，前前提是你要知道这个值得在什么位置。
　　如果用for循环来取值，我们把每一个值都取到，不需要关心每个值的位置，因为只能循序的取值，并不能跳过任何一个直接去取值其他位置的值。
　　但你有没有想过，我们为什么使用for循环来取值？
　　for 循环内部是怎么工作的？

　　迭代器

　　python 中的for循环

　　要了解for循环是怎么回事，咱们还是要从代码的角度出发。
　　首先我们对一个列表进行for循环。
　　for i in [1,2,3,4]:
　　print（i）

　　上面这段代码肯定是没有问题的，但是我们换一种情况，来循环一个数字1234试试。

　　for i in 1234:
　　print(i)
　　输出：
　　Traceback (most recent call last):
　　File "test.py", line 4, in <module>
　　for i in 1234:
　　TypeError: 'int' object is not iterable

　　报错了，报了什么错？“TypeError: 'int' object is not iterable”，说int类型不是一个iterable，那这个iterable是个啥？
　　　iterable 翻译：可迭代的，可重复的，迭代的。

　　假如你不知道什么是iterable，我们可以翻译词典，首先得到一个中文的解释，尽管翻译过来了你可能也不知道，但是没关系，我会带着你一步一步来分析。

　　　　迭代和可迭代协议
　　什么叫迭代
　　现在，我们已经获得了一个新线索，有一个叫做“可迭代的”概念。
　　首先，我们从报错来分析，好像之所以1234不可以for循环，是因为它不可迭代。那么如果“可迭代”，就应该可以被for循环了。
　　这个我们知道，字符串，列表，元组，字典，集合都可被for循环，说明他们都是可迭代的。
　　我们怎么来证明这一点呢？
　　from collections import Iterable

　　l = [1,2,3,4]
　　t = (1,2,3,4)
　　d = {1:2,3:4}
　　s = {1,2,3,4}

　　print(isinstance(l,Iterable))
　　print(isinstance(t,Iterable))
　　print(isinstance(d,Iterable))
　　print(isinstance(s,Iterable))

　　输出：
　　True
　　True
　　True
　　True

　　结合我们使用的for循环取值的现象，再从字面上理解一下魔骑士迭代器就是我们刚刚说的，可以将某个数据集内的数据“一个挨着一个的取出来”，就叫做“迭代器”

　　可迭代的协议：
　　　　我们现在是从结果分析原因，能for循环的就是“可迭代的”，但是如果正着想，for怎么知道谁是可迭代的呢？
　　　　假如我们自己写了一个数据类型希望这个数据类型的东西也可以使用for被一个一个的取出来，那我们就必须满足for的要求，这个要求就叫做“协议”
　　　　可以被迭代要满足的要求就叫做可迭代协议。可迭代协议的定义非常简单，就是内部实现了——iter——方法。
　　接下来我们就来验证一下：
　　print(dir([1,2]))
　　print(dir((2,3)))
　　print(dir({1:2}))
　　print(dir({1,2}))

　　输出：
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']

　　总结一个我们现在所知道的：可以被for循环的都是可迭代的，要想可迭代，内部必须有一个——iter——方法。
　　接着分析__iter__方法做了什么事情？
　　print([1,2].__iter__())
　　输出：
　　<list_iterator object at 0x000000C3E6403A90>
　　执行了list（[1，2]）的——iter——方法，我们好像得到了一个list——iterator，现在又得到了一个新的名词--iterator。

　　　　iterator 翻译：迭代器，迭代程序。

　　iterator，这里给我们标出来了，是一个计算机中专属名词，叫做迭代器。

　　迭代器协议：
　　　　即什么叫“可迭代”之后，有一个历史新难题，什么叫“迭代器“？
　　　　虽然我们不着调什么叫迭代器，但是我们现在已经有一个迭代器了，这个迭代器就是一个列表的迭代器。

　　　　我们来看看这个列表的迭代器比起来列表来说实现了那些新方法，这样就能揭开迭代器的什么面纱了吧？

　　　　dir([1,2].__iter__()) #是列表迭代器中实现的所有方法，dir（[1,2]） 是列表中实现的所有方法，都是以列表的形式返回给我们，为了看的更清楚，我们分别把他们转换成结合，然后取差集。

　　#print(dir([1,2].__iter__()))
　　#print(dir([1,2]))
　　print(set(dir([1,2].__iter__()))-set(dir([1,2])))

　　输出：
　　{'__length_hint__', '__next__', '__setstate__'}

　　我们看到在列表迭代器中多了三种方法，那么这三个方法都分别做了什么事呢？
　　iter_l = [1,2,3,4,5,6].__iter__()
　　print(iter_l.__length_hint__())
　　print('*',iter_l.__setstate__(4))
　　print('**',iter_l.__next__())
　　print('***',iter_l.__next__())

　　输出：
　　6
　　* None
　　** 5
　　*** 6
　　这三种方法中，能让我们一个一个取值的神奇方方法是谁？
　　没错！就是__next__
　　正在for循环中就是在内部调用了__next__方法才能取到一个一个的值。
　　那接下来我们就用迭代器的next方法来写一个不依赖for的遍历。
　　l=[1,2,3,4]
　　l_iter = l.__iter__()
　　item = l_iter.__next__()
　　print(item)
　　item = l_iter.__next__()
　　print(item)
　　item = l_iter.__next__()
　　print(item)
　　item = l_iter.__next__()
　　print(item)
　　输出：
　　1
　　2
　　3
　　4

　　那现在我们就使用while循环实现了原本for循环做的事情，我们是从谁那儿获取一个一个的值呀？是不是就是l_iter？好了，这个l_iter就是一个迭代器。

　　迭代器遵循迭代器协议：必须拥有__iter__方法和__next__方法。

　　还账：next和iter方法

　　如此一来，关于迭代器和生成器的方法我们就还清了两个，最后我们来看看range()是个啥。首先，它肯定是一个可迭代的对象，但是它是否是一个迭代器？我们来测试一下

　　print('__next__' in dir(range(12))) #查看'__next__'是不是在range()方法执行之后内部是否有__next__
　　print('__iter__' in dir(range(12))) #查看'__next__'是不是在range()方法执行之后内部是否有__next__

　　from collections import Iterator
　　print(isinstance(range(100000000),Iterator)) #验证range执行之后得到的结果不是一个迭代器

　　为什么要有for循环

　　基于上面讲的列表这一大堆遍历方式，聪明的你立马看出了端倪，于是你不知死活的大声喊道，你这不逗我玩呢么，有了下标的访问方式，我可以这样遍历一个列表啊。

　　l = [1,2,3,]

　　index=0

　　while index <len(l):
　　print(l[index])
　　index += 1
　　#要毛线for循环，要毛线可迭代，要毛钱迭代器。

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

　　生成器

　　初始生成器：
　　一个包含yield关键字的函数就是一个生成器函数，yield可以为我们从函数中返回值，但是yield又不同于return，return的执行意味着程序的结束，调用生成器函数不会得到返回值具体的值，而却得到一个可迭代的对象，每一次获取这个可迭代对象的值，就能推动函数的执行，获取新的返回值。知道函数执行结束。

　　import time
　　def genrator_fun1():
　　a = 1
　　print('现在定义了a变量')
　　yield a
　　b = 2
　　print('现在又定义了b变量')
　　yield b

　　g1 = genrator_fun1()
　　print('g1 : ',g1) #打印g1可以发现g1就是一个生成器
　　print('-'*20) #我是华丽的分割线
　　print(next(g1))
　　time.sleep(1) #sleep一秒看清执行过程
　　print(next(g1))

　　生成器有什么好处呢？就是不会一下子在内存中生成太多数据
　　假如我想让工厂给做校服，生产20000000件衣服，我和工厂一说，工厂应该是先答应下来，然后再去生产，我可以一件一件的要，也可以根据学生一批一批的找工厂拿。
　　而不能是一说要生产20000000件衣服工厂就先去做生产20000000件衣服，等回来做好了，学生都毕业了。。
　　#初识生成器二

　　def produce():
　　"""生产衣服"""
　　for i in range(2000000):
　　yield "生产了第%s件衣服"%i

　　product_g = produce()
　　print(product_g.__next__()) #要一件衣服
　　print(product_g.__next__()) #再要一件衣服
　　print(product_g.__next__()) #再要一件衣服
　　num = 0
　　for i in product_g: #要一批衣服，比如5件
　　print(i)
　　num +=1
　　if num == 5:
　　break

　　#到这里我们找工厂拿了8件衣服，我一共让我的生产函数(也就是produce生成器函数)生产2000000件衣服。
　　#剩下的还有很多衣服，我们可以一直拿，也可以放着等想拿的时候再拿

　　更多应用：
　　import time

　　def tail(filename):
　　f = open(filename)
　　f.seek(0, 2) #从文件末尾算起
　　while True:
　　line = f.readline() # 读取文件中新的文本行
　　if not line:
　　time.sleep(0.1)
　　continue
　　yield line

　　tail_g = tail('tmp')
　　for line in tail_g:
　　print(line)

　　send：

　　def generator():
　　print(123)
　　content = yield 1
　　print('=======',content)
　　print(456)
　　yield2

　　g = generator()
　　ret = g.__next__()
　　print('***',ret)
　　ret = g.send('hello') #send的效果和next一样
　　print('***',ret)

　　#send 获取下一个值的效果和next基本一致
　　#只是在获取下一个值的时候，给上一yield的位置传递一个数据
　　#使用send的注意事项
　　# 第一次使用生成器的时候 是用next获取下一个值
　　# 最后一个yield不能接受外部的值

　　计算移动平均值：
　　def averager():
　　total = 0.0
　　count = 0
　　average = None
　　while True:
　　term = yield average
　　total += term
　　count += 1
　　average = total/count

　　g_avg = averager()
　　next(g_avg)
　　print(g_avg.send(10))
　　print(g_avg.send(30))
　　print(g_avg.send(5))

计算移动平均值(2)_预激协程的装饰器
　　def init(func): #在调用被装饰生成器函数的时候首先用next激活生成器
　　def inner(*args,**kwargs):
　　g = func(*args,**kwargs)
　　next(g)
　　return g
　　return inner

　　@init
　　def averager():
　　total = 0.0
　　count = 0
　　average = None
　　while True:
　　term = yield average
　　total += term
　　count += 1
　　average = total/count

　　g_avg = averager()
# next(g_avg) 在装饰器中执行了next方法
　　print(g_avg.send(10))
　　print(g_avg.send(30))
　　print(g_avg.send(5))

　　yield from
　　def gen1():
　　for c in 'AB':
　　yield c
　　for i in range(3):
　　yield i

　　print(list(gen1()))

　　def gen2():
　　yield from 'AB'
　　yield from range(3)

　　print(list(gen2()))

　　列表推导式和生成器表达式

　　#老男孩由于峰哥的强势加盟很快走上了上市之路,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))

总结：

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

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

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

而不用多此一举的先构造一个列表：
sum([x ** 2 for x in range(4)])

 

转载于:https://www.cnblogs.com/qingmu6/p/8952177.html