ITPub博客

首页 > 应用开发 > Python > 好程序员Python培训分享深入理解yield from语法

好程序员Python培训分享深入理解yield from语法

原创 Python 作者:好程序员 时间:2020-06-27 23:00:17 0 删除 编辑

  好程序员 Python培训分享 深入理解yield from语法 当你看到这一篇的时候,请确保你对生成器的知识,有一定的了解。当然不了解,也没有关系,你只要花个几分钟的时间,来看下我上一篇文章,就能够让你认识生成器,入门协程了。

再次提醒
本系列所有的代码均在Python3下编写,也建议大家尽快投入到Python3的怀抱中来。

本文目录

·  为什么要使用协程

·  yield from的用法详解

·  为什么要使用yield from

. 为什么要使用协程

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

但一定有许多人,只知道协程是个什么东西,但并不知道为什么要用协程?换句话来说,并不知道在什么情况下用协程?
它相比多线程来说,有哪些过人之处呢?

在开始讲 yield from  之前,我想先解决一下这个给很多人带来困惑的问题。

举个例子。
假如我们做一个爬虫。我们要爬取多个网页,这里简单举例两个网页(两个spider函数),获取HTML(耗IO耗时),然后再对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锁的存在,多线程的运行需要频繁的加锁解锁,切换线程,这极大地降低了并发性能;

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

00001.  协程是在单线程里实现任务的切换的

00002.  利用同步的方式去实现异步

00003.  不再需要锁,提高了并发性能

. 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已经想得这么周到,我们当然要好好利用起来。

讲解它之前,首先要知道这个几个概念

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() 直接发送消息给子生成器,而子生成器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.015.020.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

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

00001.  迭代器(即可指子生成器)产生的值直接返还给调用者

00002.  任何使用send()方法发给委派生产器(即外部生产器)的值被直接传递给迭代器。如果send值是None,则调用迭代器next()方法;如果不为None,则调用迭代器的send()方法。如果对迭代器的调用产生StopIteration异常,委派生产器恢复继续执行yield from后面的语句;若迭代器产生其他任何异常,则都传递给委派生产器。

00003.  子生成器可能只是一个迭代器,并不是一个作为协程的生成器,所以它不支持.throw()和.close()方法,即可能会产生AttributeError 异常。

00004.  除了GeneratorExit 异常外的其他抛给委派生产器的异常,将会被传递到迭代器的throw()方法。如果迭代器throw()调用产生了StopIteration异常,委派生产器恢复并继续执行,其他异常则传递给委派生产器。

00005.  如果GeneratorExit异常被抛给委派生产器,或者委派生产器的close()方法被调用,如果迭代器有close()的话也将被调用。如果close()调用产生异常,异常将传递给委派生产器。否则,委派生产器将抛出GeneratorExit 异常。

00006.  当迭代器结束并抛出异常时,yield from表达式的值是其StopIteration 异常中的第一个参数。

00007.  一个生成器中的return expr语句将会从生成器退出并抛出 StopIteration(expr)异常。

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


来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/69913864/viewspace-2700769/,如需转载,请注明出处,否则将追究法律责任。

请登录后发表评论 登录
全部评论

注册时间:2019-03-20

  • 博文量
    342
  • 访问量
    150012