python入门20180717-迭代器、生成器和协程

迭代器、生成器和协程

python中任意的对象，只要它定义了可以返回一个迭代器的__iter__方法，或者支持下标索引的_getitem_方法，那么它就是一个可迭代对象。

可迭代的对象不一定就是迭代器；

比如：一个列表L=[1,2,3]是一个可迭代对象，但不是迭代器，l=iter(L)返回的是迭代器；

In [17]: L = [1,2,3,4]
 
In [18]: l = iter(L)
 
In [19]: next(l)
Out[19]: 1
 
In [20]: next(l)
Out[20]: 2
 
In [21]: l.__next__()
Out[21]: 3
 
In [22]: l.__next__()
Out[22]: 4
 
In [23]: l.__next__()
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-23-731686253790> in <module>()
----> 1 l.__next__()
 
StopIteration: 

什么是迭代器呢？

实现了__iter__和next的方法的对象就是迭代器，其中，__iter__方法但会迭代器对象本身，next方法返回容器的下一个元素，在没有后续元素时抛出StopIteration异常；

在python2中要定义的next方法名字不同，应该是__next__

为什么有了可迭代对象，还要有迭代器？

因为可迭代对象，是全部获取，占用内存；也是因为使用迭代器更通用，更简单、优雅；

迭代器可以用list函数转换为一个列表；

In [5]: class Fib:
   ...:     def __init__(self,max):
   ...:         self.a = 0
   ...:         self.b = 1
   ...:         self.max = max
   ...:
   ...:     def __iter__(self):
   ...:         return self
   ...:
   ...:     def __next__(self):
   ...:         fib = self.a
   ...:         if fib > self.max:
   ...:             raise StopIteration
   ...:         self.a,self.b = self.b,self.a + self.b
   ...:         return fib
   ...:     
 
In [6]: f = Fib(100)
 
In [7]: for i in f:
   ...:     print(i)
   ...:
0
1
1
2
3
5
8
13
21
34
55
89

In [45]: f.next()
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-45-297e922ec2d6> in <module>()
----> 1 f.next()

AttributeError: 'Fib' object has no attribute 'next'

In [46]: next(f)
Out[46]: 0

In [47]: next(f)
Out[47]: 1

In [48]: next(f)
Out[48]: 1

In [51]: f.__next__()

Out[51]: 2

In [52]: f.__next__()

Out[52]: 3

In [8]: list(Fib(100))             #迭代器可以用list函数转换为一个列表；
Out[8]: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

生成器

生成器是一种使用普通函数语法定义的迭代器。生成器和普通函数的区别是使用yield，而不是return返回值。

yield 中文有生产、产生的意思；

yield每次返回一个结果，在每个结果的中间会挂起函数；挂起函数的状态便于下次从离开的地方继续；生成器本质上也是迭代器；

对于 Python 生成器中的 yield 来说，yield item 这行代码会产出一个值，提供给 next(...) 的调用方；此外，还会作出让步，暂停执行生成器，让调用方继续工作，直到需要使用另一个值时再调用next()；调用方会从生成器中拉取值。

生成器表达式

In [24]: g = (i for i in range(10) if i%2)   #生成器表达式
 
In [25]: g
Out[25]: <generator object <genexpr> at 0x7f2db837a620>
 
In [26]: for i in g:
    ...:     print(i)
    ...:
1
3
5
7
9

In [37]: g = (i for i in range(10) if i%2)

In [38]: g.next()
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-38-7dbbdfed0980> in <module>()
----> 1 g.next()

AttributeError: 'generator' object has no attribute 'next'

In [39]: g
Out[39]: <generator object <genexpr> at 0x7f2dbb968570>

In [40]: next(g)
Out[40]: 1

In [41]: next(g)
Out[41]: 3

In [42]: next(g)
Out[42]: 5

从句法上看，协程与生成器类似，都是定义体中包含 yield 关键字的函数。可是，在协程中，yield 通常出现在表达式的右边（例如，datum = yield），可以产出值，也可以不产出——如果 yield关键字后面没有表达式，那么生成器产出 None。协程可能会从调用方接收数据，不过调用方把数据提供给协程使用的是 .send(datum) 方法，而不是 next(...) 函数。通常，调用方会把值推送给协程。

yield 关键字甚至还可以不接收或传出数据。不管数据如何流动，yield 都是一种流程控制工具，使用它可以实现协作式多任务：协程可以把控制器让步给中心调度程序，从而激活其他的协程。

从根本上把 yield 视作控制流程的方式 ，这样就好理解协程了。

来看个例子：

n [27]: def coroutine2(a):
    ...:     print(f'Start: {a}')
    ...:     b = yield a
    ...:     print(f'Received: b = {b}')
    ...:     c = yield a + b
    ...:     print(f'Received: c = {c}')
    ...:     
 
In [28]: coro = coroutine2(1)
 
In [29]: next(coro)   #最先调用 next(my_coro) 函数 这一步通常称为 “预激”（prime）协程 （即，让协程向前执行到第一个 yield 表达式，准备好作为活跃的协程使用）
Start: 1
Out[29]: 1
 
In [30]: coro.send(2)
Received: b = 2
Out[30]: 3
 
In [31]: coro.send(10)
Received: c = 10
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-31-7a1f101c1ec1> in <module>()
----> 1 coro.send(10)
 
StopIteration: 

协程可以身处四个状态中的一个：

当前状态可以使用inspect.getgeneratorstate(...) 函数确定，该函数会返回下述字符串中的一个。

GEN_CREATED	等待开始执行
GEN_RUNNING	解释器正在执行
GEN_SUSPENDED	在 yield 表达式处暂停
GEN_CLOSED	执行结束

因为 send 方法 的参数 会成为暂停的 yield 表达式的值 ，所以，仅当协程处于暂停状态时才能调用 send 方法，例如 my_coro.send(10)。不过，如果协程还没激活（即，状态是 'GEN_CREATED'），情况就不同了。因此，始终要调用 next(my_coro) 激活协程——也可以调用my_coro.send(None)，效果一样。

最先调用 next(my_coro) 函数 这一步通常称为 “预激”（prime）协程 （即，让协程向前执行到第一个 yield 表达式，准备好作为活跃的协程使用）。

如果创建协程对象后立即把 None 之外的值发给它，会出现下述错误：

In [32]: coro2 = coroutine2(1)
 
In [33]: coro2.send(121)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-33-25e001dbff4a> in <module>()
----> 1 coro2.send(121)
 
TypeError: can't send non-None value to a just-started generator
 
In [34]: coro2.send(None)
Start: 1
Out[34]: 1

关键的一点是， 协程在 yield 关键字所在的位置暂停执行 。前面说过， 在赋值语句中， = 右边的代码在赋值之前执行 。因此，对于 b =yield a 这行代码来说，等到客户端代码再激活协程时才会设定 b 的值。这种行为要花点时间才能习惯，不过一定要理解，这样才能弄懂异步编程中 yield 的作用。

simple_coro2 协程的执行过程分为 3 个阶段，如图下图所示。

(1) 调用 next(my_coro2)，打印第一个消息，然后执行 yield a，产 出数字 14。

(2) 调用 my_coro2.send(28)，把 28 赋值给 b，打印第二个消息，然 后执行 yield a + b，产出数字 42。

(3) 调用 my_coro2.send(99)，把 99 赋值给 c，打印第三个消息，协 程终止。

注意，各个阶段都在yield 表达式中结束，而且下一个阶段都从那一行代码开始，然后再把 yield 表达式的值赋给变量。

协程的特点及优势

协程的特点在于是一个线程执行，那和多线程比，协程有何优势？

最大的优势就是协程极高的执行效率。因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。

第二大优势就是不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。

因为协程是一个线程执行，那怎么利用多核CPU呢？最简单的方法是多进程+协程，既充分利用多核，又充分发挥协程的高效率，可获得极高的性能。

Python对协程的支持还非常有限，用在generator中的yield可以一定程度上实现协程。虽然支持不完全，但已经可以发挥相当大的威力了。

来看例子：

传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但一不小心就可能死锁。

如果改用协程，生产者生产消息后，直接通过yield跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产，效率极高：

import time
 
def consumer():
    r = ''
    while True:
        n = yield r
        print('[CONSUMER] Consuming %s...' % n)
        r = '200 OK'
 
def produce(c):
    next(c)
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] Producing %s...' % n)
        r = c.send(n)
        print('[PRODUCER] Consumer return: %s' % r)
    c.close()
 
if __name__ == "__main__":
    c = consumer()
    produce(c)
 
输出：
[PRODUCER] Producing 1...
[CONSUMER] Consuming 1...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 2...
[CONSUMER] Consuming 2...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 3...
[CONSUMER] Consuming 3...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 4...
[CONSUMER] Consuming 4...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 5...
[CONSUMER] Consuming 5...
[PRODUCER] Consumer return: 200 OK

整个流程无锁，由一个线程执行，produce和consumer协作完成任务，所以称为“协程”，而非线程的抢占式多任务。