yield、greenlet与协程gevent

yield

在说明yield之前，我们了解python中一些概念。

在了解Python的数据结构时，容器(container)、可迭代对象(iterable)、迭代器(iterator)、生成器(generator)、列表/集合/字典推导式(list,set,dict comprehension)众多概念参杂在一起，难免让初学者一头雾水。

容器(container)

容器是一种把多个元素组织在一起的数据结构，容器中的元素可以逐个地迭代获取，可以用in, not in关键字判断元素是否包含在容器中。通常这类数据结构把所有的元素存储在内存中（也有一些特例，并不是所有的元素都放在内存，比如迭代器和生成器对象）在Python中，常见的容器对象有：

• list, deque, ….
• set, frozensets, ….
• dict, defaultdict, OrderedDict, Counter, ….
• tuple, namedtuple, …
• str

容器比较容易理解，因为你就可以把它看作是一个盒子、一栋房子、一个柜子，里面可以塞任何东西。从技术角度来说，当它可以用来询问某个元素是否包含在其中时，那么这个对象就可以认为是一个容器，比如 list，set，tuples都是容器对象：

 

>>> assert 1 in [1, 2, 3]      # lists
>>> assert 4 not in [1, 2, 3]
>>> assert 1 in {1, 2, 3}      # sets
>>> assert 4 not in {1, 2, 3}
>>> assert 1 in (1, 2, 3)      # tuples
>>> assert 4 not in (1, 2, 3)

询问某元素是否在dict中用dict的中key：

>>> d = {1: 'foo', 2: 'bar', 3: 'qux'}
>>> assert 1 in d
>>> assert 'foo' not in d  # 'foo' 不是dict中的元素

询问某substring是否在string中：

>>> s = 'foobar'
>>> assert 'b' in s
>>> assert 'x' not in s
>>> assert 'foo' in s

尽管绝大多数容器都提供了某种方式来获取其中的每一个元素，但这并不是容器本身提供的能力，而是可迭代对象赋予了容器这种能力，当然并不是所有的容器都是可迭代的，比如：Bloom filter，虽然Bloom filter可以用来检测某个元素是否包含在容器中，但是并不能从容器中获取其中的每一个值，因为Bloom filter压根就没把元素存储在容器中，而是通过一个散列函数映射成一个值保存在数组中。

可迭代对象(iterable)

刚才说过，很多容器都是可迭代对象，此外还有更多的对象同样也是可迭代对象，比如处于打开状态的files，sockets等等。但凡是可以返回一个迭代器的对象都可称之为可迭代对象，听起来可能有点困惑，没关系，先看一个例子：

>>> x = [1, 2, 3]
>>> y = iter(x)
>>> z = iter(x)
>>> next(y)
1
>>> next(y)
2
>>> next(z)
1
>>> type(x)
<class 'list'>
>>> type(y)
<class 'list_iterator'>

这里x是一个可迭代对象，可迭代对象和容器一样是一种通俗的叫法，并不是指某种具体的数据类型，list是可迭代对象，dict是可迭代对象，set也是可迭代对象。y和z是两个独立的迭代器，迭代器内部持有一个状态，该状态用于记录当前迭代所在的位置，以方便下次迭代的时候获取正确的元素。迭代器有一种具体的迭代器类型，比如list_iterator，set_iterator。可迭代对象实现了__iter__方法，该方法返回一个迭代器对象。

当运行代码：

x = [1, 2, 3]
for elem in x:
    ...

实际执行情况是：

反编译该段代码，你可以看到解释器显示地调用GET_ITER指令，相当于调用iter(x)，FOR_ITER指令就是调用next()方法，不断地获取迭代器中的下一个元素，但是你没法直接从指令中看出来，因为他被解释器优化过了。

>>> import dis
>>> x = [1, 2, 3]
>>> dis.dis('for _ in x: pass')
  1           0 SETUP_LOOP              14 (to 17)
              3 LOAD_NAME                0 (x)
              6 GET_ITER
        >>    7 FOR_ITER                 6 (to 16)
             10 STORE_NAME               1 (_)
             13 JUMP_ABSOLUTE            7
        >>   16 POP_BLOCK
        >>   17 LOAD_CONST               0 (None)
             20 RETURN_VALUE

迭代器(iterator)

那么什么迭代器呢？它是一个带状态的对象，他能在你调用next()方法的时候返回容器中的下一个值，任何实现了__iter__和__next__()（python2中实现next()）方法的对象都是迭代器，__iter__返回迭代器自身，__next__返回容器中的下一个值，如果容器中没有更多元素了，则抛出StopIteration异常，至于它们到底是如何实现的这并不重要。

所以，迭代器就是实现了工厂模式的对象，它在你每次你询问要下一个值的时候给你返回。有很多关于迭代器的例子，比如itertools函数返回的都是迭代器对象。

生成无限序列：

>>> from itertools import count
>>> counter = count(start=13)
>>> next(counter)
13
>>> next(counter)
14

从一个有限序列中生成无限序列：

>>> from itertools import cycle
>>> colors = cycle(['red', 'white', 'blue'])
>>> next(colors)
'red'
>>> next(colors)
'white'
>>> next(colors)
'blue'
>>> next(colors)
'red'

从无限的序列中生成有限序列：

>>> from itertools import islice
>>> colors = cycle(['red', 'white', 'blue'])  # infinite
>>> limited = islice(colors, 0, 4)            # finite
>>> for x in limited:                         
...     print(x)
red
white
blue
red

为了更直观地感受迭代器内部的执行过程，我们自定义一个迭代器，以斐波那契数列为例：

class Fib:
    def __init__(self):
        self.prev = 0
        self.curr = 1
 
    def __iter__(self):
        return self
 
    def __next__(self):
        value = self.curr
        self.curr += self.prev
        self.prev = value
        return value
 
>>> f = Fib()
>>> list(islice(f, 0, 10))
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

Fib既是一个可迭代对象（因为它实现了__iter__方法），又是一个迭代器（因为实现了__next__方法）。实例变量prev和curr用户维护迭代器内部的状态。每次调用next()方法的时候做两件事：

1. 为下一次调用next()方法修改状态
2. 为当前这次调用生成返回结果

迭代器就像一个懒加载的工厂，等到有人需要的时候才给它生成值返回，没调用的时候就处于休眠状态等待下一次调用。

生成器(generator)

生成器算得上是Python语言中最吸引人的特性之一，生成器其实是一种特殊的迭代器，不过这种迭代器更加优雅。它不需要再像上面的类一样写__iter__()和__next__()方法了，只需要一个yiled关键字。 生成器一定是迭代器（反之不成立），因此任何生成器也是以一种懒加载的模式生成值。用生成器来实现斐波那契数列的例子是：

def fib():
    prev, curr = 0, 1
    while True:
        yield curr
        prev, curr = curr, curr + prev
 
>>> f = fib()
>>> list(islice(f, 0, 10))
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

fib就是一个普通的python函数，它特殊的地方在于函数体中没有return关键字，函数的返回值是一个生成器对象。当执行f=fib()返回的是一个生成器对象，此时函数体中的代码并不会执行，只有显示或隐示地调用next的时候才会真正执行里面的代码。

生成器在Python中是一个非常强大的编程结构，可以用更少地中间变量写流式代码，此外，相比其它容器对象它更能节省内存和CPU，当然它可以用更少的代码来实现相似的功能。现在就可以动手重构你的代码了，但凡看到类似：

def something():
    result = []
    for ... in ...:
        result.append(x)
    return result

都可以用生成器函数来替换：

def iter_something():
    for ... in ...:
        yield x

生成器表达式(generator expression)

生成器表达式是列表推倒式的生成器版本，看起来像列表推导式，但是它返回的是一个生成器对象而不是列表对象。

>>> a = (x*x for x in range(10))
>>> a
<generator object <genexpr> at 0x401f08>
>>> sum(a)
285

总结

• 容器是一系列元素的集合，str、list、set、dict、file、sockets对象都可以看作是容器，容器都可以被迭代（用在for，while等语句中），因此他们被称为可迭代对象。
• 可迭代对象实现了__iter__方法，该方法返回一个迭代器对象（可以用next()取出元素的叫迭代器）。
• 迭代器持有一个内部状态的字段，用于记录下次迭代返回值，它实现了__next__和__iter__方法，迭代器不会一次性把所有元素加载到内存，而是需要的时候才生成返回结果。
• 生成器是一种特殊的迭代器，它的返回值不是通过return而是用yield。

生成器函数与外部通信

下面是一个列子：

def consumer():
  r = 'here'
  for i in xrange(3):
    yield r
    r = '200 OK'+ str(i)
 
c = consumer()
n1 = c.next()
n2 = c.next()
n3 = c.next()

对于普通的生成器，第一个next调用，相当于启动生成器，会从生成器函数的第一行代码开始执行，直到第一次执行完yield语句（第4行）后，跳出生成器函数。

然后第二个next调用，进入生成器函数后，从yield语句的下一句语句（第5行）开始执行，然后重新运行到yield语句，执行后，跳出生成器函数，后面再次调用next，依次类推。

了解了next()如何让包含yield的函数执行后，我们再来看另外一个非常重要的函数send(msg)。其实next()和send()在一定意义上作用是相似的，区别是send()可以传递yield表达式的值进去，而next()不能传递特定的值，只能传递None进去。因此，我们可以看做c.next() 和 c.send(None) 作用是一样的。

需要提醒的是，第一次调用时，请使用next()语句或是send(None)，不能使用send发送一个非None的值，否则会出错的，因为没有Python yield语句来接收这个值。

下面来着重说明下send执行的顺序。当第一次send（None）（对应11行）时，启动生成器，从生成器函数的第一行代码开始执行，直到第一次执行完yield（对应第4行）后，跳出生成器函数。这个过程中，n1一直没有定义。

下面运行到send（1）时，进入生成器函数，注意这里与调用next的不同。这里是从第4行开始执行，把1赋值给n1，但是并不执行yield部分。下面继续从yield的下一语句继续执行，然后重新运行到yield语句，执行后，跳出生成器函数。

即send和next相比，只是开始多了一次赋值的动作，其他运行流程是相同的。

def consumer():
  r = 'here'
  while True:
    n1 = yield r
    if not n1:
      return
    print('[CONSUMER] Consuming %s...' % n1)
    r = '200 OK'+str(n1)
 
def produce(c):
  aa = c.send(None)
  n = 0
  while n < 5:
    n = n + 1
    print('[PRODUCER] Producing %s...' % n)
    r1 = c.send(n)
    print('[PRODUCER] Consumer return: %s' % r1)
  c.close()
 
c = consumer()
produce(c)

>>
[PRODUCER] Producing 1...
[CONSUMER] Consuming 1...
[PRODUCER] Consumer return: 200 OK1
[PRODUCER] Producing 2...
[CONSUMER] Consuming 2...
[PRODUCER] Consumer return: 200 OK2
[PRODUCER] Producing 3...
[CONSUMER] Consuming 3...
[PRODUCER] Consumer return: 200 OK3
[PRODUCER] Producing 4...
[CONSUMER] Consuming 4...
[PRODUCER] Consumer return: 200 OK4
[PRODUCER] Producing 5...
[CONSUMER] Consuming 5...
[PRODUCER] Consumer return: 200 OK5

总结：

• 在yield处会返回一个值，并暂停执行，在外部可以send() 传递参数进来
• a = yield b ,c = func.send(d) # func是个生成器，执行之后 c = b a = d #yield把b返回 被c接收 send把d传进去，被a接收 

• 先要send(None)(相当于next())一次，让函数执行到yield处，这样才能往生成器里面传参，让函数可以接收

greenlet

虽然CPython（标准Python）能够通过生成器来实现协程，但使用起来还并不是很方便。与此同时，Python的一个衍生版 Stackless Python实现了原生的协程，它更利于使用。

于是，大家开始将 Stackless 中关于协程的代码单独拿出来做成了CPython的扩展包。这就是 greenlet 的由来，因此 greenlet 是底层实现了原生协程的 C扩展库。

greenlet的使用

from greenlet import greenlet
 
def test1():
    print 12
    gr2.switch()
    print 34
 
def test2():
    print 56
    gr1.switch()
    print 78
 
gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()
输出：
12
56
34

最后一行跳转到 test1() ，它打印12，然后跳转到 test2() ，打印56，然后跳转回 test1() ，打印34，然后 test1() 就结束，gr1 dead。这时执行会回到原来的 gr1.switch() 。

让我们看看当一个greenlet dead时执行到了哪里。每个greenlet拥有一个“父”greenlet。父greenlet在每个greenlet初始化时创建（这可以在任何时候被改变）。父greenlet是当greenlet dead时，在原来的位置继续执行。通过这种方式，greenlet以树的形式组织。层次最高的代码不会在用户创建的freenlet中运行，称为主greenlet，也就是树根。
在上述的例子中，gr1和gr2都把主greenlet作为父greenlet。当其中任一greenlet dead时，执行点都会回到主greenlet。

from greenlet import greenlet
 
def test1():
    print 12
    gr2.switch()
    print 34
 
def test2():
    print 56
 
gr1 = greenlet(test1)
gr2 = greenlet(test2, gr1)
gr1.switch()
print 78

这里创建greenlet对象”gr2″时，指定了其父协程是”gr1″。所以在函数test2()里，虽然没有”gr1.switch()”代码，但是在其退出后，程序一样回到了函数test1()，并且执行”print 34″。同样，在test1()退出后，代码回到了主程序，并执行”print 78″。所以，最后的输出就是：

12
56
34
78

如果上例中，”gr2″的父协程不是”gr1″而是”main”的话，那test2()运行完毕就会回到主程序并直接打印”78″，这样”print 34″就不会执行。大家可以试一试。

异常

一个协程要抛出异常，就会先抛到其父协程中，如果所有父协程都不捕获此异常，程序才会退出。

我们试下，把上面的例子中函数test2()的代码改为：

def test2():
    print 56
    raise NameError

程序执行后，我们可以看到Traceback信息：

  File "parent.py", line 14, in 
    gr1.switch()
  File "parent.py", line 5, in test1
    gr2.switch()
  File "parent.py", line 10, in test2
    raise NameError

同时大家可以试下，如果将”gr2″的父协程设为空，Traceback信息就会变为：

  File "parent.py", line 14, in 
    gr1.switch()
  File "parent.py", line 10, in test2
    raise NameError

因此，如果”gr2″的父协程是”gr1″的话，异常先回抛到函数test1()的代码”gr2.switch()”处。所以，我们再对函数test1()改动下：

def test1():
    print 12
    try:
        gr2.switch()
    except NameError:
        print 90
    print 34

运行后的结果，如果”gr2″的父协程是”gr1″，则异常被捕获，并打印90。否则，异常会被抛出。以上实验很好的证明了，子协程抛出的异常会根据栈里的顺序，依次抛到父协程里。

有一个异常是特例，不会被抛到父协程中，那就是”greenlet.GreenletExit”，这个异常会让当前协程强制退出。比如，我们将函数test2()改为：

def test2():
    print 56
    raise greenlet.GreenletExit
    print 78

那代码行”print 78″永远不会被执行。但这个异常不会往上抛，所以其父协程还是可以正常运行。

另外，我们可以通过greenlet对象的”throw()”方法，手动往一个协程里抛个异常。比如，我们在test1()里调一个throw()方法：

def test1():
    print 12
    gr2.throw(NameError)
    try:
        gr2.switch()
    except NameError:
        print 90
    print 34

这样，异常就会被抛出，运行后的Trackback是这样的：

  File "exception.py", line 21, in 
    gr1.switch()
  File "exception.py", line 5, in test1
    gr2.throw(NameError)

如果将”gr2.throw(NameError)”放在”try”语句中，那该异常就会被捕获，并打印”90″。另外，当”gr2″的父协程不是”gr1″而是”main”时，异常会直接抛到主程序中，此时函数test1()中的”try”语句就不起作用了。

greenlet间通信

greenlets之间切换通过调用greenlet的switch()方法，在这种情况下，执行点跳转到调用switch()的greenlet，当一个greenlet挂点时，执行点会跳到其父greenlet。在切换的时候，一个对象或者异常可以传到目标greenlet，这可以很方便的用来在greenlet之间传递信息．例如：

from greenlet import greenlet
 
def test1():
    print 12
    y = gr2.switch(56)
    print y
 
def test2(x):
    print x
    gr1.switch(34)
    print 78
 
gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()

在test1()中调用”gr2.switch()”，由于协程”gr2″之前未被启动，所以传入的参数”56″会被赋在test2()函数的参数”x”上；在test2()中调用”gr1.switch()”，由于协程”gr1″之前已执行到第5行”y = gr2.switch(56)”这里，所以传入的参数”34″会作为”gr2.switch(56)”的返回值，赋给变量”y”。这样，两个协程之间的互传消息就实现了。

让我们用greenlet实现生产者消费者模型：

from greenlet import greenlet
import random
import time
def productor():
    while True:
        item = random.randint(0,99)
        print('生产了{}'.format(item))
        c.switch(item) # 切换到c 并传了一个参数item
        time.sleep(1)

def consumer():
    while True:
        item = p.switch() # 切换到p 在恢复的时候接收数据
        print('消费了{}'.format(item))

if __name__ == '__main__':
    c = greenlet(consumer) #将一个普通函数变成协程
    p = greenlet(productor) 
    c.switch() #进入消费者函数执行，到yield后进入暂停状态，只有恢复时才能接收数据

注意：greenlet 是遇到switch就切换，可以传参

greenlet 的价值
价值一： 高性能的原生协程
价值二： 语义更加明确的显式切换
价值三： 直接将函数包装成协程，保持原有代码风格

gevent

   gevent的基本原理来自于libevent&libev。熟悉c语言的同学对这么一个lib应该不陌生。本质上libevent或者说libev都是一种事件驱动模型。这种模型对于提高cpu的运行效率，增强用户的并发访问非常有效。但是因为它本身是一种事件机制，所以写起来有点绕，不是很直观。所以，为了修正这个问题，有心人引入了用户侧上下文切换的机制。这就是说，如果代码中引入了带io阻塞的代码时，lib本身会自动完成上下文的切换，全程用户都是没有觉察的。这就是gevent的由来。

gevent 的价值
价值一： 使用基于 epoll 的 libev 来避开阻塞
价值二： 使用基于 gevent 的 高效协程 来切换执行
价值三： 只在遇到阻塞的时候切换，没有轮需的开销，也没有线程的开销

遇到阻塞就切换到另一个协程继续执行 ！

使用

import gevent

def f1():
    for i in range(5):
        print 'this is ' + str(i)
        gevent.sleep(0)

def f2():
    for i in range(5):
        print 'that is ' + str(i)
        gevent.sleep(0)

t1 = gevent.spawn(f1)
t2 = gevent.spawn(f2)
gevent.joinall([t1, t2])

通过打印输出，可以看出f1和f2是交叉打印信息的，因为在代码执行的过程中，由用户自己主动调用了切换函数。

锁操作

    虽然是协程，但是在里面添加锁增加对共享资源的互斥访问也是非常重要的，此外锁本身的添加也是很简单的

import gevent
from gevent.lock import Semaphore

sem = Semaphore(1)

def f1():
    for i in range(5):
        sem.acquire()
        print 'this is ' + str(i)
        sem.release()

def f2():
    for i in range(5):
        sem.acquire()
        print 'that is ' + str(i)
        sem.release()

t1 = gevent.spawn(f1)
t2 = gevent.spawn(f2)
gevent.joinall([t1, t2])

gevent下的monkey机制

    要是gevent说到这里，只能算的上还行。我个人觉得gevent另外一个特别厉害的功能就是它的monkey机制。简单来说，假设你不愿意修改原来已经写好的python代码，但是又想充分利用gevent机制，那么你就可以用monkey来做到这一点。你所要做的就是在文件开头打一个patch，那么它就会自动替换你原来的thread、socket、time、multiprocessing等代码，全部变成gevent框架。这一切都是由gevent自动完成的。注意这个patch是在所有module都import了之后再打，否则没有效果。

协程队列

之前介绍进程与线程时，为了方便进程或线程间的通信，引入了队列的概念。在协程中，同样也有队列来进行协程间的通信。