原創不易，轉載請聯絡作者

深入理解協程分為三部分進行講解：

• 協程的引入
  
• yield from實現非同步協程
  
• async/await實現非同步協程

本篇為深入理解協程系列文章的第二篇。

yield from

yield from是Python3.3（PEP 380）引入的新語法。主要用於解決在生成器中不方便使用生成器的問題。主要有兩個功能。

第一個功能：讓巢狀生成器不必再通過迴圈迭代yield，而可以直接使用yield from。

看一段程式碼：

titles = ['Python', 'Java', 'C++']
def func1(titles):
    yield titles

def func2(titles):
    yield from titles

for title in func1(titles):
    print(title)

for title in func2(titles):
    print(title)
    
# 輸出結果
['Python', 'Java', 'C++']
Python
Java
C++
 

yield返回的完整的titles列表，而yield from返回的是列表中的具體元素。yield from可以看作是for title in titles: yield title的縮寫。這樣就可以用yield from減少了一次迴圈。

第二個功能：開啟雙向通道，把最外層給呼叫方與最內層的子生成器連結起來，二者可以直接通訊。

第二個功能聽起來就讓人頭大。我們再舉一個例子進行說明：

【舉個例子】：通過生成器實現整數相加，通過send()函式想生成器中傳入要相加的數字，最後傳入None結束相加。total儲存結果。

def generator_1():      # 子生成器
    total = 0
    while True:
        x = yield       # 解釋4
        print(f'+ {x}')
        if not x:
            break
        total += x
    return total        # 解釋5

def generator_2():      # 委託生成器
    while True:
        total = yield from generator_1()    # 解釋3
        print(f'total: {total}')

if __name__ == '__main__':      # 呼叫方
    g2 = generator_2()      # 解釋1
    g2.send(None)           # 解釋2
    g2.send(2)              # 解釋6
    g2.send(3)              
    g2.send(None)           # 解釋7

# 輸出結果
+ 2
+ 3
+ None
total: 5
 

說明：

解釋1：g2是呼叫generator_2()得到的生成器物件，作為協程使用。

解釋2：預啟用協程g2。

解釋3：generator_2接收的值都會經過yield from處理，通過管道傳入generator_1例項。generator_2會在yield from處暫停，等待generator_1例項傳回的值賦值給total。

解釋4：呼叫方傳入的值都會傳到這裡。

解釋5：此處返回的total正是generator_2()中解釋3處等待返回的值。

解釋6：傳入2進行計算。

解釋7：在計算的結尾傳入None，跳出generator_1()的迴圈，結束計算。

說到這裡，相信看過《深入理解協程（一）：協程的引入》的朋友應該就容易理解上面這段程式碼的執行流程了。

藉助上面例子，說明一下隨yield from一起引入的3個概念：

• 子生成器

  從yield from獲取任務並完成具體實現的生成器。

• 委派生成器

  包含有 yield from表示式的生成器函式。負責給子生成器委派任務。

• 呼叫方

  指呼叫委派生成器的客戶端程式碼。

在每次呼叫send(value)時，value不是傳遞給委派生成器，而是藉助yield from將value傳遞給了子生成器的yield。

結合asyncio實現非同步協程

asyncio是Python 3.4 試驗性引入的非同步I/O框架（PEP 3156），提供了基於協程做非同步I/O編寫單執行緒併發程式碼的基礎設施。其核心元件有事件迴圈（Event Loop）、協程(Coroutine）、任務(Task)、未來物件(Future)以及其他一些擴充和輔助性質的模組。

在引入asyncio的時候，還提供了一個裝飾器@asyncio.coroutine用於裝飾使用了yield from的函式，以標記其為協程。

在實現非同步協程之前，我們先看一個同步的案例：

import time
def taskIO_1():
    print('開始執行IO任務1...')
    time.sleep(2)  # 假設該任務耗時2s
    print('IO任務1已完成，耗時2s')
def taskIO_2():
    print('開始執行IO任務2...')
    time.sleep(3)  # 假設該任務耗時3s
    print('IO任務2已完成，耗時3s')

start = time.time()
taskIO_1()
taskIO_2()
print('所有IO任務總耗時%.5f秒' % float(time.time()-start))
# 輸出結果
開始執行IO任務1...
IO任務1已完成，耗時2s
開始執行IO任務2...
IO任務2已完成，耗時3s
所有IO任務總耗時5.00094秒

可以看到，使用同步的方式實現多個IO任務的時間是分別執行這兩個IO任務時間的總和。

下面我們使用yield from與asyncio將上面的同步程式碼改成非同步的。修改結果如下：

import time
import asyncio

@asyncio.coroutine # 解釋1
def taskIO_1():
    print('開始執行IO任務1...')
    yield from asyncio.sleep(2)  # 解釋2
    print('IO任務1已完成，耗時2s')
    return taskIO_1.__name__

@asyncio.coroutine 
def taskIO_2():
    print('開始執行IO任務2...')
    yield from asyncio.sleep(3)  # 假設該任務耗時3s
    print('IO任務2已完成，耗時3s')
    return taskIO_2.__name__

@asyncio.coroutine 
def main(): # 呼叫方
    tasks = [taskIO_1(), taskIO_2()]  # 把所有任務新增到task中
    done,pending = yield from asyncio.wait(tasks) # 子生成器
    for r in done: # done和pending都是一個任務，所以返回結果需要逐個呼叫result()
        print('協程無序返回值：'+r.result())

if __name__ == '__main__':
    start = time.time()
    loop = asyncio.get_event_loop() # 建立一個事件迴圈物件loop
    try:
        loop.run_until_complete(main()) # 完成事件迴圈，直到最後一個任務結束
    finally:
        loop.close() # 結束事件迴圈
    print('所有IO任務總耗時%.5f秒' % float(time.time()-start))
    
# 輸出結果
開始執行IO任務2...
開始執行IO任務1...
IO任務1已完成，耗時2s
IO任務2已完成，耗時3s
協程無序返回值：taskIO_1
協程無序返回值：taskIO_2
所有IO任務總耗時3.00303秒

說明：

解釋1：@asyncio.coroutine裝飾器是協程函式的標誌，我們需要在每一個任務函式前加這個裝飾器，並在函式中使用yield from。

解釋2：此處假設該任務執行需要2秒，此處使用非同步等待2秒asyncio.sleep(2)，而非同步等待time.sleep(2)。

執行過程：

1. 先通過get_event_loop()獲取了一個標準事件迴圈loop(因為是一個，所以協程是單執行緒)
2. 然後，我們通過run_until_complete(main())來執行協程(此處把呼叫方協程main()作為引數，呼叫方負責呼叫其他委託生成器)，run_until_complete的特點就像該函式的名字，直到迴圈事件的所有事件都處理完才能完整結束.
3. 進入呼叫方協程，我們把多個任務[taskIO_1()和taskIO_2()]放到一個task列表中，可理解為打包任務。
4. 我們使用asyncio.wait(tasks)來獲取一個awaitable objects即可等待物件的集合，通過yield from返回一個包含(done, pending)的元組，done表示已完成的任務列表，pending表示未完成的任務列表。
5. 因為done裡面有我們需要的返回結果，但它目前還是個任務列表，所以要取出返回的結果值，我們遍歷它並逐個呼叫result()取出結果即可。
6. 最後我們通過loop.close()關閉事件迴圈。

可見，通過使用協程，極大提高了多工的執行效率，程式最後消耗的時間是任務佇列中耗時最多時間任務的時長。

總結

本篇講述了：

• yield from如何實現協程
• 如何結合asyncio實現非同步協程

雖然有了yield from的存在，讓協程實現比之前容易了，但是這種非同步協程的實現方式，並不是很pythonic。現在已經不推薦使用了。下篇將與您分享更加完善的Python非同步實現方式——async/await實現非同步協程。

參考

Python非同步IO之協程(一):從yield from到async的使用

關注公眾號西加加先生一起玩轉Python。

相關推薦