python 第五章 迭代器，生成器，生成器函数

Posted 2021-01-03 xyx2018

迭代器

迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退，不过这也没什么，因为人们很少在迭代途中往后退。另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件

特点：
访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
不能随机访问集合中的某个值 ，只能从头到尾依次访问
访问到一半时不能往回退
便于循环比较大的数据集合，节省内存

 1 #!/usr/bin/env python
 2 # -*- coding:utf8 -*-
 3 
 4 l = [1,2,3]
 5 iter = l.__iter__() #遵迭代器协议，生成可迭代对象
 6 print(iter.__next__())
 7 print(iter.__next__())
 8 print(iter.__next__())
 9 #输出
10 1
11 2
12 3

for会自动将列表，字符串，字典，集合，元祖，文件，通过__iter__ 生成可迭代对象
然后通过__next__方法取值

 1 #!/usr/bin/env python
 2 # -*- coding:utf8 -*-
 3 
 4 """ for循环内部自动通过__iter__ 生成可迭代对象然后通过__next__方法取值 """
 5 l = [1,2,3]
 6 for i in l:
 7     print(i)
 8 #输出
 9 1
10 2
11 3

生成器
通过列表生成式，我们可以直接创建一个列表，但是，受到内存限制。列表容量肯定是有限的。而且，创建一个包含100万个元素
的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，哪后面绝大多数元素占用的空间就都白白浪费了、
所以，如果列表元素可以按照某种算法推算出来， 哪我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间，在python中这种循环一边计算的机制，称为生成器 generator
要创建一个 generator 有很多种方法，第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个 generator

 1 #!/usr/bin/env python
 2 # -*- coding:utf8 -*-
 3 
 4 L = [x*x for x in range(10)]
 5 print(L)
 6 #输出
 7 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 8 
 9 g = (x*x for x in range(10))  #生成器 generator
10 print(g)
11 #输出
12 <generator object <genexpr> at 0x000000000218D408>

创建L 和g 的区别在于最外层的[]和()，L是一个list g是一个 generator
我们可以直接打印出list的每一个元素，哪怎么打印出 generator的每一个元素
如果要一个一个打印出来 可以通过 next()函数获得 generator的下一个返回值；

 1 #!/usr/bin/env python
 2 # -*- coding:utf8 -*-
 3 
 4 """generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出错误"""
 5 
 6 g = (x*x for x in range(3))
 7 print(next(g))
 8 #输出
 9 0
10 
11 print(next(g))
12 #输出
13 1
14 
15 print(next(g))
16 #输出
17 4
18 
19 print(next(g)) #报错

当然上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象

 1 #!/usr/bin/env python
 2 # -*- coding:utf8 -*-
 3 
 4 """通过for循环"""
 5 
 6 g = (x*x for x in range(3))
 7 for n in g:
 8     print(n)
 9 #输出
10 0
11 1
12 4

所以我们创建了
一个generator后，基本上永远不会调用next() 而是通过for循环来迭代它，并且不需要关心 stopiteration错误
generator非常强大，如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现
比如斐波拉契数列 除第一个数和第二个数外，任意一个数都可以由前两个数相加得到：
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

 1 #!/usr/bin/env python
 2 # -*- coding:utf8 -*-
 3 
 4 """斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易"""
 5 
 6 def fib(max):
 7    n,a,b = 0,0,1
 8    while n < max:
 9        print(b)
10        a,b = b,a+b
11        n = n+1
12    return "done"
13 fib(10)
14 #输出
15 1
16 1
17 2
18 3
19 5
20 8
21 13
22 21
23 34
24 55

仔细观察可以看出，fib函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非常类似 generator也就是说上面的函数和generator 仅一步之遥，要把函数变成generator,只需要吧 print(b)改为 yield b 就可以了

 1 #!/usr/bin/env python
 2 # -*- coding:utf8 -*-
 3 
 4 def fid(max):
 5     n, a, b = 0, 0 ,1
 6     while n < max:
 7         yield b
 8         a,b =b, a+b
 9         n = n + 1
10     return "done"
11 print(list(fid(10)))
12 #输出
13 [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

这就是定义generator的另一种方式。

生成器函数
yield相当于return控制的是函数的返回值
yield的另一个特性，接受send传过来的值，赋值给x
send() 同next 但是括号里可以输入一个值 传给yield
vield 相当于return 但是可以使用多次

 1 #!/usr/bin/env python
 2 # -*- coding:utf8 -*-
 3 
 4 def test():
 5     yield 1
 6     yield 2
 7     yield 3
 8 g = test()
 9 print(g)
10 #输出
11 <generator object test at 0x000000000277D408>
12 
13 print(next(g))
14 #输出
15 1
16 
17 print(next(g))
18 #输出
19 2
20 
21 print(next(g))
22 #输出
23 3

如果一个函数定义中 包含yield 关键字，那么这个函数就是一个generator
这里最难理解的就是 generator和函数执行流程不一样，函数是顺序执行，遇到return语句或者最后一行函数语句就返回，而变成generator的函数，在每次调用 next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行

 1 #!/usr/bin/env python
 2 # -*- coding:utf8 -*-
 3  """举一个简单的例子 ，定义一个 generator ，依次返回数字 1， 3， 5"""
 4 
 5 def odd():
 6     print("step 1")
 7     yield 1
 8     print("step 2")
 9     yield (3)
10     print("steo 3")
11     yield (5)
12 print(odd())
13 #输出
14 <generator object odd at 0x000000000211D408>
15 
16 """调用该generator时，首先要生成一个generator对象，然后用next()函数不断获得下一个返回值："""
17 i = odd()
18 next(i)
19 #输出
20 step 1
21 1
22 
23 next(i)
24 #输出
25 step 2
26 3
27 
28 next(i)
29 #输出
30 step 3
31 5
32 next(i)
33 #输出
34 报错

可以看到，odd不是普通的函数，而是generator，在执行过程中，遇到 yield就中断，下次又继
续执行。执行三次yield后 已经没有yield 可以执行了，所以，第4次调用next(o)就报错同样的，把函数改成 generator后，我们基本上从来不会用next()来获取 下一个返回值，而是直接使用for循环来迭代；但是用for循环调用generator时，发现拿不到generator的return语句的返回值，如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

 1 #!/usr/bin/env python
 2 # -*- coding:utf8 -*-
 3 
 4 def fid(max):
 5     n, a, b = 0, 0 ,1
 6     while n < max:
 7         yield b
 8         a,b =b, a+b
 9         n = n + 1
10     return "done"
11 g = fid(6)
12 while True:
13     try:
14         x = next(g)
15         print(‘g‘,x)
16     except StopIteration as e:
17         print("Generator  return valur:", e.value)
18         break
19 
20 #输出
21 g 1
22 g 1
23 g 2
24 g 3
25 g 5
26 g 8
27 Generator  return valur: done

要理解 generator 的工作原理，它是在for循环的过程中不断计算出下一个元素，并在适当的条件
结束for循环，对于函数改成generator 来说 遇到return语句或者执行到函数体最后一行语句，就是结束generator、的指令 for循环随之结束。
请注意区分普通函数和generator函数，普通函数调用直接放回结果
generator函数调用实际返回一个generator对象