推文：Python协程深入理解（本文转载于该文章）
从语法上来看，协程和生成器类似，都是定义体中包含yield关键字的函数。
yield在协程中的用法：
- 在协程中yield通常出现在表达式的右边，例如：datum = yield,可以产出值，也可以不产出--如果yield关键字后面没有表达式，那么生成器产出None.
- 协程可能从调用方接受数据，调用方是通过send(datum)的方式把数据提供给协程使用，而不是next(...)函数，通常调用方会把值推送给协程。
- 协程可以把控制器让给中心调度程序，从而激活其他的协程
所以总体上在协程中把yield看做是控制流程的方式。
协程不止可以接受，还可以发送
了解协程的过程
>>> def simple_corotine(): ... print('---->coroutine started') ... x = yield #有接收值，所以同生成器一样，需要先激活,使用next ... print('---->coroutine recvied:',x) ... >>> my_coro = simple_corotine() >>> my_coro <generator object simple_corotine at 0x0000000000A8A518>
>>> next(my_coro) #先激活生成器，执行到yield val语句 #或者使用send(None)也可以激活生成器 ---->coroutine started >>> my_coro.send(24) #向其中传入值，x = yield ---->coroutine recvied: 24 Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration #当生成器执行完毕时会报错
若是我们没有激活生成器，会报错
>>> def simple_corotine(): ... print('---->coroutine started') ... x = yield ... print('---->coroutine recvied:',x) ... >>> my_coro = simple_corotine() >>> my_coro <generator object simple_corotine at 0x0000000000A8A518> >>> my_coro.send(2) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: can't send non-None value to a just-started generator
协程在运行中的四种状态
GEN_CREATE:等待开始执行
GEN_RUNNING:解释器正在执行，这个状态一般看不到
GEN_SUSPENDED:在yield表达式处暂停
GEN_CLOSED:执行结束
>>> from inspect import getgeneratorstate #状态查看需要引入
>>> def simple_corotine(val): ... print('---->coroutine started: val=',val) ... b = yield val ... print('---->coroutine received: b=',b) ... c = yield val + b ... print('---->coroutine received: c=',c) ... >>> my_coro = simple_corotine(12) >>> from inspect import getgeneratorstate >>> getgeneratorstate(my_coro) 'GEN_CREATED' #创建未激活 >>> my_coro.send(None) ---->coroutine started: val= 12 12 >>> getgeneratorstate(my_coro) 'GEN_SUSPENDED' #在yield处暂停 >>> my_coro.send(13) ---->coroutine received: b= 13 25 >>> getgeneratorstate(my_coro) 'GEN_SUSPENDED' >>> my_coro.send(14) ---->coroutine received: c= 14 Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration >>> getgeneratorstate(my_coro) 'GEN_CLOSED' #执行结束 >>>
再使用一个循环例子来了解协程：求平均值
>>> def averager(): ... total = 0.0 ... count = 0 ... aver = None ... while True: ... term = yield aver ... total += term ... count += 1 ... aver = total/count ... >>> coro_avg = averager() >>> coro_avg.send(None) >>> coro_avg.send(10) 10.0 >>> coro_avg.send(20) 15.0 >>> coro_avg.send(30) 20.0 >>> coro_avg.send(40) 25.0
这里是一个死循环，只要不停send值给协程，可以一直计算下去。
通过上面的几个例子我们发现，我们如果想要开始使用协程的时候必须通过next(...)方式激活协程，如果不预激，这个协程就无法使用，如果哪天在代码中遗忘了那么就出问题了，所以有一种预激协程的装饰器，可以帮助我们干这件事（用来帮助我们激活协程）
预激协程的装饰器（自定义）
>>> def coro_active(func): ... def inner(*args,**kwargs): ... gen = func(*args,**kwargs) ... next(gen) #gen.send(None) ... return gen ... return inner ... >>> @coro_active ... def averager(): ... total = 0.0 ... count = 0 ... aver = None ... while True: ... term = yield aver ... total += term ... count += 1 ... aver = total/count ...
>>> coro_avg = averager()
>>> coro_avg.send(10) 10.0
>>> coro_avg.send(20) 15.0
>>> coro_avg.send(30) 20.0
def coro_active(func): def inner(*args,**kwargs): gen = func(*args,**kwargs) next(gen) #gen.send(None) return gen return inner @coro_active def averager(): total = 0.0 count = 0 aver = None while True: term = yield aver total += term count += 1 aver = total/count
关于预激，在使用yield from句法调用协程的时候，会自动预激活，这样其实与我们上面定义的预激装饰器是不兼容的，
在python3.4里面的asyncio.coroutine装饰器不会预激协程，因此兼容yield from。
终止协程和异常处理（throw抛出，close终止）
协程中为处理的异常会向上冒泡,传给next函数或send函数的调用方(即触发协程的对象)
拿上面的代码举例子，如果我们发送了一个字符串而不是一个整数的时候就会报错，并且这个时候协程是被终止了
>>> def coro_active(func): ... def inner(*args,**kwargs): ... gen = func(*args,**kwargs) ... next(gen) #gen.send(None) ... return gen ... return inner ... >>> @coro_active ... def averager(): ... total = 0.0 ... count = 0 ... aver = None ... while True: ... term = yield aver ... total += term ... count += 1 ... aver = total/count ...
>>> coro_avg = averager() >>> coro_avg.send(10) 10.0 >>> coro_avg.send(20) 15.0 >>> coro_avg.send(30) 20.0 >>> averager.send('z') #我们应该对异常进行处理 Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 8, in averager TypeError: unsupported operand type(s) for +=: 'float' and 'str'
异常处理
class TestException(Exception): '''自定义异常''' def coro_active(func): def inner(*args,**kwargs): gen = func(*args,**kwargs) next(gen) #gen.send(None) return gen return inner @coro_active def averager(): total = 0.0 count = 0 aver = None while True: try: term = yield aver except TestException: print('捕获到TestException') term = 0 count -= 1 total += term count += 1 aver = total/count coro_avg = averager() print(coro_avg.send(10)) print(coro_avg.send(20)) print(coro_avg.send(30)) print(coro_avg.throw(TestException)) print(coro_avg.send('z')) #报错TypeError，未捕获 averager.close()
让协程返回值
通过下面的例子进行演示如何获取协程的返回值：
def coro_active(func): def inner(*args,**kwargs): gen = func(*args,**kwargs) next(gen) #gen.send(None) return gen return inner @coro_active def averager(): total = 0.0 count = 0 aver = None while True: term = yield aver if term is None: break total += term count += 1 aver = total/count return 101 coro_avg = averager() print(coro_avg.send(10)) print(coro_avg.send(20)) print(coro_avg.send(30)) try: #获取我们的返回值 coro_avg.send(None) except StopIteration as e: print(e.value) averager.close()
若是不去捕获异常：
StopIteration: 101 #抛出我们要获取的值
其实相对来说上面这种方式获取返回值比较麻烦，而yield from 结构会自动捕获StopIteration异常，
这种处理方式与for循环处理StopIteration异常的方式一样，循环机制使我们更容易理解处理异常，
对于yield from来说，解释器不仅会捕获StopIteration异常，还会把value属性的值变成yield from表达式的值
关于yield from（重点）
在生成器gen中使用yield from subgen()时，subgen会获得控制权，把产出的值传给gen的调用方，即调用方可以直接控制subgen,
同时，gen会阻塞，等待subgen终止
yield from x表达式对x对象所做的第一件事是，调用iter(x),从中获取迭代器，因此x可以是任何可迭代的对象
yield from可以简化yield表达式
def genyield(): for c in "AB": yield c for i in range(1,3): yield i print(list(genyield())) def genyieldfrom(): yield from "AB" yield from range(1,3) print(list(genyieldfrom()))
这两种的方式的结果是一样的，但是这样看来yield from更加简洁，但是yield from的作用可不仅仅是替代产出值的嵌套for循环。
yield from的主要功能是打开双向通道，把最外层的调用方与最内层的子生成器连接起来，这样二者可以直接发送和产出值，还可以直接传入异常，而不用再像之前那样在位于中间的协程中添加大量处理异常的代码
对StopIteration和return进行简化
委派生成器在yield from 表达式处暂停时，调用方可以直接把数据发给子生成器，子生成器再把产出产出值发给调用方，子生成器返回之后，解释器会抛出StopIteration异常，并把返回值附加到异常对象上，此时委派生成器会恢复。
from collections import namedtuple Result = namedtuple('Result', 'count average') # 子生成器 def averager(): total = 0.0 count = 0 average = None while True: term = yield if term is None: break total += term count += 1 average = total/count return Result(count, average) # 委派生成器 def grouper(result, key): while True: # print(key) #可以知道，对于每一组数据，都是通过委派生成器传递的，开始传递一次，结束获取结果的时候又传递一次 result[key] = yield from averager() #将返回结果收集 # 客户端代码，即调用方 def main(data): results = {} for key,values in data.items(): group = grouper(results,key) next(group) for value in values: group.send(value) group.send(None) #这里表示要终止了 report(results) # 输出报告 def report(results): for key, result in sorted(results.items()): group, unit = key.split(';') print('{:2} {:5} averaging {:.2f}{}'.format( result.count, group, result.average, unit )) data = { 'girls;kg': [40.9, 38.5, 44.3, 42.2, 45.2, 41.7, 44.5, 38.0, 40.6, 44.5], 'girls;m': [1.6, 1.51, 1.4, 1.3, 1.41, 1.39, 1.33, 1.46, 1.45, 1.43], 'boys;kg': [39.0, 40.8, 43.2, 40.8, 43.1, 38.6, 41.4, 40.6, 36.3], 'boys;m': [1.38, 1.5, 1.32, 1.25, 1.37, 1.48, 1.25, 1.49, 1.46], } if __name__ == '__main__': main(data)
关于上述代码着重解释一下关于委派生成器部分，这里的循环每次迭代时会新建一个averager实例，每个实例都是作为协程使用的生成器对象。
grouper发送的每个值都会经由yield from处理，通过管道传给averager实例。grouper会在yield from表达式处暂停，等待averager实例处理客户端发来的值。averager实例运行完毕后，返回的值会绑定到results[key]上，while 循环会不断创建averager实例，处理更多的值
并且上述代码中的子生成器可以使用return 返回一个值，而返回的值会成为yield from表达式的值。
是一组数据一组数据按照顺序处理的。
关于yield from的意义
关于yield from 六点重要的说明：
- 子生成器产出的值都直接传给委派生成器的调用方(即客户端代码)
- 使用send()方法发送给委派生成器的值都直接传给子生成器。如果发送的值为None,那么会给委派调用子生成器的__next__()方法。如果发送的值不是None,那么会调用子生成器的send方法，如果调用的方法抛出StopIteration异常，那么委派生成器恢复运行，任何其他异常都会向上冒泡，传给委派生成器
- 生成器退出时，生成器(或子生成器)中的return expr表达式会出发StopIteration(expr)异常抛出
- yield from表达式的值是子生成器终止时传给StopIteration异常的第一个参数。yield from 结构的另外两个特性与异常和终止有关。
- 传入委派生成器的异常，除了GeneratorExit之外都传给子生成器的throw()方法。如果调用throw()方法时抛出StopIteration异常，委派生成器恢复运行。StopIteration之外的异常会向上冒泡，传给委派生成器
- 如果把GeneratorExit异常传入委派生成器，或者在委派生成器上调用close()方法，那么在子生成器上调用clsoe()方法，如果它有的话。如果调用close()方法导致异常抛出，那么异常会向上冒泡，传给委派生成器，否则委派生成器抛出GeneratorExit异常