什么是协程

协程

to yield 含义:产出和让步。

yield item这行代码会产出一个值,提供给next(...)的调用方;此外,还会作出让步,暂停执行生成器,让调用方继续工作,直到需要使用另一个值时再调用next()。调用方会从生成器中拉取值。

从根本上把yield视作控制流程的方式,这样就好理解协程了。

将生成器当作一个协程

生成器的调用方可以使用.send(...)方法发送数据,发送的数据会成为生成器函数中yield表达式的值。因此,生成器可以作为协程使用。协程是指一个过程,这个过程与调用方协作,产出由调用方提供的值。

def simple_coroutine():
    print("->coroutine started")
    x = yield # ①
    print("-> coroutine received:", x)

my_coro = simple_coroutine()
next(my_coro)  # ②
my_coro.send(42) # ③

# 输出:
->coroutine started
Traceback (most recent call last):
-> coroutine received: 42
  File "C:/Users/42072/PycharmProjects/day01/ready04/yield_reday.py", line 62, in 
    my_coro.send(42)
StopIteration
  • ① yield在表达式中使用;如果协程只需从客户那里接收数据,那么产出的值是None——这个值是隐式指定的,因为yield关键字右边没有表达式。
  • ② 首先要调用next(...)函数,因为生成器还没启动,没在yield语句处暂停,所以一开始无法发送数据。
  • ③ 调用这个方法后,协程定义体中的yield表达式会计算出42;现在,协程会恢复,一直运行到下一个yield表达式,或者终止。

协程的状态

  1. GEN_CREATED:等待开始执行
  2. GEN_RUNNING:解释器正在执行
  3. GEN_SUSPENDED:在yield表达式处暂停
  4. GEN_CLOSED:执行结束
from inspect import getgeneratorstate

def simple_coroutine():
    print("->coroutine started")
    x = yield
    print(getgeneratorstate(my_coro))
    print("-> coroutine received:", x)

my_coro = simple_coroutine()
print(getgeneratorstate(my_coro))
next(my_coro)
print(getgeneratorstate(my_coro))
my_coro.send(42)
print(getgeneratorstate(my_coro))

注意:

  • 因为send方法的参数会成为暂停的yield表达式的值,所以,仅当协程处于暂停状态时才能调用send方法。
  • 如果给未激活的协程对象发送None以外的值,会引发错误。

激活协程的方式有两种:

  • next(my_coro)方法
  • my_coro.send(None)

示例:协程产出两个值

def simple_coro2(a):
    print('->Started :a = ' ,a)
    b = yield a
    print('->Started :b = ' ,b)
    c = yield a + b
    print('->Received: c=',c)

my_coro2 = simple_coro2(14)
next(my_coro2)
rs1 = my_coro2.send(28)
print(rs1)
rs2 = my_coro2.send(99)
print(rs2)

案例:计算移动平均值

def averager():
    total = 0.0
    count = 0
    average = None

    while True:
        term = yield average
        total += term
        count += 1
        average = total / count

coro_avg = averager()
next(coro_avg)
print(coro_avg.send(10))
print(coro_avg.send(20))
print(coro_avg.send(30))
#输出:
10.0
15.0
20.0

使用协程之前必须预激,可是这一步容易忘记。为了避免忘记,可以在协程上使用一个特殊的装饰器。

  • 额外知识:wraps
作者:hqzxsc2006 
来源:CSDN 
原文:https://blog.csdn.net/hqzxsc2006/article/details/50337865 

Python装饰器(decorator)在实现的时候,被装饰后的函数其实已经是另外一个函数了(函数名等函数属性会发生改变),为了不影响,Python的functools包中提供了一个叫wraps的decorator来消除这样的副作用。写一个decorator的时候,最好在实现之前加上functools的wrap,它能保留原有函数的名称和docstring。

#不加wraps
def my_decorator(func):
    
    def wrapper(*args, **kwargs):
        """decorator"""
        print("Calling decorated function...")
        return func(*args,**kwargs)

    return wrapper

@my_decorator
def example():
    """Docstring"""
    print('Called example function')
    
print(example.__name__,example.__doc__)

#输出:
wrapper decorator


#加wraps

from functools import wraps
def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        """decorator"""
        print("Calling decorated function...")
        return func(*args,**kwargs)

    return wrapper

@my_decorator
def example():
    """Docstring"""
    print('Called example function')
    
print(example.__name__,example.__doc__)

#输出:
example Docstring

预激协程

协程如果不激活,那么则没什么用。调用send()方法之前,需要先调用next(my_coro)方法进行激活。为了简化协程的用法,有时会使用一个预激装饰器。

from functools import wraps


def coroutine(func):
    @wraps(func)
    def primer(*args,**kwargs):
        gen = func(*args,**kwargs)
        next(gen)
        return gen

    return primer


@coroutine
def averager():
    total = 0.0
    count = 0
    average = None

    while True:
        term = yield average
        total += term
        count += 1
        average = total / count

from inspect import getgeneratorstate
coro_avg = averager()
print(getgeneratorstate(coro_avg))
print(coro_avg.send(10))
print(coro_avg.send(30))

输出:
GEN_SUSPENDED
10.0
20.0

如果使用yield from 语法,会自动预激。asyncio.coroutine装饰器不会预激活协程,因此能兼容yield from 句法。

终止协程和异常处理

协程中未处理的异常会向上冒泡,传给next函数或send方法的调用方。

例如:

coro_avg = averager()
print(coro_avg.send(20))
print(coro_avg.send('aa'))

  • 由于第三行发送的不是数据,导致协程内部抛出异常。
  • 由于协程内部没有处理异常,协程会终止。如果试图重新激活协程,会抛出StopIteration异常。

python 2.5以后,客户代码可以调用以下两个方法,显示地把异常发给协程:

  • generator.throw(exec_type[,exc_value[,traceback]])

致使生成器在暂停的yield表达式处抛出指定的异常。如果生成器处理了抛出的异常,代码会向前执行到下一个yield表达式,而产出的值会成为调用generator.throw方法得到的返回值。如果生成器没有处理抛出的异常,异常会向上冒泡,传到调用方的上下文中。

  • generator.close()

致使生成器在暂停的yield表达式处抛出GeneratorExit异常。如果生成器没有处理这个异常,或者抛出了StopIteration异常(通常是指运行到结尾),调用方不会报错。如果收到GeneratorExit异常,生成器一定不能产出值,否则解释器会抛出RuntimeError异常。生成器抛出的其他异常会向上冒泡,传给调用方。

示例:调用

class DemoException(Exception):
    """自定义异常"""

def demo_exc_handling():
    print("-> oroutine started")

    while True:
        try :
            x = yield
        except DemoException:
            print('*** DemoException handled. Continuing...')
        else :
            print('-> coroutine received: {!r}'.format(x))

    raise RuntimeError('永远不执行')

exc_coro = demo_exc_handling()
next(exc_coro)
exc_coro.send(11)
exc_coro.send(22)
exc_coro.close()
from inspect import getgeneratorstate
print(getgeneratorstate(exc_coro))

如果传入 DemoException,则协程会正常处理,并继续运行。

exc_coro = demo_exc_handling()
next(exc_coro)
exc_coro.send(11)
exc_coro.send(22)
# 将 DemoException 传入
exc_coro.throw(DemoException)
from inspect import getgeneratorstate
print(getgeneratorstate(exc_coro))

如果传入的异常没有处理,协程会立即停止,变成'GEN_CLOSED'状态。

exc_coro = demo_exc_handling()
next(exc_coro)
exc_coro.send(11)
exc_coro.send(22)
# 将 DemoException 传入
exc_coro.throw(ZeroDivisionError)
from inspect import getgeneratorstate
print(getgeneratorstate(exc_coro))

如果协程必须做一些清理工作,则可以在协程体中放入 try/finally 代码块。

def demo_finally():
    print('-> coroutine started')
    try:
        while True:
            try:
                x = yield
            except DemoException:
                print('*** DemoException handled. Continuing...')
            else:
                print('-> coroutine received: {!r}'.format(x))
    finally:
        print("->coroutine ending...")

demo_coro = demo_finally();
next(demo_coro)
demo_coro.send(11)
demo_coro.send(ZeroDivisionError)

让协程返回值

协程可以在执行时不产出值,而是在最后返回一个值(通常是累计值)。

例子:一次返回平均值

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)

coro_avg = averager();
next(coro_avg)
coro_avg.send(10)
coro_avg.send(30)
coro_avg.send(20)
coro_avg.send(None)

#输出:
Traceback (most recent call last):
  File "C:/Users/42072/PycharmProjects/day01/ready04/cor.py", line 109, in 
    coro_avg.send(None)
StopIteration: Result(count=3, average=20.0)

发送None会终止循环,导致协程结束,返回结果。一如既往,生成器对象会抛出StopIteration异常。异常对象的value属性保存着返回的值。

coro_avg = averager();
next(coro_avg)
coro_avg.send(10)
coro_avg.send(30)
coro_avg.send(20)
try:
    coro_avg.send(None)
except StopIteration as exc:
    result = exc.value

print(result)

yield from结构会在内部自动捕获StopIteration异常。对yield from结构来说,解释器不仅会捕获StopIteration异常,还会把value属性的值变成yield from表达式的值。

yield from 句法

在生成器gen中使用yield from subgen()时,subgen会获得控制权,把产出的值传给gen的调用方,即调用方可以直接控制subgen。与此同时,gen会阻塞,等待subgen终止。

用来简化for循环中的yield表达式

def gen():
    for c in 'AB':
        yield c

    for i in range(1,3):
        yield i

print(list(gen()))

# 可以改写为:  

def gen():
    yield from 'AB'
    yield from range(1,3)
    
print(list(gen()))

yield from x表达式对x对象所做的第一件事是,调用iter(x),从中获取迭代器。因此,x可以是任何可迭代的对象。

把职责委托给子生成器

yield from 的主要功能是打开双向通道,把最外层的调用方与最内层的子生成器连接起来,这样二者可以直接发送和产出值,还可以直接传入异常,而不用在位于中间的协程中添加大量处理异常的样板代码。通过这个结构,协程可以把功能委托给子生成器。

主要术语:

  1. 委派生成器:
    包含 yield from 表达式的生成器函数。

  2. 子生成器:
    从 yield from 表达式中 部分获取的生成器。

  3. 调用方
    调用委派生成器的客户端代码。

graph LR
调用方-->委派生成器
委派生成器-->子生成器

示例:
计算7年级学生的体重和身高的平均值:

from collections import namedtuple

Result = namedtuple('Result','count average')

# 子生成器
def averager():
    total = 0.0
    count = 0
    average = None

    while True:
        # main 方法中发送的各种值,会绑定到term变量上
        term = yield
        
        # 子生成器终止的条件
        if term is None:
            break

        total += term
        count += 1
        average = total / count
    
    # 返回值会成为grouper中 yield from表达式的值
    return Result(count,average)

# 委派生成器
def grouper(results,key):
    while True:
        # 每次迭代都会生成一个averager实例。每个生成器都是本协程(grouper)使用的生成器对象。
        results[key] = yield from averager()

# 客户端代码
def main(data):
    results = {}
    for key,values in data.items():
        # results 用来存储结果
        group = grouper(results, key)
        # 预激活协程
        next(group)
        for value in values:
            # 发送的每个值都会经由grouper的yield from处理,通过管道传给averager实例。同时,当前的grouper实例,会在yield from 处暂停。
            group.send(value)
        # 把None值传入grouper,导致当前的averager实例终止,并让grouper继续运行,再创建一个aveager实例,处理下一组值。
        group.send(None)
    print(results)

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]
}

main(data)

# 输出:
{'girls;kg': Result(count=10, average=42.040000000000006), 'girls;m': Result(count=10, average=1.4279999999999997), 'boys;kg': Result(count=9, average=40.422222222222224), 'boys;m': Result(count=9, average=1.3888888888888888)}

委派生成器在yield from 表达式处暂停时,调用方可以直接把数据发给子生成器,子生成器再把产出的值发给调用方。子生成器返回之后,解释器会抛出StopIteration异常,并把返回值附加到异常对象上,此时委派生成器会恢复运行。

注意:

  • 如果子生成器不终止,委派生成器会在yield from处永远暂停。
  • 因为委派生成器相当于管道,所以可以把任意数量个委派生成器连接在一起:一个委派生成器使用yield from调用一个子生成器,而那个子生成器本身也是委派生成器,使用yield from调用另一个子生成器,以此类推。最终,这个链条要以一个只使用yield表达式的简单生成器结束;不过,也能以任何可迭代的对象结束。
  • 任何yield from链条都必须由客户驱动,在最外层委派生成器上调用next(...)函数或.send(...)方法。

yield from的意义

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

协程能自然地表述很多算法,例如仿真、游戏、异步I/O,以及其他事件驱动型编程形式或协作式多任务。

案例:出租车运营仿真

import collections
# time 事件发生时间  proc:出租车编号  action:活动描述
Event = collections.namedtuple('Event','time proc action')

# 每辆出租车调用一次该函数,用于创建一个生成器对象,用来表示各辆出租车的运营过程。
# ident是出租车编号
# trips 是出租车回家之前的形成数量
def taxi_process(ident,trips, start_time = 0):
    """每次改变状态时创建事件,把控制权让给仿真器"""

    # 离开停车场事件,执行到此,会暂停。当需要重新激活这个进程时,主循环会使用send方法发送当前的仿真事件赋值给time
    time = yield Event(start_time,ident,'leave garage')

    #每次行程都会执行一遍此处的代码块
    for i in range(trips):
        # 产生一个Event实例,表示拉到乘客了。协程在这里会暂停,需要激活时,主循环会使用send方法发送当前时间。
        time = yield Event(time,ident,'pick up passenger')
        time = yield Event(time,ident,'drop off passenger')

    # 指定行程数量完成后,产生回家事件。此处,协程最后一次暂停。
    yield Event(time,ident,'going home')


taxi = taxi_process(ident=12,trips=2,start_time=0)
next(taxi)
print(taxi.send( 7))
print(taxi.send(10))
print(taxi.send(15))
print(taxi.send(25))
print(taxi.send(35))

# 输出:
Event(time=7, proc=12, action='pick up passenger')
Event(time=10, proc=12, action='drop off passenger')
Event(time=15, proc=12, action='pick up passenger')
Event(time=25, proc=12, action='drop off passenger')
Event(time=35, proc=12, action='going home')

你可能感兴趣的:(什么是协程)