顶格标注，初学者看这个一定要记住这么几个概念：
1、next(x)与s.send(None)的一样的效果，需要给生成器send消息，必须先执行前面的命令，让生成器预激，就是走到能够互动给值的地方。
2、yield from x x是可迭代对象既可，因为它首相会先对x进行iter(x)返回的副本（迭代器是自身，可迭代对象是创建一个自身的迭代器返回）进行操作。
3、send就是比next多了一个发送给生成器暂停位置值的作用，所以send一次，必须会促使迭代器向下走一次。初学者看字面会觉的是发送消息，其实如果生成器yield有值产出，也能接收。
send这个词汇不好，应该取一个send_next更加合理。
4、协程只需要在send的时候进行预激，另外throw,send,close,都不需要预激。
给自己的记号：
生成器一般仍什么错误，上浮什么错误，但扔StopIteration
上浮RuntimeError！！！
In [590]: i.throw(StopIteration) --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-588-e668612914cb> in <genexpr>(.0) ----> 1 i= (i for i in range(10)) StopIteration: The above exception was the direct cause of the following exception: RuntimeError Traceback (most recent call last) <ipython-input-590-6828ce324924> in <module> ----> 1 i.throw(StopIteration) RuntimeError: generator raised StopIteration
协程是指一个过程，这个过程与调用方协作，产出由调用方提供的值。
16.2 用作协程的生成器的基本行为
协程可以通过inspect.getgenerationstate(...)来返回协程状态
'GEN_CREATED' 等待开始执行
'GEN_RUNNING' 解释器正在执行
'GEN_SUSPENDED' 在yield表达式暂停
'GEN_CLOSE' 执行结束
协程在执行send(xxx)具体内容，必须预激协程，可以通过next(gen)或gen.send(None)
In [473]: def simple_coro2(a):
...: print('-> Started: a =', a)
...: b = yield a
...: print('-> Received: b =', b)
...: c = yield a + b
...: print('-> Received: c =', c)
...:
In [474]: my_core2 = simple_coro2(14) # 生成generator
In [475]: from inspect import getgeneratorstate
In [476]: getgeneratorstate(my_core2)
Out[476]: 'GEN_CREATED'
In [477]: next(my_core2) # 预激协程
-> Started: a = 14
Out[477]: 14
In [478]: getgeneratorstate(my_core2)
Out[478]: 'GEN_SUSPENDED'
In [479]: my_core2.send(28) # 发送数据
-> Received: b = 28
Out[479]: 42
In [480]: my_core2.send(99) # 发送数据
-> Received: c = 99
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-480-f1e922706109> in <module>
----> 1 my_core2.send(99)
StopIteration:
In [481]: getgeneratorstate(my_core2)
Out[481]: 'GEN_CLOSED'
其实这种b = yield a可以理解为一个双向通道，当执行，只不过这个双向通道是分开执行的。
当停滞在yield a的时候，已经生产出a了，这个时候你如果执行send，可以给b对象，并且生成器向下执行到下一个yield xxx产出。
所以，如果下一个yield后面有跟对象产出，这个send就是想送一个东西进去，然后产出一个东西出来。
16.3 示例：使用协程计算移动平均值
In [482]: def averager():
...: total = 0.0
...: count = 0
...: average = None
...: while True:
...: term = yield average
...: total += term
...: count += 1
...: average = total / count
...:
In [483]: coro = average_gen()
In [484]: coro.send(None) # 预激协程
Out[484]: 0
In [485]: coro = average_gen()
In [486]: next(coro) # 另外一种预激协程
Out[486]: 0
In [487]: coro.send(10)
Out[487]: 10.0
In [488]: coro.send(20)
Out[488]: 15.0
In [489]: coro.send(30)
Out[489]: 20.0
16.4预激协程的装饰器
先上装饰器
from functools import wraps
def coroutine(func):
@wraps(func)
def primer(*args, **kwargs):
gen = func(*args, **kwargs)
next(gen) # 预激协程
return gen
return primer
from coroutil import coroutine
@coroutine
def averager():
total = 0.0
count = 0
average = None
while True:
term = yield average
total += term
count += 1
average = total / count
if __name__ == '__main__':
aver = averager()
print(aver.send(10))
print(aver.send(20))
print(aver.send(30))
/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第十六章/coroaverager0.py 10.0 15.0 20.0 Process finished with exit code 0
16.5终止协程和异常处理
next与close不需要预激协程，throw与send需要预激协程
from inspect import getgeneratorstate
class DemoException(Exception):
"""演示用的"""
def demo_exc_handling():
print('-> coroutine started')
count = 0
while True:
try:
x = yield f'info->({count})' # 测试定位用
except DemoException:
print("*** DemoException handled. Continuing...")
else:
print(f'-> coroutine received:{x!r}')
count += 1
def throw():
exc_coro = demo_exc_handling()
print(exc_coro.send(None)) # 预激协程
print(exc_coro.throw(DemoException))
print(getgeneratorstate(exc_coro))
def close():
exc_coro = demo_exc_handling()
print(exc_coro.send(None))
print(exc_coro.close()) # 没有返回值，不需要预激携程
print(getgeneratorstate(exc_coro))
if __name__ == '__main__':
throw()
print('='*20)
close()
/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第十六章/coro_exc_demo.py -> coroutine started info->(0) *** DemoException handled. Continuing... info->(1) GEN_SUSPENDED ==================== -> coroutine started info->(0) None GEN_CLOSED Process finished with exit code 0
16.6让协程返回值
In [492]: 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: # 判断输入是否为None
...: break
...: total += term
...: count += 1
...: average = total / count
...: return Result(count, average) # 返回StopIteration
...:
In [493]: aver = averager()
In [494]: next(aver)
In [495]: aver.send(10)
In [496]: aver.send(20)
In [497]: aver.send(None)
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-497-19d1f05a0674> in <module>
----> 1 aver.send(None)
StopIteration: Result(count=2, average=15.0)
前面14章我自己理解关于生成器碰到return或者没有yield生成的时候,会上报StopIteration，但这个return返回的对象尽然包含在StopIteration的属性里面。
那就可以想办法取出来了.
In [498]: aver = averager()
In [499]: aver.send(None)
In [500]: aver.send(10)
In [501]: aver.send(20)
In [502]: try:
...: aver.send(None)
...: except StopIteration as s:
...: result = s
...:
In [503]: dir(result)
Out[503]:
['__cause__',
'__class__',
'__context__',
'__delattr__',
'__dict__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__gt__',
'__hash__',
'__init__',
'__init_subclass__',
'__le__',
'__lt__',
'__ne__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__setstate__',
'__sizeof__',
'__str__',
'__subclasshook__',
'__suppress_context__',
'__traceback__',
'args',
'value',
'with_traceback']
In [504]: res = result.value
In [505]: res
Out[505]: Result(count=2, average=15.0)
In [506]:
16.7使用 yield from
In [506]: def demo():
...: yield from 'abcd'
...: yield from range(10)
...:
...:
In [507]: list(demo())
Out[507]: ['a', 'b', 'c', 'd', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [508]:
yield from x 表达式对x对象所做的第一件事是，调用iter(x)，从中获取迭代器。因此x可以是任何可迭代对象。
yield from的主要功能是打开双向通道，把最外层的调用方法与最内层的子生成器链接起来，这样二者可以直接发送和产出值，还可以直接传入异常，而不用在位于中间的协程中添加大量处理异常的样板代码。
委派生成器：
包含yield from <iterable> 表达式的生成器函数
我的理解方式是：委派生成器就像农夫山泉的广告，它其实不生产元素，它只不过是元素的搬运工，提供了一个管理。
当然你可以在生成器函数里面执行一些代码，但也就预激的时候运行一下，后面加入想获取子生成器的return的时候会再执行一次next。
委派生成器除了能够获取出子生成器的StopIteration里面的return 的result，在调用方与子生成器的互动中，不能获取双法发送的信息。
子生成器：
从yield from表达式中<iterable>部分获取的生成器，这就是PEP380的标题中所有的"子生成器"
这个才是真正的底层工作的生成器，它里面有一个yield在辛苦的坐着底层劳动，然后通过委派生成器与最外面的调用方互动。
调用方
PEP380使用"调用方"这个术语指代调用委托生成的客户端代码。
这个主要是与子生成器互动的，根据需求，可以直接获得子生成器yield出来的值，也可以send给子生成器值，发送结束命令后，获取res结果。
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: # 判断输入是否为None
break
total += term
count += 1
average = total / count
return Result(count, average) # 返回StopIteration
def second(): # 自己添加的二层委派生成器
results = yield from averager() # 获取最终的子生成器的res
return results # 获取以后直接通过StopIteration的value传出结果
# 委派生成器
def grouper(results, key):
# while True: # 书中这里用了while True当然这是非常好的，网上一堆代码也都这样写。
# 有人提问为什么要while True至少百度没有啥正确答案，通过重复测试。
# result在获得值以后grouper被重新激活，按照生成器的原理会继续向下走，但去掉了while向下走。
# 会产生函数默认返回值return None，同时委派生成器的StopIteration报错。
# 我这里选择加再加一个yield，这也可以避免StopIteration报错，书中的while方式当然也可以
# 但感觉没有添加一个while快，因为再次进去 yield from averager()会再次创建一个averager()子生成器
# 但调用方后续新建一个results[key] 与 averager()子生成器，前面刚刚新建的averager()子生成器被垃圾回收。
# 所以再添加一个yield可以避免发生空余新建averager()子生成器，当然你也可以在调用方设置try，except来捕获异常，但不用任何操作。
results[key] = yield from second()
yield
# 客户端代码，既调用方
def main(data):
results = {} # 为了捕获委派生成器的结果，定义一个可变参数接收委派生成器的产出结果，是一个非常不错的主意。
for key, values in data.items():
# group 是调用grouper函数得到的生成器对象，传给grouper 函数的第一个参数是results，用于收集结果；第二个是某个键
group = grouper(results, key) # 给委派生成器传递可变参数字典，与key
next(group) # 这个是预激委派生成器，后面所有的委派生成器或者子生成器都会自动被预激
for value in values:
# 通过grouper 把value传入的值到达averager函数中；
# grouper并不知道传入的是什么，同时grouper实例在yield from处暂停
group.send(value)
# 把None传入groupper，传入的值最终到达averager函数中，导致当前实例终止。然后继续创建下一个实例。
# 如果没有group.send(None)，那么averager子生成器永远不会终止，委派生成器也永远不会在此激活，也就不会为result[key]赋值
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, 41, 42, 43, 44, 54],
'girls;m': [1.5, 1.6, 1.8, 1.5, 1.45, 1.6],
'boys;kg':[50, 51, 62, 53, 54, 54],
'boys;m': [1.6, 1.8, 1.8, 1.7, 1.55, 1.6],
}
if __name__ == '__main__':
main(data)
/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/第十六章/coroaverager3.py 6 boys averaging 54.00kg 6 boys averaging 1.68m 6 girls averaging 44.00kg 6 girls averaging 1.58m Process finished with exit code 0
注释已经很仔细了。
如果你不需要拿回子生成器的return（就是子生成器函数不能停下来，因为一旦停下来，函数就会有返回值，就算你没设置也会返回None），
只想拿子生成器产出的值，由于没有return，所以这个子生成器只能是一个无线迭代的生成器。
In [537]: def c_gen():
...: i = 0
...: while True:
...: yield i
...: i += 1
...:
In [538]: def wei1():
...: yield from c_gen()
...:
In [539]: def wei2():
...: yield from wei1()
...:
In [540]: w = wei2()
In [541]: next(w)
Out[541]: 0
In [542]: next(w)
Out[542]: 1
In [543]: next(w)
Out[543]: 2
In [544]: def c_gen():
...: return (i for i in range(4))
...:
...:
In [545]: w = wei2()
In [546]: next(w)
Out[546]: 0
In [547]: list(w)
Out[547]: [1, 2, 3]
In [548]:
这是一个不获取子生成器return值的示例，通过两层委派生成器，执行最后的委派生成器，跟直接执行子生成器效果一样。
这个就很好的显示了管道的力量。
In [548]: def c_gen():
...: return iter('abc')
...:
...:
In [549]: w = wei2()
In [550]: next(w)
Out[550]: 'a'
In [551]: w.send('a')
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-551-77ce452bcf0e> in <module>
----> 1 w.send('a')
<ipython-input-539-fc4381f76d91> in wei2()
1 def wei2():
----> 2 yield from wei1()
3
<ipython-input-538-91d3b9c6a7ef> in wei1()
1 def wei1():
----> 2 yield from c_gen()
3
AttributeError: 'str_iterator' object has no attribute 'send'
最后我把子生成器返回一个迭代器，因为迭代器没有send方法，所以，就报错了，通过委派生成器层层传递到最外层。
我把前面这些理解了，再取理解yield from 到底再做什么就方便多了。
我先上书中的简化版的逻辑。
后面又花了几个小时仔细研究了这个代码：这不就是只有一个yield的的生成器吗？只不过进行了一系列封装。
RESULT = yield from EXPR
# 模拟具体效果
_i = iter(EXPR) # 对EXPR进行iter操作，必须返回一个迭代器
try:
_y = next(_i) # 为什么yield from的子生成器不用预激，就是这里帮你预激了
except StopIteration as _e: # 取出第一次预激就StopIteration，那准备接收返回值，也没必要yield
_r = _e.value # 拿出返回值
else:
while 1: # 这里就是为什么yield from 能够取代for循环的原因了（运行这个循环时，委派生成器会阻塞，只作为调用方与子生成器之间的通道）。
_s = yield _y # 产出前面预激的时候获取的值给调用者，这里面yield暂停(进入了管道里面)，等待调用者发送信息。
try:
_y = _i.send(_s) # 将委派生成器接收到的_s发送给_s子生成器
except StopIteration as _e: # 如果接收到StopIteration，从子生成器中拿出返回值
_r = _e.value
break
RESULT = _r # 赋值给他 是不是发现少了什么，少了一个yield
已经讲的很啰嗦了。
-
_i 迭代器（子生成器）
-
_y 产出的值 （子生成器产出的值）
-
_r 结果 （最终的结果 即整个yield from表达式的值）
-
_s 发送的值 （调用方发给委派生成器的值，这个只会传给子生成器）
-
_e 异常 （异常对象）
上面的例子是子生成器经过iter(x)以后必定有send方法，但并不是所有的迭代器独有send方法，而且很多报错的逻辑上浮也没写。
上一个书中的终极版本：
RESULT = yield from EXPR
# EXPR 可以是任何可迭代对象，因为获取迭代器_i 使用的是iter()函数。
_i = iter(EXPR) # 对EXPR进行iter操作，必须返回一个迭代器
try:
_y = next(_i) # 预激字生成器，结果保存在_y 中，作为第一个产出的值
except StopIteration as _e: # 3 如果调用的方法抛出StopIteration异常，获取异常对象的value属性，赋值给_r
_r = _e.value
else:
while 1: # 4 运行这个循环时，委派生成器会阻塞，只能作为调用方和子生成器直接的通道
try:
_s = yield _y # 5 产出子生成器当前产出的元素；等待调用方发送_s中保存的值。
# throw与close也从这里传进来
except GeneratorExit as _e: # 捕获关闭的信号
try:
_m = _i.close # 首先想到的是查看子生成器是否有该属性
except AttributeError:
pass # 没有就不操作子生成器
else:
_m() # 如果调用子生成器close() 方法
raise _e # 子生成器正常关闭，把这个关闭信号传递给委派生成器，委派生成器也关了，通道也关了。
except BaseException as _e: # 捕获调用者的throw，里面的异常要给子生成器。
_x = sys.exc_info() # 保存错误信息
try:
_m = _i.throw
except AttributeError: # 子生成器一迭代器，没有throw属性
raise _e # 上浮错误还给委派生成器
else:
try:
_y = _m(*_x) # 让委派生成器取throw扔出这个错误
except StopIteration as _e: # 根据我前面的检查，throw进来的所有信息都会上浮到调用者包括throw(StopIteration)
# 但子生成器自身发出的StopIteration信息应该通过其属性返回值
_r = _e.value
break
else: # 9 如果产出值时没有异常
try: # 10 尝试让子生成器向前执行
if _s is None: # 11. 如果调用者发送的值是None，那么会调用子生成器的 __next__()方法。
_y = next(_i) # 赋值给_y通过循环到循环的开始yield_y输出给调用者
else:
_y = _i.send(_s) # 11. 如果发送的值不是None，把传入的值给子生成器用，并赋值给_y通过循环到循环的开始yield_y输出给调用者。
except StopIteration as _e: # 如果调用的方法抛出StopIteration异常，获取子生成器的return，赋值给_r, 退出循环，委派生成器恢复运行。
_r = _e.value
break
RESULT = _r #13 返回的结果是 _r
上面是完整版的逻辑，从别人处参考，但基本改了很多，我觉的他解释的是错误的。
从这个整体逻辑来看，委派生成器内部会对每一个调用者与子生成器互动的信号进行判断，然后根据信号的不同，执行不同的操作。
当传输关闭信号的时候：先尝试关闭子生成器，然后把自己给关了，真的一个贴心宝宝
当有错误时BaseException，是错误祖宗，委派生成器捕获到throw进来的错误时候，会将错误保存复制后，传递给子生成器。
上面两个yield from的代码我是抄袭书上的，也花了我几天的时候研究，测试。
就我自己的感受yield from就是一个高度封装了很多逻辑，只有一个yield的函数。
16.9使用案例：使用协程做离散时间仿真
如果我能够理解，我独立开辟一篇随笔给自己做笔记。