Python中怎么理解yield from語法

本篇內容介紹了“Python中怎么理解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

                breakRESULT = _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)異常。

“Python中怎么理解yield from語法”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！