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