本文目錄

為什麼要使用協程
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文法。可以實作在某一函數中暫停的效果。

試着思考一下，假如沒有協程，我們要寫一個并發程式。可能有以下問題:

使用最正常的同步程式設計要實作異步并發效果并不理想，或者難度極高。
由于GIL鎖的存在，多線程的運作需要頻繁的加鎖解鎖，切換線程，這極大地降低了并發性能；

而協程的出現，剛好可以解決以上的問題。它的特點有:
協程是在單線程裡實作任務的切換的
利用同步的方式去實作異步
不再需要鎖，提高了并發性能

簡單應用：拼接可疊代對象

我們可以用一個使用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 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

以上的代碼，稍微有點複雜，有興趣的同學可以結合以下說明去研究看看

疊代器（即可指子生成器）産生的值直接返還給調用者
任何使用send()方法發給委派生産器（即外部生産器）的值被直接傳遞給疊代器。如果send值是None，則調用疊代器next()方法；如果不為None，則調用疊代器的send()方法。如果對疊代器的調用産生StopIteration異常，委派生産器恢複繼續執行yield from後面的語句；若疊代器産生其他任何異常，則都傳遞給委派生産器。
子生成器可能隻是一個疊代器，并不是一個作為協程的生成器，是以它不支援.throw()和.close()方法,即可能會産生AttributeError 異常。
除了GeneratorExit 異常外的其他抛給委派生産器的異常，将會被傳遞到疊代器的throw()方法。如果疊代器throw()調用産生了StopIteration異常，委派生産器恢複并繼續執行，其他異常則傳遞給委派生産器。
如果GeneratorExit異常被抛給委派生産器，或者委派生産器的close()方法被調用，如果疊代器有close()的話也将被調用。如果close()調用産生異常，異常将傳遞給委派生産器。否則，委派生産器将抛出GeneratorExit 異常。
當疊代器結束并抛出異常時，yield from表達式的值是其StopIteration 異常中的第一個參數。
一個生成器中的return expr語句将會從生成器退出并抛出 StopIteration(expr)異常。

沒興趣看的同學，隻要知道，yield from幫我們做了很多的異常處理，而且全面，而這些如果我們要自己去實作的話，一個是編寫代碼難度增加，寫出來的代碼可讀性極差，這些我們就不說了，最主要的是很可能有遺漏，隻要哪個異常沒考慮到，都有可能導緻程式崩潰什麼的。

深入了解yield from文法本文目錄

本文目錄

為什麼要使用協程

簡單應用：拼接可疊代對象

複雜應用：生成器的嵌套

為什麼使用yield from

因為它可以幫我們處理異常

繼續閱讀

來自python的【條件控制/語句循環/break/continue/else/pass】一、條件控制二、語句循環

無法解析的外部符号 wmain，該符号在函數 "void cdecl mainCRTStartupHelper(struct HINSTANCE *,unsigned short con......

TestLink導出用例轉換工具(XML2Excel)

YAML簡介和PyYAML安全操作YAML支援的類型YAML的優點：yaml的基本文法python操作

Small tricks

libsvm for python 安裝

學習軟體測試基礎測試第七天

Zeppelin 配置通路 REST APIApache Zeppelin Configuration REST API

【Torch】最簡潔logging使用指南

27. Remove Element(清單)題目代碼

Cloud Studio初體驗

使用 ctypes 進行 Python 和 C 的混合程式設計

【python】【資料處理】畫多元資料分布圖

【python】netconf協定對接管理裝置

「Python 網絡自動化」NETCONF —— Python 使用 NETCONF 管理配置 H3C 網絡裝置

在python中建立excel并寫入