本文的文字及圖片來源於網路,僅供學習、交流使用,不具有任何商業用途,如有問題請及時聯絡我們以作處理

在 Python 開發中， yield 關鍵字的使用其實較為頻繁，例如大集合的生成，簡化程式碼結構、協程與併發都會用到它。

但是，你是否真正瞭解 yield 的執行過程呢？

這篇文章，我們就來看一下 yield 的執行流程，以及在開發中哪些場景適合使用 yield 。

生成器

如果在一個方法內，包含了 yield 關鍵字，那麼這個函式就是一個「生成器」。

生成器其實就是一個特殊的迭代器，它可以像迭代器那樣，迭代輸出方法內的每個元素。

我們來看一個包含 yield 關鍵字的方法：

# coding: utf8

# 生成器
defgen(n):
foriinrange(n):
yieldi

g = gen(5)# 建立一個生成器
print(g)# <generator object gen at 0x10bb46f50>
print(type(g))# <type 'generator'>

# 迭代生成器中的資料
foriing:
print(i)

# Output:
# 0 1 2 3 4
 

注意，在這個例子中，當我們執行 g = gen(5) 時， gen 中的程式碼其實並沒有執行，此時我們只是建立了一個「生成器物件」，它的型別是 generator 。

然後，當我們執行 for i in g ，每執行一次迴圈，就會執行到 yield 處，返回一次 yield 後面的值。

這個迭代過程是和迭代器最大的區別。

換句話說，如果我們想輸出 5 個元素，在建立生成器時，這個 5 個元素其實還並沒有產生，什麼時候產生呢？只有在執行 for 迴圈遇到 yield 時，才會依次生成每個元素。

此外，生成器除了和迭代器一樣實現迭代資料之外，還包含了其他方法：

• generator.__next__()

  ：執行 for 時呼叫此方法，每次執行到 yield 就會停止，然後返回 yield 後面的值，如果沒有資料可迭代，丟擲 StopIterator 異常， for 迴圈結束

• generator.send(value) ：外部傳入一個值到生成器內部，改變 yield 前面的值

• generator.throw(type[, value[, traceback]]) ：外部向生成器丟擲一個異常

• generator.close() ：關閉生成器

通過使用生成器的這些方法，我們可以完成很多有意思的功能。

__ next __

先來看生成器的 __next__ 方法，我們看下面這個例子。

# coding: utf8

defgen(n):
foriinrange(n):
print('yield before')
yieldi
print('yield after')

g = gen(3)# 建立一個生成器
print(g.__next__())# 0
print('----')
print(g.__next__())# 1
print('----')
print(g.__next__())# 2
print('----')
print(g.__next__())# StopIteration

# Output:
# yield before
# 0
# ----
# yield after
# yield before
# 1
# ----
# yield after
# yield before
# 2
# ----
# yield after
# Traceback (most recent call last):
# File "gen.py", line 16, in <module>
# print(g.__next__()) # StopIteration
# StopIteration

在這個例子中，我們定義了 gen 方法，這個方法包含了 yield 關鍵字。然後我們執行 g = gen(3) 建立一個生成器，但是這次沒有執行 for 去迭代它，而是多次呼叫 g.next() 去輸出生成器中的元素。

我們看到，當執行 g.__next__() 時，程式碼就會執行到 yield 處，然後返回 yield 後面的值，如果繼續呼叫 g.__next__() ，注意，你會發現，這次執行的開始位置，是上次 yield 結束的地方，並且它還保留了上一次執行的上下文，繼續向後迭代。

這就是使用 yield 的作用，在迭代生成器時，每一次執行都可以保留上一次的狀態，而不是像普通方法那樣，遇到 return 就返回結果，下一次執行只能再次重複上一次的流程。

生成器除了能儲存狀態之外，我們還可以通過其他方式，改變其內部的狀態，這就是下面要講的 send 和 throw 方法。

send

上面的例子中，我們只展示了在 yield 後有值的情況，其實還可以使用 j = yield i 這種語法，我們看下面的程式碼：

# coding: utf8

defgen():
i =1
whileTrue:
j =yieldi
i *=2
ifj ==-1:
break

此時如果我們執行下面的程式碼：

foriingen():
print(i)
time.sleep(1)

輸出結果會是 1 2 4 8 16 32 64 ... 一直迴圈下去， 直到我們殺死這個程序才能停止。

這段程式碼一直迴圈的原因在於，它無法執行到 j == -1 這個分支裡 break 出來，如果我們想讓程式碼執行到這個地方，如何做呢？

這裡就要用到生成器的 send 方法了， send 方法可以把外部的值傳入生成器內部，從而改變生成器的狀態。

程式碼可以像下面這樣寫：

g = gen()# 建立一個生成器
print(g.__next__())# 1
print(g.__next__())# 2
print(g.__next__())# 4
# send 把 -1 傳入生成器內部 走到了 j = -1 這個分支
print(g.send(-1))# StopIteration 迭代停止

當我們執行 g.send(-1) 時，相當於把 -1 傳入到了生成器內部，然後賦值給了 yield 前面的 j ，此時 j = -1 ，然後這個方法就會 break 出來，不會繼續迭代下去。

throw

外部除了可以向生成器內部傳入一個值外，還可以傳入一個異常，也就是呼叫 throw 方法：

# coding: utf8

defgen():
try:
yield1
exceptValueError:
yield'ValueError'
finally:
print('finally')

g = gen()# 建立一個生成器
print(g.__next__())# 1
# 向生成器內部傳入異常 返回ValueError
print(g.throw(ValueError))

# Output：
# 1
# ValueError
# finally

這個例子建立好生成器後，使用 g.throw(ValueError) 的方式，向生成器內部傳入了一個異常，走到了生成器異常處理的分支邏輯。

close

生成器的 close 方法也比較簡單，就是手動關閉這個生成器，關閉後的生成器無法再進行操作。

>>>g = gen()
>>>g.close()# 關閉生成器
>>>g.__next__()# 無法迭代資料
Traceback (most recent call last):
File"<stdin>", line1,in<module>
StopIteration

close 方法我們在開發中使用得比較少，瞭解一下就好。

使用場景

瞭解了 yield 和生成器的使用方式，那麼 yield 和生成器一般用在哪些業務場景中呢？

下面我介紹幾個例子，分別是大集合的生成、簡化程式碼結構、協程與併發，你可以參考這些使用場景來使用 yield 。

大集合的生成

如果你想生成一個非常大的集合，如果使用 list 建立一個集合，這會導致在記憶體中申請一個很大的儲存空間，例如想下面這樣：

# coding: utf8

defbig_list():
result = []
foriinrange(10000000000):
result.append(i)
returnresult

# 一次性在記憶體中生成大集合 記憶體佔用非常大
foriinbig_list():
print(i)

這種場景，我們使用生成器就能很好地解決這個問題。

因為生成器只有在執行到 yield 時才會迭代資料，這時只會申請需要返回元素的記憶體空間，程式碼可以這樣寫：

# coding: utf8

defbig_list():
foriinrange(10000000000):
yieldi

# 只有在迭代時 才依次生成元素 減少記憶體佔用
foriinbig_list():
print(i)

簡化程式碼結構

我們在開發時還經常遇到這樣一種場景，如果一個方法要返回一個 list ，但這個 list 是多個邏輯塊組合後才能產生的，這就會導致我們的程式碼結構變得很複雜：

# coding: utf8

defgen_list():
# 多個邏輯塊 組成生成一個列表
result = []
foriinrange(10):
result.append(i)
forjinrange(5):
result.append(j * j)
forkin[100,200,300]:
result.append(k)
returnresult

foritemingen_list():
print(item)

這種情況下，我們只能在每個邏輯塊內使用 append 向 list 中追加元素，程式碼寫起來比較囉嗦。

此時如果使用 yield 來生成這個 list ，程式碼就簡潔很多：

# coding: utf8

defgen_list():
# 多個邏輯塊 使用yield 生成一個列表
foriinrange(10):
yieldi
forjinrange(5):
yieldj * j
forkin[100,200,300]:
yieldk

foritemingen_list():
print(i)

使用 yield 後，就不再需要定義 list 型別的變數，只需在每個邏輯塊直接 yield 返回元素即可，可以達到和前面例子一樣的功能。

我們看到，使用 yield 的程式碼更加簡潔，結構也更清晰，另外的好處是隻有在迭代元素時才申請記憶體空間，降低了記憶體資源的消耗。

協程與併發

還有一種場景是 yield 使用非常多的，那就是「協程與併發」。

如果我們想提高程式的執行效率，通常會使用多程序、多執行緒的方式編寫程式程式碼，最常用的程式設計模型就是「生產者-消費者」模型，即一個程序 / 執行緒生產資料，其他程序 / 執行緒消費資料。

在開發多程序、多執行緒程式時，為了防止共享資源被篡改，我們通常還需要加鎖進行保護，這樣就增加了程式設計的複雜度。

在 Python 中，除了使用程序和執行緒之外，我們還可以使用「協程」來提高程式碼的執行效率。

什麼是協程？

簡單來說， 由多個程式塊組合協作執行的程式，稱之為「協程」。

而在 Python 中使用「協程」，就需要用到 yield 關鍵字來配合。

可能這麼說還是太好理解，我們用 yield 實現一個協程生產者、消費者的例子：

# coding: utf8

defconsumer():
i =None
whileTrue:
# 拿到 producer 發來的資料
j =yieldi
print('consume %s'% j)

defproducer(c):
c.__next__()
foriinrange(5):
print('produce %s'% i)
# 發資料給 consumer
c.send(i)
c.close()

c = consumer()
producer(c)

# Output:
# produce 0
# consume 0
# produce 1
# consume 1
# produce 2
# consume 2
# produce 3
# consume 3
...

這個程式的執行流程如下：

1. c = consumer() 建立一個生成器物件

2. producer(c) 開始執行， c.__next()__ 會啟動生成器 consumer 直到程式碼執行到 j = yield i 處，此時 consumer 第一次執行完畢，返回

3. producer 函式繼續向下執行，直到 c.send(i) 處，這裡利用生成器的 send 方法，向 consumer 傳送資料

4. consumer 函式被喚醒，從 j = yield i 處繼續開始執行，並且接收到 producer 傳來的資料賦值給 j ，然後列印輸出，直到再次執行到 yield 處，返回

5. producer 繼續迴圈執行上面的過程，依次傳送資料給 cosnumer ，直到迴圈結束

6. 最終 c.close() 關閉 consumer 生成器，程式退出

在這個例子中我們發現，程式在 producer 和 consumer 這 2 個函式之間 來回切換 執行，相互協作，完成了生產任務、消費任務的業務場景，最重要的是，整個程式是在 單程序單執行緒 下完成的。

這個例子用到了上面講到的 yield 、生成器的 __next__ 、 send 、 close 方法。如果不好理解，你可以多看幾遍這個例子，最好自己測試一下。

我們使用協程編寫生產者、消費者的程式時，它的好處是：

• 整個程式執行過程中無鎖，不用考慮共享變數的保護問題，降低了程式設計複雜度

• 程式在函式之間來回切換，這個過程是使用者態下進行的，不像程序 / 執行緒那樣，會陷入到核心態，這就減少了核心態上下文切換的消耗，執行效率更高

所以， Python 的 yield 和生成器實現了協程的程式設計方式，為程式的併發執行提供了程式設計基礎。

Python 中的很多第三方庫，都是基於這一特性進行封裝的，例如 gevent 、 tornado ，它們都大大提高了程式的執行效率。

總結

總結一下，這篇文章我們主要講了 yield 的使用方式，以及生成器的各種特性。

生成器是一種特殊的迭代器，它除了可以迭代資料之外，在執行時還可以儲存方法中的狀態，除此之外，它還提供了外部改變內部狀態的方式，把外部的值傳入到生成器內部。

利用 yield 和生成器的特性，我們在開發中可以用在大整合的生成、簡化程式碼結構、協程與併發的業務場景中。

Python 的 yield 也是實現協程和併發的基礎，它提供了協程這種使用者態的程式設計模式，提高了程式執行的效率。

想要獲取更多Python學習資料可以加
QQ:2955637827私聊
或加Q群630390733
大家一起來學習討論吧！