Python協程深刻理解

從語法上來看，協程和生成器相似，都是定義體中包含yield關鍵字的函數。
yield在協程中的用法：

• 在協程中yield一般出如今表達式的右邊，例如：datum = yield,能夠產出值，也能夠不產出--若是yield關鍵字後面沒有表達式，那麼生成器產出None.

• 協程可能從調用方接受數據，調用方是經過send(datum)的方式把數據提供給協程使用，而不是next(...)函數，一般調用方會把值推送給協程。

• 協程能夠把控制器讓給中心調度程序，從而激活其餘的協程

因此整體上在協程中把yield看作是控制流程的方式。

瞭解協程的過程

先經過一個簡單的協程的例子理解：

對上述例子的分析：
yield 的右邊沒有表達式，因此這裏默認產出的值是None
剛開始先調用了next(...)是由於這個時候生成器尚未啓動，沒有停在yield那裏，這個時候也是沒法經過send發送數據。因此當咱們經過next(...)激活協程後，程序就會運行到x = yield，這裏有個問題咱們須要注意，x = yield這個表達式的計算過程是先計算等號右邊的內容，而後在進行賦值，因此當激活生成器後，程序會停在yield這裏，但並無給x賦值。
當咱們調用send方法後yield會收到這個值並賦值給x,而當程序運行到協程定義體的末尾時和用生成器的時候同樣會拋出StopIteration異常

若是協程沒有經過next(...)激活(一樣咱們能夠經過send(None)的方式激活)，可是咱們直接send，會提示以下錯誤：

關於調用next(...)函數這一步一般稱爲」預激(prime)「協程，即讓協程向前執行到第一個yield表達式，準備好做爲活躍的協程使用

協程在運行過程當中有四個狀態：

1. GEN_CREATE:等待開始執行

2. GEN_RUNNING:解釋器正在執行，這個狀態通常看不到

3. GEN_SUSPENDED:在yield表達式處暫停

4. GEN_CLOSED:執行結束

經過下面例子來查看協程的狀態：

接着再經過一個計算平均值的例子來繼續理解：

這裏是一個死循環，只要不停send值給協程，能夠一直計算下去。
經過上面的幾個例子咱們發現，咱們若是想要開始使用協程的時候必須經過next(...)方式激活協程，若是不預激，這個協程就沒法使用，若是哪天在代碼中遺忘了那麼就出問題了，因此有一種預激協程的裝飾器，能夠幫助咱們幹這件事

預激協程的裝飾器

下面是預激裝飾器的演示例子：

1 from functools import wraps
 2 
 3 
 4 def coroutine(func):
 5     @wraps(func)
 6     def primer(*args,**kwargs):
 7         gen = func(*args,**kwargs)
 8         next(gen)
 9         return gen
10     return primer
11 
12 
13 @coroutine
14 def averager():
15     total = 0.0
16     count = 0
17     average = None
18     while True:
19         term = yield average
20         total += term
21         count += 1
22         average = total/count
23 
24 
25 coro_avg = averager()
26 from inspect import getgeneratorstate
27 print(getgeneratorstate(coro_avg))
28 print(coro_avg.send(10))
29 print(coro_avg.send(30))
30 print(coro_avg.send(5))

關於預激，在使用yield from句法調用協程的時候，會自動預激活，這樣其實與咱們上面定義的coroutine裝飾器是不兼容的，在python3.4裏面的asyncio.coroutine裝飾器不會預激協程，所以兼容yield from

終止協程和異常處理

協程中爲處理的異常會向上冒泡,傳給next函數或send函數的調用方(即觸發協程的對象)
拿上面的代碼舉例子，若是咱們發送了一個字符串而不是一個整數的時候就會報錯，而且這個時候協程是被終止了

從python2.5開始客戶端代碼在生成器對象上調用兩個方法，顯示的把異常發送給協程
分別爲：throw和close
generator.throw:會讓生成器在暫停的yield表達式處拋出指定的異常，若是生成器處理了拋出的異常，代碼會向前執行到下一個yield表達式，而產出的值會成爲調用generator.throw方法代碼的返回值。若是生成器沒有處理拋出的異常，異常會向上冒泡，傳到調用方的上下文中。
generator.close:會讓生成器在暫停的yield表達式處拋出GeneratorExit異常。若是生成器沒有處理這個異常，或者拋出了StopIteration異常，調用方不會報錯，若是收到GeneratorExit異常，生成器必定不能產出值，不然解釋器會拋出RuntimeError異常。生成器拋出的異常會向上冒泡，傳給調用方。
下面是一個例子：

當傳入咱們定義的異常時不會影響協程，協程不會中止，能夠繼續send,可是若是是沒有處理的異常的時候，就會報錯，而且協程會被終止

讓協程返回值

經過下面的例子進行演示如何獲取協程的返回值：

1 from collections import namedtuple
 2 
 3 
 4 Result = namedtuple("Result","colunt average")
 5 
 6 
 7 def averager():
 8     total = 0.0
 9     count = 0
10     average = None
11     while True:
12         term = yield
13         if term is None:
14             break
15         total += term
16         count+=1
17         average = total/count
18     return Result(count,average)
19 
20 coro_avg = averager()
21 next(coro_avg)
22 coro_avg.send(10)
23 coro_avg.send(30)
24 coro_avg.send(5)
25 try:
26     coro_avg.send(None)
27 except StopIteration as e:
28     result = e.value
29     print(result)

這樣就能夠獲取到最後的結果：

其實相對來講上面這種方式獲取返回值比較麻煩，而yield from 結構會自動捕獲StopIteration異常，這種處理方式與for循環處理StopIteration異常的方式同樣，循環機制使咱們更容易理解處理異常，對於yield from來講，解釋器不只會捕獲StopIteration異常，還會把value屬性的值變成yield from表達式的值

關於yield from

在生成器gen中使用yield from subgen()時，subgen會得到控制權，把產出的值傳給gen的調用方，即調用方能夠直接控制subgen,同時，gen會阻塞，等待subgen終止

yield from x表達式對x對象所作的第一件事是，調用iter(x),從中獲取迭代器，所以x能夠是任何可迭代的對象

下面是yield from能夠簡化yield表達式的例子：

1 def gen():
 2     for c in "AB":
 3         yield c
 4     for i in range(1,3):
 5         yield i
 6 
 7 print(list(gen()))
 8 
 9 def gen2():
10     yield from "AB"
11     yield from range(1,3)
12 
13 print(list(gen2()))

這兩種的方式的結果是同樣的，可是這樣看來yield from更加簡潔，可是yield from的做用可不只僅是替代產出值的嵌套for循環。
yield from的主要功能是打開雙向通道，把最外層的調用方與最內層的子生成器鏈接起來，這樣兩者能夠直接發送和產出值，還能夠直接傳入異常，而不用再像以前那樣在位於中間的協程中添加大量處理異常的代碼

經過yield from還能夠連接可迭代對象

委派生成器在yield from 表達式處暫停時，調用方能夠直接把數據發給子生成器，子生成器再把產出產出值發給調用方，子生成器返回以後，解釋器會拋出StopIteration異常，並把返回值附加到異常對象上，此時委派生成器會恢復。

下面是一個完整的例子代碼

1 from collections import namedtuple
 2 
 3 
 4 Result = namedtuple('Result', 'count average')
 5 
 6 
 7 # 子生成器
 8 def averager():
 9     total = 0.0
10     count = 0
11     average = None
12     while True:
13         term = yield
14         if term is None:
15             break
16         total += term
17         count += 1
18         average = total/count
19     return Result(count, average)
20 
21 
22 # 委派生成器
23 def grouper(result, key):
24     while True:
25         result[key] = yield from averager()
26 
27 
28 # 客戶端代碼，即調用方
29 def main(data):
30     results = {}
31     for key,values in data.items():
32         group = grouper(results,key)
33         next(group)
34         for value in values:
35             group.send(value)
36         group.send(None) #這裏表示要終止了
37 
38     report(results)
39 
40 
41 # 輸出報告
42 def report(results):
43     for key, result in sorted(results.items()):
44         group, unit = key.split(';')
45         print('{:2} {:5} averaging {:.2f}{}'.format(
46             result.count, group, result.average, unit
47         ))
48 
49 data = {
50     'girls;kg':
51         [40.9, 38.5, 44.3, 42.2, 45.2, 41.7, 44.5, 38.0, 40.6, 44.5],
52     'girls;m':
53         [1.6, 1.51, 1.4, 1.3, 1.41, 1.39, 1.33, 1.46, 1.45, 1.43],
54     'boys;kg':
55         [39.0, 40.8, 43.2, 40.8, 43.1, 38.6, 41.4, 40.6, 36.3],
56     'boys;m':
57         [1.38, 1.5, 1.32, 1.25, 1.37, 1.48, 1.25, 1.49, 1.46],
58 }
59 
60 
61 if __name__ == '__main__':
62     main(data)

關於上述代碼着重解釋一下關於委派生成器部分，這裏的循環每次迭代時會新建一個averager實例，每一個實例都是做爲協程使用的生成器對象。

grouper發送的每一個值都會經由yield from處理，經過管道傳給averager實例。grouper會在yield from表達式處暫停，等待averager實例處理客戶端發來的值。averager實例運行完畢後，返回的值會綁定到results[key]上，while 循環會不斷建立averager實例，處理更多的值

而且上述代碼中的子生成器可使用return 返回一個值，而返回的值會成爲yield from表達式的值。

關於yield from的意義

關於yield from 六點重要的說明：

1. 子生成器產出的值都直接傳給委派生成器的調用方(即客戶端代碼)

2. 使用send()方法發送給委派生成器的值都直接傳給子生成器。若是發送的值爲None,那麼會給委派調用子生成器的__next__()方法。若是發送的值不是None,那麼會調用子生成器的send方法，若是調用的方法拋出StopIteration異常，那麼委派生成器恢復運行，任何其餘異常都會向上冒泡，傳給委派生成器

3. 生成器退出時，生成器(或子生成器)中的return expr表達式會出發StopIteration(expr)異常拋出

4. yield from表達式的值是子生成器終止時傳給StopIteration異常的第一個參數。yield from 結構的另外兩個特性與異常和終止有關。

5. 傳入委派生成器的異常，除了GeneratorExit以外都傳給子生成器的throw()方法。若是調用throw()方法時拋出StopIteration異常，委派生成器恢復運行。StopIteration以外的異常會向上冒泡，傳給委派生成器

6. 若是把GeneratorExit異常傳入委派生成器，或者在委派生成器上調用close()方法，那麼在子生成器上調用clsoe()方法，若是它有的話。若是調用close()方法致使異常拋出，那麼異常會向上冒泡，傳給委派生成器，不然委派生成器拋出GeneratorExit異常