python 生成器与迭代器

1.列表生成式

需求：将列表[0，1，2，3，4，5，6，7，8，9]的每一个元素加1

方法一：

#Author:Anliu
a = [0,2,3,4,5,6,7,8,9]
b = []
for i in a:b.append(i+1)
a=b
print(a)

方法二：

#Author:Anliu
a = [0,2,3,4,5,6,7,8,9]
for index,i in enumerate(a):
    a[index] +=1
print(a)

方法三：

a = [i+1 for i in range(10)]
print(a)

这就叫做列表生成式

2.生成器

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

#Author:Anliu
list1 = [x*x for x in range(10)]
print(list1)
list2 = (x*x for x in range(10))
print(list2)

输出结果：
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
<generator object <genexpr> at 0x000002E1CAEC1E60>

创建list1和list2的区别仅在于最外层的[]和()，list1是一个list，而list2是一个generator。

我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

#Author:Anliu
list1 = [x*x for x in range(10)]
print(list1)
list2 = (x*x for x in range(10))
print(list2)
print(list2.__next__())
print(list2.__next__())
print(list2.__next__())
print(list2.__next__())

输出结果：
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
<generator object <genexpr> at 0x0000023CB58E1E60>
0
1
4
9

我们讲过，generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

  File "K:/pyprogram/generator_test/list_test2.py", line 16, in <module>
1
    print(list2.__next__())
4
StopIteration

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

#Author:Anliu
list1 = [x*x for x in range(10)]
print(list1)
list2 = (x*x for x in range(10))
print(list2)

for i in list2:
    print(i)

所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误。

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。

比如，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：

#Author:Anliu
def fib(max):
    n,a,b = 0,0,1
    while n < max:
        print(b)
        a,b = b,a+b
        n = n+1
    return "down"
fib(10)

输出结果：

1
1
2
3
5
8
13
21
34
55

仔细观察，可以看出，fib函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非常类似generator。

也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只需要把print(b)改为yield b就可以了：

#Author:Anliu
def fib(max):
    n,a,b = 0,0,1
    while n < max:
        #print(b)
        yield b
        a,b = b,a+b
        n = n+1
    return "down"
f = fib(10)
print(f)

输出结果：

<generator object fib at 0x00000238EF531E60>

这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：

这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

#Author:Anliu
def fib(max):
    n,a,b = 0,0,1
    while n < max:
        #print(b)
        yield b
        a,b = b,a+b
        n = n+1
    return "down"
f = fib(10)
print(f)

print(f.__next__())
print(f.__next__())
print(f.__next__())
print("出去玩玩")
print(f.__next__())
print(f.__next__())
print("外面有病毒")
print(f.__next__())
print(f.__next__())
print("不太好吧")
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())

输出结果：

Traceback (most recent call last):
<generator object fib at 0x000002424E651E60>
   File "K:/pyprogram/generator_test/fiebonaqi.py", line 26, in <module>
     print(f.__next__())
1
StopIteration: down
1
2
出去玩玩
3
5
外面有病毒
8
13
不太好吧
21
34
55

在上面fib的例子，我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。

同样的，把函数改成generator后，我们基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：

#Author:Anliu
def fib(max):
    n,a,b = 0,0,1
    while n < max:
        #print(b)
        yield b
        a,b = b,a+b
        n = n+1
    return "down"
f = fib(10)
print(f)
for i in f:
    print(i)

输出结果：

<generator object fib at 0x0000025955241E60>
1
1
2
3
5
8
13
21
34
55

但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

#Author:Anliu
def fib(max):
    n,a,b = 0,0,1
    while n < max:
        #print(b)
        yield b
        a,b = b,a+b
        n = n+1
    return "down"
f = fib(10)
print(f)

while True:
    try:
        x = next(f)
        print("g:",x)
    except StopIteration as e:
        print("Generator return values:",e.value)
        break

输出结果：

<generator object fib at 0x000001D22EC11E60>
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
g: 13
g: 21
g: 34
g: 55
Generator return values: down

示例：还可通过yield实现在单线程的情况下实现并发运算的效果　　

#Author:Anliu
import time
def consumer(name):
    print("%s 开始消费" %name)
    while True:
        mess = yield
        print("消息%s来了，被%s消费了"%(mess,name))

c = consumer("runrun")
c.__next__()

def producer(name):
    c1 = consumer("runrun")
    c2 = consumer("quanquan")
    c1.__next__()
    c2.__next__()
    print("%s 开始准备消息"%name)
    for i in range(10):
        time.sleep(1)
        print("今天下雨")
        c1.send(i)
        c2.send(i)

producer("xiaozhi")

输出结果：

runrun 开始消费
runrun 开始消费
quanquan 开始消费
xiaozhi 开始准备消息
今天下雨
消息0来了，被runrun消费了
消息0来了，被quanquan消费了
今天下雨
消息1来了，被runrun消费了
消息1来了，被quanquan消费了
今天下雨
消息2来了，被runrun消费了
消息2来了，被quanquan消费了
今天下雨
消息3来了，被runrun消费了
消息3来了，被quanquan消费了
今天下雨
消息4来了，被runrun消费了
消息4来了，被quanquan消费了
今天下雨
消息5来了，被runrun消费了
消息5来了，被quanquan消费了
今天下雨
消息6来了，被runrun消费了
消息6来了，被quanquan消费了
今天下雨
消息7来了，被runrun消费了
消息7来了，被quanquan消费了
今天下雨
消息8来了，被runrun消费了
消息8来了，被quanquan消费了
今天下雨
消息9来了，被runrun消费了
消息9来了，被quanquan消费了

3. 迭代器

我们已经知道，可以直接作用于for循环的数据类型有以下几种：

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。

可以使用isinstance()判断一个对象是否是Iterable对象：

#Author:Anliu
from collections import Iterable
print(isinstance([],Iterable))
print(isinstance({},Iterable))
print(isinstance("123",Iterable))
print(isinstance((),Iterable))
print(isinstance(set(),Iterable))

而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

*可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

可以使用isinstance()判断一个对象是否是Iterator对象：

#Author:Anliu
from collections import Iterator
print(isinstance((x for x in range(10)),Iterator))
print(isinstance([],Iterator))
print(isinstance({},Iterator))
print(isinstance((),Iterator))

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用iter()函数：

from collections import Iterator
print(isinstance((x for x in range(10)),Iterator))
print(isinstance([],Iterator))
print(isinstance({},Iterator))
print(isinstance((),Iterator))
print(isinstance(iter(()),Iterator))
print(isinstance(iter([]),Iterator))
print(isinstance(iter({}),Iterator))

为什么list、dict、str等数据类型不是Iterator？

这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

4. 小结

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:
    pass

完全等价于：

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break