包含python生成器迭代實際案例的詞條

本文目錄一覽：

• 1、python 迭代器和生成器的區別
• 2、python 如何使用生成器函數實現可迭代對象
• 3、Python中的「迭代」詳解
• 4、如何更好地理解Python迭代器和生成器
• 5、Python基礎之迭代器
• 6、閑話python 45: 淺談生成器yield

python 迭代器和生成器的區別

Num01–迭代器

定義：

對於list、string、tuple、dict等這些容器對象,使用for循環遍歷是很方便的。在後台for語句對容器對象調用iter()函數。iter()是python內置函數。

iter()函數會返回一個定義了next()方法的迭代器對象，它在容器中逐個訪問容器內的元素。next()也是python內置函數。在沒有後續元素時，next()會拋出一個StopIteration異常，通知for語句循環結束。

迭代器是用來幫助我們記錄每次迭代訪問到的位置，當我們對迭代器使用next()函數的時候，迭代器會向我們返回它所記錄位置的下一個位置的數據。實際上，在使用next()函數的時候，調用的就是迭代器對象的_next_方法（Python3中是對象的_next_方法，Python2中是對象的next()方法）。所以，我們要想構造一個迭代器，就要實現它的_next_方法。但這還不夠，python要求迭代器本身也是可迭代的，所以我們還要為迭代器實現_iter_方法，而_iter_方法要返回一個迭代器，迭代器自身正是一個迭代器，所以迭代器的_iter_方法返回自身self即可。

一些術語的解釋：

1，迭代器協議：對象需要提供next()方法，它要麼返回迭代中的下一項，要麼就引起一個StopIteration異常，以終止迭代。

2，可迭代對象：實現了迭代器協議對象。list、tuple、dict都是Iterable（可迭代對象），但不是Iterator（迭代器對象）。但可以使用內建函數iter()，把這些都變成Iterable（可迭代器對象）。

3，for item in Iterable 循環的本質就是先通過iter()函數獲取可迭代對象Iterable的迭代器，然後對獲取到的迭代器不斷調用next()方法來獲取下一個值並將其賦值給item，當遇到StopIteration的異常後循環結束

Python自帶容器對象案例：

# 隨便定義一個listlistArray=[1,2,3]# 使用iter()函數iterName=iter(listArray)

print(iterName)# 結果如下：是一個列表list的迭代器# list_iterator object at 0x0000017B0D984278print(next(iterName))

print(next(iterName))

print(next(iterName))

print(next(iterName))#沒有迭代到下一個元素，直接拋出異常# 1# 2# 3# Traceback (most recent call last):# File “Test07.py”, line 32, in module# StopIteration123456789101112131415161718

Python中一個實現了_iter_方法和_next_方法的類對象，就是迭代器，如下案例是計算菲波那切數列的案例

class Fib(object):

def __init__(self, max):

super(Fib, self).__init__()

self.max = max def __iter__(self):

self.a = 0

self.b = 1

return self def __next__(self):

fib = self.a if fib self.max: raise StopIteration

self.a, self.b = self.b, self.a + self.b return fib# 定義一個main函數，循環遍歷每一個菲波那切數def main():

# 20以內的數

fib = Fib(20) for i in fib:

print(i)# 測試if __name__ == ‘__main__’:

main()12345678910111213141516171819202122232425262728

解釋說明：

在本類的實現中，定義了一個_iter_(self)方法，這個方法是在for循環遍歷時被iter()調用，返回一個迭代器。因為在遍歷的時候，是直接調用的python內置函數iter()，由iter()通過調用_iter_(self)獲得對象的迭代器。有了迭代器，就可以逐個遍曆元素了。而逐個遍歷的時候，也是使用內置的next(）函數通過調用對象的_next_(self)方法對迭代器對象進行遍歷。所以要實現_iter_(self)和_next_(self)這兩個方法。

而且因為實現了_next_(self)方法，所以在實現_iter_(self)的時候，直接返回self就可以。

總結一句話就是：

在循環遍歷自定義容器對象時,會使用python內置函數iter()調用遍歷對象的_iter_(self)獲得一個迭代器,之後再循環對這個迭代器使用next()調用迭代器對象的_next_(self)。

注意點：_iter_(self)只會被調用一次,而_next_(self)會被調用 n 次，直到出現StopIteration異常。

Num02–生成器

作用：

延遲操作。也就是在需要的時候才產生結果，不是立即產生結果。12

注意事項：

生成器是只能遍歷一次的。

生成器是一類特殊的迭代器。123

分類：

第一類：生成器函數：還是使用 def 定義函數，但是，使用yield而不是return語句返回結果。yield語句一次返回一個結果，在每個結果中間，掛起函數的狀態，以便下次從它離開的地方繼續執行。

如下案例加以說明：

# 菲波那切數列def Fib(max):

n, a, b = 0, 0, 1

while n max: yield b

a, b = b, a + b

n = n + 1

return ‘親！沒有數據了…’# 調用方法，生成出10個數來f=Fib(10)# 使用一個循環捕獲最後return 返回的值，保存在異常StopIteration的value中while True: try:

x=next(f)

print(“f:”,x) except StopIteration as e:

print(“生成器最後的返回值是：”,e.value) break123456789101112131415161718

第二類：生成器表達式：類似於列表

，只不過是把一對大括弧[]變換為一對小括弧()。但是，生成器表達式是按需產生一個生成器結果對象，要想拿到每一個元素，就需要循環遍歷。

如下案例加以說明：

# 一個列表xiaoke=[2,3,4,5]# 生成器generator，類似於list，但是是把[]改為()gen=(a for a in xiaoke)for i in gen:

print(i)#結果是：2345# 為什麼要使用生成器？因為效率。# 使用生成器表達式取代列表推導式可以同時節省 cpu 和 內存(RAM)。# 如果你構造一個列表(list)的目的僅僅是傳遞給別的函數,# 比如 傳遞給tuple()或者set(), 那就用生成器表達式替代吧!# 本案例是直接把列錶轉化為元組kk=tuple(a for a in xiaoke)

print(kk)#結果是：(2, 3, 4, 5)# python內置的一些函數，可以識別這是生成器表達式，外面有一對小括弧，就是生成器result1=sum(a for a in range(3))

print(result1)# 列表推導式result2=sum([a for a in range(3)])

print(result2)

python 如何使用生成器函數實現可迭代對象

Iamlaosong文

我們在用for … in …語句循環時，in後面跟隨的對象要求是可迭代對象，即可以直接作用於for循環的對象統稱為可迭代對象（Iterable），如list、tuple、dict、set、str等。

可迭代對象是實現了__iter__()方法的對象，而迭代器（Iterator）則是實現了__iter__()和__next__()方法的對象，可以顯示地獲取下一個元素。這種可以被next調用並不斷返回下一個值的對象稱為迭代器。迭代器一定是可迭代對象，反過來則不一定成立。用iter()函數可以把list、dict、str等Iterable變成Iterator，例如：

bb=[x for x in range(10)]

cc=iter(bb)

cc.next()

循環變數的值其實可以看著是一次次用next取值的過程，每取一個值，做一次處理。list等對象用於循環實際上可以看著是用iter()方法產生一個迭代器，然後循環取值。

生成器（generator）就是一個能返回迭代器的函數，其實就是定義一個迭代演算法，可以理解為一個特殊的迭代器。調用這個函數就得到一個迭代器，生成器中的yield相當於一個斷點，執行到此返回一個值後暫停，從而實現next取值。

Python中的「迭代」詳解

迭代器模式：一種惰性獲取數據項的方式，即按需一次獲取一個數據項。

所有序列都是可以迭代的。我們接下來要實現一個 Sentence（句子）類，我們向這個類的構造方法傳入包含一些文本的字元串，然後可以逐個單詞迭代。

接下來測試 Sentence 實例能否迭代

序列可以迭代的原因：

iter()

解釋器需要迭代對象 x 時，會自動調用iter(x)。

內置的 iter 函數有以下作用：

由於序列都實現了 __getitem__ 方法，所以都可以迭代。

可迭代對象：使用內置函數 iter() 可以獲取迭代器的對象。

與迭代器的關係：Python 從可迭代對象中獲取迭代器。

下面用for循環迭代一個字元串，這裡字元串 ‘abc’ 是可迭代的對象，用 for 循環迭代時是有生成器，只是 Python 隱藏了。

如果沒有 for 語句，使用 while 循環模擬，要寫成下面這樣：

Python 內部會處理 for 循環和其他迭代上下文（如列表推導，元組拆包等等）中的 StopIteration 異常。

標準的迭代器介面有兩個方法：

__next__ ：返回下一個可用的元素，如果沒有元素了，拋出 StopIteration 異常。

__iter__ ：返回 self，以便在需要使用可迭代對象的地方使用迭代器，如 for 循環中。

迭代器：實現了無參數的 __next__ 方法，返回序列中的下一個元素；如果沒有元素了，那麼拋出 StopIteration 異常。Python 中的迭代器還實現了 __iter__ 方法，因此迭代器也可以迭代。

接下來使用迭代器模式實現 Sentence 類：

注意， 不要 在 Sentence 類中實現 __next__ 方法，讓 Sentence 實例既是可迭代對象，也是自身的迭代器。

為了「支持多種遍歷」，必須能從同一個可迭代的實例中獲取多個獨立的迭代器，而且各個迭代器要能維護自身的內部狀態，因此這一模式正確的實現方式是，每次調用 iter(my_iterable) 都新建一個獨立的迭代器。

所以總結下來就是：

實現相同功能，但卻符合 Python 習慣的方式是，用生成器函數代替 SentenceIteror 類。

只要 Python 函數的定義體中有 yield 關鍵字，該函數就是生成器函數。調用生成器函數，就會返回一個生成器對象。

生成器函數會創建一個生成器對象，包裝生成器函數的定義體，把生成器傳給 next(…) 函數時，生成器函數會向前，執行函數定義體中的下一個 yield 語句，返回產出的值，並在函數定義體的當前位置暫停，。最終，函數的定義體返回時，外層的生成器對象會拋出 StopIteration 異常，這一點與迭代器協議一致。

如今這一版 Sentence 類相較之前簡短多了，但是還不夠慵懶。 惰性 ，是如今人們認為最好的特質。惰性實現是指儘可能延後生成值，這樣做能節省內存，或許還能避免做無用的處理。

目前實現的幾版 Sentence 類都不具有惰性，因為 __init__ 方法急迫的構建好了文本中的單詞列表，然後將其綁定到 self.words 屬性上。這樣就得處理整個文本，列表使用的內存量可能與文本本身一樣多（或許更多，取決於文本中有多少非單詞字元）。

re.finditer 函數是 re.findall 函數的惰性版本，返回的是一個生成器，按需生成 re.MatchObject 實例。我們可以使用這個函數來讓 Sentence 類變得懶惰，即只在需要時才生成下一個單詞。

標準庫提供了很多生成器函數，有用於逐行迭代純文本文件的對象，還有出色的 os.walk 函數等等。本節專註於通用的函數：參數為任意的可迭代對象，返回值是生成器，用於生成選中的、計算出的和重新排列的元素。

第一組是用於 過濾 的生成器函數：從輸入的可迭代對象中產出元素的子集，而且不修改元素本身。這種函數大多數都接受一個斷言參數(predicate)，這個參數是個 布爾函數 ，有一個參數，會應用到輸入中的每個元素上，用於判斷元素是否包含在輸出中。

以下為這些函數的演示：

第二組是用於映射的生成器函數：在輸入的單個/多個可迭代對象中的各個元素上做計算，然後返回結果。

以下為這些函數的用法：

第三組是用於合併的生成器函數，這些函數都可以從輸入的多個可迭代對象中產出元素。

以下為演示：

第四組是從一個元素中產出多個值，擴展輸入的可迭代對象。

以下為演示：

第五組生成器函數用於產出輸入的可迭代對象中的全部元素，不過會以某種方式重新排列。

下面的函數都接受一個可迭代的對象，然後返回單個結果，這種函數叫「歸約函數」，「合攏函數」或「累加函數」，其實，這些內置函數都可以用 functools.reduce 函數實現，但內置更加方便，而且還有一些優點。

參考教程：

《流暢的python》 P330 – 363

如何更好地理解Python迭代器和生成器

Python這門語言中，生成器毫無疑問是最有用的特性之一。與此同時，也是使用的最不廣泛的Python特

性之一。究其原因，主要是因為，在其他主流語言裡面沒有生成器的概念。正是由於生成器是一

個「新」的東西，所以，它一方面沒有引起廣大工程師的重視，另一方面，也增加了工程師的學習成本，

最終導致大家錯過了Python中如此有用的一個特性。

我的這篇文章，希望通過簡單易懂的方式，深入淺出地介紹Python的生成器，以改變「如此有用的特性卻

使用極不廣泛」的現象。本文的組織如下：在第1章，我們簡單地介紹了Python中的迭代器協議；在本文

第2章，將會詳細介紹生成器的概念和語法；在第3章，將會給出一個有用的例子，說明使用生成器的好

處；在本文最後，簡單的討論了使用生成器的注意事項。

1. 迭代器協議

由於生成器自動實現了迭代器協議，而迭代器協議對很多人來說，也是一個較為抽象的概念。所以，為了

更好的理解生成器，我們需要簡單的回顧一下迭代器協議的概念。

1. 迭代器協議是指：對象需要提供next方法，它要麼返回迭代中的下一項，要麼就引起一個

StopIteration異常，以終止迭代

2. 可迭代對象就是：實現了迭代器協議的對象

3. 協議是一種約定，可迭代對象實現迭代器協議，Python的內置工具(如for循環，sum，min，max函

數等)使用迭代器協議訪問對象。

舉個例子：在所有語言中，我們都可以使用for循環來遍曆數組，Python的list底層實現是一個數組，所

以，我們可以使用for循環來遍歷list。如下所示：

for n in [1, 2, 3, 4]:

… print n

但是，對Python稍微熟悉一點的朋友應該知道，Python的for循環不但可以用來遍歷list，還可以用來遍歷

文件對象，如下所示：

with open(『/etc/passwd』) as f: # 文件對象提供迭代器協議

… for line in f: # for循環使用迭代器協議訪問文件

… print line

…

為什麼在Python中，文件還可以使用for循環進行遍歷呢？這是因為，在Python中，文件對象實現了迭代

器協議，for循環並不知道它遍歷的是一個文件對象，它只管使用迭代器協議訪問對象即可。正是由於

Python的文件對象實現了迭代器協議，我們才得以使用如此方便的方式訪問文件，如下所示：

f = open(‘/etc/passwd’)

dir(f)

[‘__class__’, ‘__enter__’, ‘__exit__’, ‘__iter__’, ‘__new__’, ‘writelines’, ‘…’

2. 生成器

Python使用生成器對延遲操作提供了支持。所謂延遲操作，是指在需要的時候才產生結果，而不是立即產

生結果。這也是生成器的主要好處。

Python有兩種不同的方式提供生成器：

2017/11/6 如何更好地理解Python迭代器和生成器？ – 知乎

2/5

1. 生成器函數：常規函數定義，但是，使用yield語句而不是return語句返回結果。yield語句一次返回一

個結果，在每個結果中間，掛起函數的狀態，以便下次重它離開的地方繼續執行

2. 生成器表達式：類似於列表推導，但是，生成器返回按需產生結果的一個對象，而不是一次構建一個

結果列表

2.1 生成器函數

我們來看一個例子，使用生成器返回自然數的平方（注意返回的是多個值）：

def gensquares(N):

for i in range(N):

yield i ** 2

for item in gensquares(5):

print item,

使用普通函數：

def gensquares(N):

res = []

for i in range(N):

res.append(i*i)

return res

for item in gensquares(5):

print item,

可以看到，使用生成器函數代碼量更少。

2.2 生成器表達式

使用列表推導，將會一次產生所有結果：

squares = [x**2 for x in range(5)]

squares

[0, 1, 4, 9, 16]

將列表推導的中括弧，替換成圓括弧，就是一個生成器表達式：

squares = (x**2 for x in range(5))

squares next(squares)

next(squares)

1

next(squares)

4

list(squares)

[9, 16]

Python不但使用迭代器協議，讓for循環變得更加通用。大部分內置函數，也是使用迭代器協議訪問對象

的。例如， sum函數是Python的內置函數，該函數使用迭代器協議訪問對象，而生成器實現了迭代器協

2017/11/6 如何更好地理解Python迭代器和生成器？ – 知乎

3/5

議，所以，我們可以直接這樣計算一系列值的和：

sum(x ** 2 for x in xrange(4))

而不用多此一舉的先構造一個列表：

sum([x ** 2 for x in xrange(4)])

2.3 再看生成器

前面已經對生成器有了感性的認識，我們以生成器函數為例，再來深入探討一下Python的生成器：

1. 語法上和函數類似：生成器函數和常規函數幾乎是一樣的。它們都是使用def語句進行定義，差別在

於，生成器使用yield語句返回一個值，而常規函數使用return語句返回一個值

2. 自動實現迭代器協議：對於生成器，Python會自動實現迭代器協議，以便應用到迭代背景中（如for

循環，sum函數）。由於生成器自動實現了迭代器協議，所以，我們可以調用它的next方法，並且，

在沒有值可以返回的時候，生成器自動產生StopIteration異常

3. 狀態掛起：生成器使用yield語句返回一個值。yield語句掛起該生成器函數的狀態，保留足夠的信息，

以便之後從它離開的地方繼續執行

3. 示例

我們再來看兩個生成器的例子，以便大家更好的理解生成器的作用。

首先，生成器的好處是延遲計算，一次返回一個結果。也就是說，它不會一次生成所有的結果，這對於大

數據量處理，將會非常有用。

大家可以在自己電腦上試試下面兩個表達式，並且觀察內存佔用情況。對於前一個表達式，我在自己的電

腦上進行測試，還沒有看到最終結果電腦就已經卡死，對於後一個表達式，幾乎沒有什麼內存佔用。

sum([i for i in xrange(10000000000)])

sum(i for i in xrange(10000000000))

除了延遲計算，生成器還能有效提高代碼可讀性。例如，現在有一個需求，求一段文字中，每個單詞出現

的位置。

不使用生成器的情況：

def index_words(text):

result = []

if text:

result.append(0)

for index, letter in enumerate(text, 1):

if letter == ‘ ‘:

result.append(index)

return result

使用生成器的情況：

2017/11/6 如何更好地理解Python迭代器和生成器？ – 知乎

4/5

def index_words(text):

if text:

yield 0

for index, letter in enumerate(text, 1):

if letter == ‘ ‘:

yield index

這裡，至少有兩個充分的理由說明 ，使用生成器比不使用生成器代碼更加清晰：

1. 使用生成器以後，代碼行數更少。大家要記住，如果想把代碼寫的Pythonic，在保證代碼可讀性的前

提下，代碼行數越少越好

2. 不使用生成器的時候，對於每次結果，我們首先看到的是result.append(index)，其次，才是index。

也就是說，我們每次看到的是一個列表的append操作，只是append的是我們想要的結果。使用生成

器的時候，直接yield index，少了列表append操作的干擾，我們一眼就能夠看出，代碼是要返回

index。

這個例子充分說明了，合理使用生成器，能夠有效提高代碼可讀性。只要大家完全接受了生成器的概念，

理解了yield語句和return語句一樣，也是返回一個值。那麼，就能夠理解為什麼使用生成器比不使用生成

器要好，能夠理解使用生成器真的可以讓代碼變得清晰易懂。

4. 使用生成器的注意事項

相信通過這篇文章，大家已經能夠理解生成器的作用和好處。但是，還沒有結束，使用生成器，也有一點

注意事項。

我們直接來看例子，假設文件中保存了每個省份的人口總數，現在，需要求每個省份的人口佔全國總人口

的比例。顯然，我們需要先求出全國的總人口，然後在遍歷每個省份的人口，用每個省的人口數除以總人

口數，就得到了每個省份的人口佔全國人口的比例。

如下所示：

def get_province_population(filename):

with open(filename) as f:

for line in f:

yield int(line)

gen = get_province_population(‘data.txt’)

all_population = sum(gen)

#print all_population

for population in gen:

print population / all_population

執行上面這段代碼，將不會有任何輸出，這是因為，生成器只能遍歷一次。在我們執行sum語句的時候，

就遍歷了我們的生成器，當我們再次遍歷我們的生成器的時候，將不會有任何記錄。所以，上面的代碼不

會有任何輸出。

因此，生成器的唯一注意事項就是：生成器只能遍歷一次。

5. 總結

2017/11/6 如何更好地理解Python迭代器和生成器？ – 知乎

5/5

本文深入淺出地介紹了Python中，一個容易被大家忽略的重要特性，即Python的生成器。為了講解生成

器，本文先介紹了迭代器協議，然後介紹了生成器函數和生成器表達式，並通過示例演示了生成器的優點

和注意事項。在實際工作中，充分利用Python生成器，不但能夠減少內存使用，還能夠提高代碼可讀性。

掌握生成器也是Python高手的標配。希望本文能夠幫助大家理解Python的生成器

Python基礎之迭代器

一.什麼是迭代器

迭代器是用來迭代取值的工具。

而涉及到把多個值循環取出來的類型有：列表，字元串，元組，欄位，集合，打開文件等。通過使用的遍歷方式有for···in···，while等，但是，這些方式只適用於有索引的數據類型。為了解決索引取的局限性，python提供了一種 不依賴於索引的取值方式：迭代器

注意：

二.可迭代對象

可迭代對象：但凡內置有__iter__方法的都稱為可迭代對象

常見的可迭代對象：

1.集合數據類型，如list,tuple,dict,set,str等

2.生成器，包括生成器和帶yield的生成器函數。

三.如何創建迭代器

迭代器是一個包含數個值的對象。

迭代器是可以迭代的對象，這意味著您可以遍歷所有值。

從技術上講，在Python中，迭代器是實現迭代器協議的對象，該協議由方法 __iter__() 和 __next__() 組成。

簡而言之，一個類裡面實現了__iter__()和__next__()這兩個魔法方法，那麼這個類的對象就是可迭代對象。

四.迭代器的優缺點

1.優點

2.缺點

五.迭代器示例

另外，如果類Stu繼承了Iterator，那麼Stu可以不用實現__iter__()方法

遍歷迭代器

StopIteration

如果你有足夠的 next() 語句，或者在 for 循環中使用，則上面的例子將永遠進行下去。

為了防止迭代永遠進行，我們可以使用 StopIteration 語句。

在 __next__() 方法中，如果迭代完成指定的次數，我們可以添加一個終止條件來引發錯誤

閑話python 45: 淺談生成器yield

生成器似乎並不是一個經常被開發者討論的語法，因此也就沒有它的大兄弟迭代器那麼著名。大家不討論它並不是說大家都已經對它熟悉到人盡皆知，與之相反，即使是工作多年的開發者可能對生成器的運行過程還是知之甚少。這是什麼原因導致的呢？我猜想大概有以下幾點原因： (1)運行流程不同尋常，(2)日常開發不需要，(3)常常將生成器與迭代器混淆。 生成器的運行流程可以按照協程來理解，也就是說 返回中間結果，斷點繼續運行 。這與我們通常對於程序調用的理解稍有差異。這種運行模式是針對什麼樣的需求呢？ 一般而言，生成器是應用於大量磁碟資源的處理。 比如一個很大的文件，每次讀取一行，下一次讀取需要以上一次讀取的位置為基礎。下面就通過代碼演示具體看看生成器的運行機制、使用方式以及與迭代器的比較。

什麼是生成器？直接用文字描述可能太過抽象，倒不如先運行一段代碼，分析這段代碼的運行流程，然後總結出自己對生成器的理解。

從以上演示可以看出，這段代碼定義了一個函數，這個函數除了yield這個關鍵字之外與一般函數並沒有差異，也就是說生成器的魔法都是這個yield關鍵字引起的。 第一點，函數的返回值是一個生成器對象。 上述代碼中，直接調用這個看似普通的函數，然後將返回值列印出來，發現返回值是一個對象，而並不是普通函數的返回值。 第二點，可以使用next對這個生成器對象進行操作 。生成器對象天然的可以被next函數調用，然後返回在yield關鍵字後面的內容。 第三，再次調用next函數處理生成器對象，發現是從上次yield語句之後繼續運行，直到下一個yield語句返回。

生成器的運行流程確實詭異，下面還要演示一個生成器可以執行的更加詭異的操作：運行過程中向函數傳參。

返回生成器和next函數操作生成器已經並不奇怪了，但是在函數運行過程中向其傳參還是讓人驚呆了。 調用生成器的send函數傳入參數，在函數內使用yield語句的返回值接收，然後繼續運行直到下一個yield語句返回。 以前實現這種運行流程的方式是在函數中加上一個從控制台獲取數據的指令，或者提前將參數傳入，但是現在不用了，send方式使得傳入的參數可以隨著讀取到的參數變化而變化。

很多的開發者比較容易混淆生成器和迭代器，而迭代器的運行過程更加符合一般的程序調用運行流程，因此從親進度和使用熟悉度而言，大家對迭代器更有好感。比如下面演示一個對迭代器使用next方法進行操作。

從以上演示來看，大家或許會認為迭代器比生成器簡單易用得太多了。不過，如果你了解迭代器的實現機制，可能就不會這麼早下結論了。python內置了一些已經實現了的迭代器使用確實方便，但是如果需要自己去寫一個迭代器呢？下面這段代碼就帶大家見識以下迭代器的實現。

在python中，能被next函數操作的對象一定帶有__next__函數的實現，而能夠被迭代的對象有必須實現__iter__函數。看了這麼一段操作，相信大家對迭代器實現的繁瑣也是深有體會了，那麼生成器的實現是不是會讓你覺得更加簡單易用呢？不過千萬別產生一個誤區，即生成器比迭代器簡單就多用生成器。 在實際開發中，如果遇到與大量磁碟文件或者資料庫操作相關的倒是可以使用生成器。但是在其他的任務中使用生成器難免有炫技，並且使邏輯不清晰而導致可讀性下降的嫌疑。 這大概也能解釋生成器受冷落的原因。不過作為一個專業的開發者，熟悉語言特性是分內之事。

到此，關於生成器的討論就結束了。本文的notebook版本文件在github上的cnbluegeek/notebook倉庫中共享，歡迎感興趣的朋友前往下載。