Python全栈开发之---迭代器、可迭代对象、生成器

1、什么叫迭代

现在，我们已经获得了一个新线索，有一个叫做“可迭代的”概念。

首先，我们从报错来分析，好像之所以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))

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

2、迭代器和协议

既什么叫“可迭代”之后，又一个历史新难题，什么叫“迭代器”？

虽然我们不知道什么叫迭代器，但是我们现在已经有一个迭代器了，这个迭代器是一个列表的迭代器。

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

 '''
 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__())

这三个方法中，能让我们一个一个取值的神奇方法是谁？

没错！就是__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)
 item = l_iter.__next__()
 print(item)

这是一段会报错的代码，如果我们一直取next取到迭代器里已经没有元素了，就会抛出一个异常StopIteration，告诉我们，列表中已经没有有效的元素了。

这个时候，我们就要使用异常处理机制来把这个异常处理掉。

 l = [1,2,3,4]
 l_iter = l.__iter__()
 while True:
     try:
         item = l_iter.__next__()
         print(item)
     except StopIteration:
         break

3、可迭代对象

我们现在是从结果分析原因，能被for循环的就是“可迭代的”，但是如果正着想，for怎么知道谁是可迭代的呢？

假如我们自己写了一个数据类型，希望这个数据类型里的东西也可以使用for被一个一个的取出来，那我们就必须满足for的要求。这个要求就叫做“协议”。

可以被迭代要满足的要求就叫做可迭代协议。可迭代协议的定义非常简单，就是内部实现了__iter__方法。

迭代器生成的对象就是可迭代对象

4、生成器

Python中提供的生成器：

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

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

生成器Generator：

　　本质：迭代器(所以自带了__iter__方法和__next__方法，不需要我们去实现)

　　特点：惰性运算,开发者自定义

 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))

 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不能接受外部的值

 #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()))

 yield from