深刻理解Python的yield from語法

時間  2019-11-15
標籤 深刻 理解 python yield 語法 欄目 Python 简体版
原文   原文鏈接


做者：MING
我的公衆號：Python編程時光
我的微信：mrbensonwonhtml

你們好，併發編程 進入第八篇。python

注：本系列已在微信公衆號更新完成。查看最新文章，請關注公衆號獲取。程序員


直到上一篇，咱們終於迎來了Python併發編程中，最高級、最重要、固然也是最難的知識點之一（協程）。編程

當你看到這一篇的時候，請確保你對生成器的知識，有必定的瞭解。固然不瞭解，也沒有關係，你只要花個幾分鐘的時間，來看下我上一篇文章，就可以讓你認識生成器，入門協程了。bash

再次提醒：
本系列全部的代碼均在Python3下編寫，也建議你們儘快投入到Python3的懷抱中來。微信


爲何要使用協程

在上一篇中，咱們從生成器的基本認識與使用，成功過渡到了協程。多線程

但必定有許多人，只知道協程是個什麼東西，但並不知道爲何要用協程？換句話來講，並不知道在什麼狀況下用協程？
它相比多線程來講，有哪些過人之處呢？併發

在開始講yield from 以前，我想先解決一下這個給不少人帶來困惑的問題。異步

舉個例子。
假如咱們作一個爬蟲。咱們要爬取多個網頁，這裏簡單舉例兩個網頁(兩個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教程