顶格标注,初学者看这个一定要记住这么几个概念:
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生成的时候,(20年2月28日补充日记,其实就是找不到下一个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: #20年2月29日补充,这个才是真正实现管道的地方,委派生成器确实可以预激活子生成器,但其后面的运行又会产生一个生成器,所以在主函数与子生成器进行交换的时候,还是要先预激活委派生成器
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使用案例:使用协程做离散时间仿真
如果我能够理解,我独立开辟一篇随笔给自己做笔记。