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

1、什么叫迭代

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

首先，我们从报错来分析，好像之所以1234不可以for循环，是因为它不可迭代。那么如果“可迭代”，就应该可以被for循环了。

这个我们知道呀，字符串、列表、元组、字典、集合都可以被for循环，说明他们都是可迭代的。

我们怎么来证明这一点呢？

 1 from collections import iterable
 2                              
 3 l = [1,2,3,4]                
 4 t = (1,2,3,4)                
 5 d = {1:2,3:4}                
 6 s = {1,2,3,4}                
 7                              
 8 print(isinstance(l,iterable))
 9 print(isinstance(t,iterable))
10 print(isinstance(d,iterable))
11 print(isinstance(s,iterable))

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

2、迭代器和协议

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

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

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

 1 '''
 2 dir([1,2].__iter__())是列表迭代器中实现的所有方法，dir([1,2])是列表中实现的所有方法,都是以列表的形式返回给我们的，为了看的更清楚，我们分别把他们转换成集合，
 3 然后取差集。
 4 '''
 5 #print(dir([1,2].__iter__()))
 6 #print(dir([1,2]))
 7 print(set(dir([1,2].__iter__()))-set(dir([1,2])))
 8 
 9 结果：
10 {'__length_hint__', '__next__', '__setstate__'}
11 
12 
13 iter_l = [1,2,3,4,5,6].__iter__()
14 #获取迭代器中元素的长度
15 print(iter_l.__length_hint__())
16 #根据索引值指定从哪里开始迭代
17 print('*',iter_l.__setstate__(4))
18 #一个一个的取值
19 print('**',iter_l.__next__())
20 print('***',iter_l.__next__())

 

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

没错！就是__next__

在for循环中，就是在内部调用了__next__方法才能取到一个一个的值。

那接下来我们就用迭代器的next方法来写一个不依赖for的遍历。

 1 l = [1,2,3,4]
 2 l_iter = l.__iter__()
 3 item = l_iter.__next__()
 4 print(item)
 5 item = l_iter.__next__()
 6 print(item)
 7 item = l_iter.__next__()
 8 print(item)
 9 item = l_iter.__next__()
10 print(item)
11 item = l_iter.__next__()
12 print(item)

 

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

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

1 l = [1,2,3,4]
2 l_iter = l.__iter__()
3 while true:
4     try:
5         item = l_iter.__next__()
6         print(item)
7     except stopiteration:
8         break

 

3、可迭代对象

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

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

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

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

4、生成器

python中提供的生成器：

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

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

 

生成器generator：

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

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

 1 import time
 2 def genrator_fun1():
 3     a = 1
 4     print('现在定义了a变量')
 5     yield a
 6     b = 2
 7     print('现在又定义了b变量')
 8     yield b
 9 
10 g1 = genrator_fun1()
11 print('g1 : ',g1)       #打印g1可以发现g1就是一个生成器
12 print('-'*20)   #我是华丽的分割线
13 print(next(g1))
14 time.sleep(1)   #sleep一秒看清执行过程
15 print(next(g1))

 

 1 def generator():
 2     print(123)
 3     content = yield 1
 4     print('=======',content)
 5     print(456)
 6     yield2
 7 
 8 g = generator()
 9 ret = g.__next__()
10 print('***',ret)
11 ret = g.send('hello')   #send的效果和next一样
12 print('***',ret)
13 
14 #send 获取下一个值的效果和next基本一致
15 #只是在获取下一个值的时候，给上一yield的位置传递一个数据
16 #使用send的注意事项
17     # 第一次使用生成器的时候 是用next获取下一个值
18     # 最后一个yield不能接受外部的值

 1 #yield from
 2 
 3 def gen1():
 4     for c in 'ab':
 5         yield c
 6     for i in range(3):
 7         yield i
 8 
 9 print(list(gen1()))
10 
11 def gen2():
12     yield from 'ab'
13     yield from range(3)
14 
15 print(list(gen2()))
16 
17 yield from