Python 并发编程之 yield from 语法

深藏阁楼爱情的钟 2023-06-19 01:54 76阅读 0赞

## 本文目录 ##

--------------------

*  为什么要使用协程
 *  yield from 的用法详解
 *  为什么要使用 yield from

## ##

### 为什么要使用协程 ###

举个例子，假如我们做一个爬虫，要爬取多个网页。

这里简单举例，爬取两个网页( 两个 spider 函数 )：第一步，获取HTML，然后再对 HTML 进行解析并取得我们感兴趣的数据。

代码结构精简如下：

def spider_01(url):
        html = get_html(url)
        ...
        data = parse_html(html)
    
    def spider_02(url):
        html = get_html(url)
        ...
        data = parse_html(html)

我们都知道，`get_html()` 获取网页内容是非常耗 IO 的，一个网页还好，如果我们爬取的网页数据极其庞大，这个等待时间就非常惊人，是极大的浪费。

聪明的我们当然会想，如果能在 `get_html()`这里暂停一下，不用傻乎乎地去等待目标网页返回数据，而是去做别的事情，等过段时间，回过头来到刚刚暂停的地方，接收返回的 html 内容，然后去执行 `parse_html(html)` 解析网页获取数据。

利用常规的方法，几乎是没办法实现如上我们想要的效果的。所以 Python 从语言本身给我们实现了这样的功能，利用 yield 语法就可以在某一函数中实现暂停的效果。

试着思考一下，假如没有协程，我们要写一个并发程序。可能有以下问题：

> 1.  使用最常规的同步编程要实现异步并发效果并不理想，或者难度极高；
> 2.  由于GIL锁的存在，多线程的运行需要频繁的加锁解锁，切换线程，这极大地降低了并发性能；

而协程的出现，刚好可以解决以上的问题。它的特点有：

> 1.  协程是在单线程里实现任务的切换的；
> 2.  利用同步的方式去实现异步；
> 3.  不再需要锁，提高了并发性能；

## ##

### yield from 的用法详解 ###

`yield from`  是在 Python3.3 才出现的语法。所以这个特性在 Python2 中是没有的。

`yield from` 后面需要加的是可迭代对象，它可以是普通的可迭代对象，也可以是迭代器，甚至是生成器。

**简单应用：拼接可迭代对象**

我们可以用一个使用`yield` 和一个使用`yield from` 的例子来对比看下。

使用`yield :`

# 字符串
    astr='ABC'
    # 列表
    alist=[1,2,3]
    # 字典
    adict={"name":"syztoo","age":18}
    # 生成器
    agen=(i for i in range(4,8))
    
    def gen(*args, **kw):
        for item in args:
            for i in item:
                yield i
    
    new_list=gen(astr, alist, adict， agen)
    print(list(new_list))
    # ['A', 'B', 'C', 1, 2, 3, 'name', 'age', 4, 5, 6, 7]

使用`yield from :`

# 字符串
    astr='ABC'
    # 列表
    alist=[1,2,3]
    # 字典
    adict={"name":"syztoo","age":18}
    # 生成器
    agen=(i for i in range(4,8))
    
    def gen(*args, **kw):
        for item in args:
            yield from item
    
    new_list=gen(astr, alist, adict, agen)
    print(list(new_list))
    # ['A', 'B', 'C', 1, 2, 3, 'name', 'age', 4, 5, 6, 7]

由上面两种方式对比，可以看出，yield from 后面加上可迭代对象，他可以把可迭代对象里的每个元素一个一个的 yield 出来，对比 yield 来说，代码更加简洁，结构更加清晰。

**复杂应用：生成器的嵌套**

如果你认为 `yield from` 仅仅只有上述的功能的话，那你就太小瞧了它。

当 `yield from` 后面加上一个生成器后，就实现了生成的嵌套。

当然实现生成器的嵌套，并不是一定必须要使用`yield from`，而是使用`yield from` 可以让我们避免各种料想不到的异常，只专注于业务代码的实现。

如果自己用`yield` 去实现，那只会加大代码的编写难度，降低开发效率，降低代码的可读性。

讲解生成器的嵌套之前，首先要知道几个概念

> 1.  `调用方`：调用委托生成器的客户端代码
> 2.  `委托生成器`：包含 yield from 表达式的生成器函数
> 3.  `子生成器`：yield from 后面的生成器函数

你可能不知道他们都是什么意思，没关系，来看下面这个栗子。

一个返回实时平均数的栗子，比如：

*  第一次传入10，就返回平均数 10；
 *  第二次传入20，则返回平均数 (10+20)/2=15；
 *  第三次传入30，则返回平均数 (10+20+30)/3=20；

代码如下：

# 子生成器
    def average_gen():
        total = 0
        count = 0
        average = 0
        while True:
            new_num = yield average
            count += 1
            total += new_num
            average = total/count
    
    # 委托生成器
    def proxy_gen():
        while True:
            yield from average_gen()
    
    # 调用方
    def main():
        calc_average = proxy_gen()
        next(calc_average)            # 预激下生成器
        print(calc_average.send(10))  # 打印：10.0
        print(calc_average.send(20))  # 打印：15.0
        print(calc_average.send(30))  # 打印：20.0
    
    if __name__ == '__main__':
        main()

认真阅读以上代码，你应该很容易能理解，调用方、委托生成器、子生成器之间的关系。

**委托生成器的作用是**：在调用方与子生成器之间建立一个`双向通道`。

所谓的双向通道是什么意思呢？  
调用方可以通过 `send(n)`直接发送消息给子生成器，而子生成器 yield 返回的值，也是直接返回给调用方。

你可能会经常看到有些代码，还可以在`yield from` 前面看到可以赋值。这是什么用法？

你可能会以为，子生成器 yield 回来的值，被委托生成器给拦截了。你可以亲自写个 demo 运行试验一下，并不是你想的那样。  
因为我们之前说了，委托生成器，只起一个桥梁作用，它建立的是一个`双向通道`，它并没有权利也没有办法，对子生成器 yield 回来的内容做拦截。

为了解释这个用法，还是用上述的例子，并对其进行了一些改造。

# 子生成器
    def average_gen():
        total = 0
        count = 0
        average = 0
        while True:
            new_num = yield average
            if new_num is None:
                break
            count += 1
            total += new_num
            average = total/count
    
        # 每一次return，都意味着当前协程结束。
        return total,count,average
    
    # 委托生成器
    def proxy_gen():
        while True:
            # 只有子生成器要结束（return）了，yield from 左边的变量才会被赋值，后面的代码才会执行。
            total, count, average = yield from average_gen()
            print("计算完毕！！\n总共传入 %s 个数值, 总和: %s, 平均数: %s" % (count,total,average) )
    
    # 调用方
    def main():
        calc_average = proxy_gen()
        next(calc_average)            # 预激协程
        print(calc_average.send(10))  # 打印：10.0
        print(calc_average.send(20))  # 打印：15.0
        print(calc_average.send(30))  # 打印：20.0
        calc_average.send(None)      # 结束协程
        # 如果此处再调用calc_average.send(10)，由于上一协程已经结束，将重开一协程
    
    if __name__ == '__main__':
        main()

运行后，输出

10.0
    15.0
    20.0
    计算完毕！！
    总共传入 3 个数值, 总和: 60, 平均数: 20.0

## ##

### 为什么要使用 yield from ###

既然委托生成器，只是起一个双向通道的作用，那么我们还需要委托生成器做什么？调用方直接调用子生成器不就好啦，为什么要那么麻烦？

高能预警~~~

因为它可以帮我们处理异常。

如果我们去掉委托生成器，而直接调用子生成器，那我们就需要自己捕获异常并处理，代码需要改成像下面这样：

# 子生成器
    def average_gen():
        total = 0
        count = 0
        average = 0
        while True:
            new_num = yield average
            if new_num is None:
                break
            count += 1
            total += new_num
            average = total/count
        return total,count,average
    
    # 调用方
    def main():
        calc_average = average_gen()
        next(calc_average)            # 预激协程
        print(calc_average.send(10))  # 打印：10.0
        print(calc_average.send(20))  # 打印：15.0
        print(calc_average.send(30))  # 打印：20.0
    
        # ----------------注意-----------------
        try:
            calc_average.send(None)
        except StopIteration as e:
            total, count, average = e.value
            print("计算完毕！！\n总共传入 %s 个数值, 总和: %s, 平均数: %s" % (count,total,average) )
    
        # ----------------注意-----------------
    
    if __name__ == '__main__':
        main()

其实不止一个`StopIteration` 异常，`yield from`在背后默默无闻地做了许多事。

具体做了哪些事，可以参考如下这段代码：

#一些说明
    """
    _i：子生成器，同时也是一个迭代器
    _y：子生成器生产的值
    _r：yield from 表达式最终的值
    _s：调用方通过send()发送的值
    _e：异常对象
    """
    
    _i = iter(EXPR)
    
    try:
        _y = next(_i)
    except StopIteration as _e:
        _r = _e.value
    
    else:
        while 1:
            try:
                _s = yield _y
            except GeneratorExit as _e:
                try:
                    _m = _i.close
                except AttributeError:
                    pass
                else:
                    _m()
                raise _e
            except BaseException as _e:
                _x = sys.exc_info()
                try:
                    _m = _i.throw
                except AttributeError:
                    raise _e
                else:
                    try:
                        _y = _m(*_x)
                    except StopIteration as _e:
                        _r = _e.value
                        break
            else:
                try:
                    if _s is None:
                        _y = next(_i)
                    else:
                        _y = _i.send(_s)
                except StopIteration as _e:
                    _r = _e.value
                    break
    RESULT = _r

以上的代码，稍微有点复杂，有兴趣的同学可以结合以下说明去研究看看。

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

没兴趣看的同学，只要知道，`yield from` 帮我们做了很多的异常处理，而且全面。而这些如果我们要自己去实现的话，编写代码难度增加，写出来的代码可读性极差，这些我们就不说了，最主要的是很可能有遗漏，只要哪个异常没考虑到，都有可能导致程序崩溃什么的。