python-复盘-协程yield from 彻底详解yield from/asyncio异步io/协程最简例子

字数 1796阅读 1285

Python3.3版本的PEP 380中添加了yield from语法,允许一个generator生成器将其部分操作委派给另一个生成器。其产生的主要动力在于使生成器能够很容易分为多个拥有sendthrow方法的子生成器,像一个大函数可以分为多个子函数一样简单。Python的生成器是协程coroutine的一种形式,但它的局限性在于只能向它的直接调用者yield值。这意味着那些包含yield的代码不能想其他代码那样被分离出来放到一个单独的函数中。这也正是yield from要解决的。
虽然【yield from主要设计用来向子生成器委派操作任务】,但yield from可以向任意的迭代器委派操作;
对于简单的迭代器,yield from iterable本质上等于for item in iterable: yield item的缩写版,如下所示:

>>> def g(x):
...     yield from range(x, 0, -1)
...     yield from range(x)
...
>>> list(g(5))
[5, 4, 3, 2, 1, 0, 1, 2, 3, 4]

然而,不同于普通的循环,yield from允许子生成器直接从调用者接收其发送的信息或者抛出调用时遇到的异常,并且返回给委派生产器一个值,如下所示:

>>> def accumulate():    # 子生成器,将传进的非None值累加,传进的值若为None,则返回累加结果
...     tally = 0        # 由于for循环被分配到子生成器去执行,tally不断的累加
...     while 1:
...         next = yield
...         if next is None:
...             return tally
...         tally += next
...
>>> def gather_tallies(tallies):    # 外部生成器,将累加操作任务委托给子生成器
...     while 1:
...         tally = yield from accumulate()   # 这里for 会先执行完 accumulate()后再from,把item 给yield,注意⚠️程序执行顺序
...         tallies.append(tally)   #  由于子生成器累加后才把值append过来,所以最后结果是[6,10]
...
>>> tallies = []
>>> acc = gather_tallies(tallies)
>>> next(acc)    # 使累加生成器准备好接收传入值
>>> for i in range(4):   # 这个for循环针对的是acc,按理说for循环作用于外部生成器,但实际上,for 作用于子生成器,也就是上面说的 yield from 主要设计用来向子生成器委派操作任务的
...     acc.send(i)
...
>>> acc.send(None)    # 结束第一次累加
>>> for i in range(5):
...     acc.send(i)
...
>>> acc.send(None)    # 结束第二次累加
>>> tallies    # 输出最终结果
[6, 10]  

总结如下:

  1. 迭代器(即可指子生成器)产生的值直接返还给调用者
  2. 任何使用send()方法发给委派生产器(即外部生产器)的值被直接传递给迭代器。如果send值是None,则调用迭代器next()方法;如果不为None,则调用迭代器的send()方法。如果对迭代器的调用产生StopIteration异常,委派生产器恢复继续执行yield from后面的语句;若迭代器产生其他任何异常,则都传递给委派生产器。
  3. 除了GeneratorExit 异常外的其他抛给委派生产器的异常,将会被传递到迭代器的throw()方法。如果迭代器throw()调用产生了StopIteration异常,委派生产器恢复并继续执行,其他异常则传递给委派生产器。
  4. 如果GeneratorExit异常被抛给委派生产器,或者委派生产器的close()方法被调用,如果迭代器有close()的话也将被调用。如果close()调用产生异常,异常将传递给委派生产器。否则,委派生产器将抛出GeneratorExit 异常。
  5. 当迭代器结束并抛出异常时,yield from表达式的值是其StopIteration 异常中的第一个参数。
  6. 一个生成器中的return expr语句将会从生成器退出并抛出 StopIteration(expr)异常。

stackoverflow上的经典解释

将yield from视为提供了一个调用者和子生成器之间的透明的双向通道。包括从子生成器获取数据以及向子生成器传送数据

1. 利用yield from从生成器读取数据

def reader():
    # 模拟从文件读取数据的生成器
    for i in range(4):
        yield '<< %s' % i

def reader_wrapper(g):
    # 循环迭代从reader产生的数据 
    for v in g:
        yield v

wrap = reader_wrapper(reader())
for i in wrap:
    print(i)

# 结果:
<< 0
<< 1
<< 2
<< 3

我们可以用yield from语句替代reader_wrapper(g)函数中的循环,如下:

def reader_wrapper(g):
    yield from g

2.利用yield from语句向生成器(协程)传送数据

首先创建一个生成器writer,接收传送给它的数据,并写进套接字,文件等;

def writer():
    # 读取send传进的数据,并模拟写进套接字或文件
    while True:
        w =  yield    # w接收send传进的数据
        print('>> ', w)

现在的问题是,包装器函数如何传送数据给writer函数,使得传递给包装器的数据都能够显示地传递给writer函数?!
即我们期待得到如下结果:

def writer_wrapper(coro):
    # TBD
    pass

w = writer()
wrap = writer_wrapper(w)
wrap.send(None)  # 生成器准备好接收数据
for i in range(4):
    wrap.send(i)

# 期望结果:
>>  0
>>  1
>>  2
>>  3

我们可以用yield from语句替代reader_wrapper(g)函数中的循环,如下:

def reader_wrapper(g):
    yield from g

效果一样,且代码更简洁有没有。

2.利用yield from语句向生成器(协程)传送数据

首先创建一个生成器writer,接收传送给它的数据,并写进套接字,文件等;

def writer():
    # 读取send传进的数据,并模拟写进套接字或文件
    while True:
        w = (yield)    # w接收send传进的数据
        print('>> ', w)

现在的问题是,包装器函数如何传送数据给writer函数,使得传递给包装器的数据都能够显示地传递给writer函数?!

即我们期待得到如下结果:

def writer_wrapper(coro):
    # TBD
    pass

w = writer()
wrap = writer_wrapper(w)
wrap.send(None)  # 生成器准备好接收数据
for i in range(4):
    wrap.send(i)

# 期望结果:
>>  0
>>  1
>>  2
>>  3

很显然,包装区需要接收数据并显示传递给生成器,并且需要处理for循环耗尽是生成器产生的StopIteration异常,显然包装器只用for循环已经不能满足需求,满足情况的一般版本如下:

def writer_wrapper(coro1):
    coro1.send(None)  # 生成器准备好接收数据
    while True:
        try:
            x = (yield)  # x接收send传进的数据
            coro1.send(x)  # 然后将x在send给writer子生成器
        except StopIteration:    # 处理子生成器返回的异常
            pass

包装器也是个生成器,上面所有复杂的写法也可以用yield from替换:

def writer_wrapper(coro2):
    yield from coro2

一下子少了好多代码,是不是见证了奇迹!

3. 利用yield from向生成器传送数据–处理异常

更进一步,如果我们的子生成器即writer需要处理异常该怎么办?假设writer需要处理SpamException异常,遇到这个异常打印***,代码如下:

class SpamException(Exception):
    pass

def writer():
    while True:
        try:
            w = (yield)
        except SpamException:
            print('***')
        else:
            print('>> ', w)

如果使用上一个一般版本的包装器writer_wrapper(coro1),会有什么结果?试验如下:

w = writer()
wrap = writer_wrapper(w)
wrap.send(None)  # "prime" the coroutine
for i in [0, 1, 2, 'spam', 4]:
    if i == 'spam':
        wrap.throw(SpamException)
    else:
        wrap.send(i)

# 期望结果:
>>  0
>>  1
>>  2
***
>>  4

# 实际结果:
>>  0
>>  1
>>  2
Traceback (most recent call last):
  File ... in <module>
    wrap.throw(SpamException)
  File ... in writer_wrapper
    x = (yield)
__main__.SpamException

可以看出,这行不通,因为x = (yield)语句仅能够引发异常,然后停止运行。我们可以手工在包装器writer_wrapper(coro1)中添加异常处理,并传递或者抛出异常给子生成器writer,代码如下:

def writer_wrapper(coro1):
    # 手工处理异常被抛给子生成器
    coro1.send(None)    # 生成器准备好接收数据
    while True:
        try:
            try:
                x = (yield)
            except Exception as e:   # 捕获异常
                coro1.throw(e)
            else:
                coro1.send(x)
        except StopIteration:
            pass

同样的,这一堆复杂的代码,也可以用yield from语句替换,并且功能完全一样!!!

def writer_wrapper(coro):
    yield from coro

重要的代码贴三遍!三遍!三遍!

看到这里,大概能理解yield from显示处理传值给子生成器以及抛出异常给子生成器的意思了吧。
当然yield from不仅有这两个处理情况,还有之前我们提到的:外部生成器关闭,子生成器也会关闭;子生成器返回一个值得情况(上文第二个代码例子),等等。

总之,这是一个魔法语句,它也是协程的重要组成部分,至于协程,还需要继续学习。

原文:
yield from主要有什么用?



协程最简单易懂小例子(补)

Python中的协程和生成器很相似但又稍有不同。主要区别在于:

生成器是数据的生产者
协程则是数据的消费者
Python实现的grep就是个很好的例子:

    def grep(pattern):
        print("Searching for", pattern)
        while True:
            line = (yield)       # 接受消息,消息中有pattern就print(line)
            if pattern in line:
                print(line)

等等!yield返回了什么?啊哈,我们已经把它变成了一个协程。它将不再包含任何初始值,相反要从外部传值给它。我们可以通过
send() 方法向它传值。这有个例子:

    search = grep('coroutine')
    next(search)
    #output: Searching for coroutine
    search.send("I love you")
    search.send("Don't you love me?")
    search.send("I love coroutine instead!")
    #output: I love coroutine instead!

发送的值会被yield接收。我们为什么要运行next()方法呢?这样做正是为了启动一个协程。就像协程中包含的生成器并不是立刻执行,而是通过next()方法来响应send()方法。因此,你必须通过next()方法来执行yield表达式。

我们可以通过调用close()方法来关闭一个协程。像这样:

    search = grep('coroutine')
    search.close()

推荐阅读更多精彩内容