python---协程理解

推文:python---基础知识回顾(七)迭代器和生成器

推文: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
View Code

关于预激,在使用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 六点重要的说明:

  1. 子生成器产出的值都直接传给委派生成器的调用方(即客户端代码)
  2. 使用send()方法发送给委派生成器的值都直接传给子生成器。如果发送的值为None,那么会给委派调用子生成器的__next__()方法。如果发送的值不是None,那么会调用子生成器的send方法,如果调用的方法抛出StopIteration异常,那么委派生成器恢复运行,任何其他异常都会向上冒泡,传给委派生成器
  3. 生成器退出时,生成器(或子生成器)中的return expr表达式会出发StopIteration(expr)异常抛出
  4. yield from表达式的值是子生成器终止时传给StopIteration异常的第一个参数。yield from 结构的另外两个特性与异常和终止有关。
  5. 传入委派生成器的异常,除了GeneratorExit之外都传给子生成器的throw()方法。如果调用throw()方法时抛出StopIteration异常,委派生成器恢复运行。StopIteration之外的异常会向上冒泡,传给委派生成器
  6. 如果把GeneratorExit异常传入委派生成器,或者在委派生成器上调用close()方法,那么在子生成器上调用clsoe()方法,如果它有的话。如果调用close()方法导致异常抛出,那么异常会向上冒泡,传给委派生成器,否则委派生成器抛出GeneratorExit异常

 

posted @ 2018-06-23 20:09  山上有风景  阅读(1061)  评论(0编辑  收藏  举报