Python并发编程之深刻理解yield from语法（八）

时间  2019-11-12
标签 python 并发 编程 深刻 理解 yield 语法 栏目 Python 繁體版
原文   原文链接

你们好，并发编程 进入第八篇。html

直到上一篇，咱们终于迎来了Python并发编程中，最高级、最重要、固然也是最难的知识点--协程。python

当你看到这一篇的时候，请确保你对生成器的知识，有必定的了解。固然不了解，也没有关系，你只要花个几分钟的时间，来看下我上一篇文章，就可以让你认识生成器，入门协程了。程序员

再次提醒：
本系列全部的代码均在Python3下编写，也建议你们尽快投入到Python3的怀抱中来。编程

本文目录

  • 为何要使用协程
  • yield from的用法详解
  • 为何要使用yield from

. 为何要使用协程

在上一篇中，咱们从生成器的基本认识与使用，成功过渡到了协程。多线程

但必定有许多人，只知道协程是个什么东西，但并不知道为何要用协程？换句话来讲，并不知道在什么状况下用协程？
它相比多线程来讲，有哪些过人之处呢？并发

在开始讲yield from 以前，我想先解决一下这个给不少人带来困惑的问题。app

举个例子。
假如咱们作一个爬虫。咱们要爬取多个网页，这里简单举例两个网页(两个spider函数)，获取HTML（耗IO耗时），而后再对HTML对行解析取得咱们感兴趣的数据。异步

咱们的代码结构精简以下：ide

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":"wangbm","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":"wangbm","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去实现，那只会加大代码的编写难度，下降开发效率，下降代码的可读性。既然Python已经想得这么周到，咱们固然要好好利用起来。

讲解它以前，首先要知道这个几个概念

一、调用方：调用委派生成器的客户端（调用方）代码
二、委托生成器：包含yield from表达式的生成器函数
三、子生成器：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()直接发送消息给子生成器，而子生成器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总共传入 {} 个数值， 总和：{}，平均数：{}".format(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

学到这里，我相信你确定要问，既然委托生成器，起到的只是一个双向通道的做用，我还须要委托生成器作什么？我调用方直接调用子生成器不就好啦？

高能预警~~~

下面咱们来一块儿探讨一下，到底yield from 有什么过人之处，让咱们非要用它不可。

由于它能够帮咱们处理异常

若是咱们去掉委托生成器，而直接调用子生成器。那咱们就须要把代码改为像下面这样，咱们须要本身捕获异常并处理。而不像使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总共传入 {} 个数值， 总和：{}，平均数：{}".format(count, total, average))
    # ----------------注意-----------------

if __name__ == '__main__':
    main()

此时的你，可能会说，不就一个StopIteration的异常吗？本身捕获也没什么大不了的。

你要是知道yield from在背后为咱们默默无闻地作了哪些事，你就不会这样说了。

具体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()方法发给委派生产器（即外部生产器）的值被直接传递给迭代器。若是send值是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帮咱们作了不少的异常处理，并且全面，而这些若是咱们要本身去实现的话，一个是编写代码难度增长，写出来的代码可读性极差，这些咱们就不说了，最主要的是极可能有遗漏，只要哪一个异常没考虑到，都有可能致使程序崩溃什么的。

好了，今天就讲这些。

关注公众号，获取最新文章
关注公众号，获取最新文章
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程