python中的迭代工具包,python中的迭代器和生成器

本文目錄一覽：

1、如何更好地理解Python迭代器和生成器
2、Python中的“迭代”詳解
3、Python中的迭代器是什麼
4、Python中的迭代器與可迭代:iter()和next()
5、Python基礎之迭代器

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

在Python這門語言中，生成器毫無疑問是最有用的特性之一。與此同時，也是使用的最不廣泛的Python特性之一。究其原因，主要是因為，在其他主流語言裡面沒有生成器的概念。正是由於生成器是一個“新”的東西，所以，它一方面沒有引起廣大工程師的重視，另一方面，也增加了工程師的學習成本，最終導致大家錯過了Python中如此有用的一個特性。

我的這篇文章，希望通過簡單易懂的方式，深入淺出地介紹Python的生成器，以改變“如此有用的特性卻使用極不廣泛”的現象。本文的組織如下：在第1章，我們簡單地介紹了Python中的迭代器協議；在本文第2章，將會詳細介紹生成器的概念和語法；在第3章，將會給出一個有用的例子，說明使用生成器的好處；在本文最後，簡單的討論了使用生成器的注意事項。

1. 迭代器協議

由於生成器自動實現了迭代器協議，而迭代器協議對很多人來說，也是一個較為抽象的概念。所以，為了更好的理解生成器，我們需要簡單的回顧一下迭代器協議的概念。

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

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

協議是一種約定，可迭代對象實現迭代器協議，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有兩種不同的方式提供生成器：

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

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

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

generator object at 0x00B2EC88

next(squares)

list(squares)

[9, 16]

Python不但使用迭代器協議，讓for循環變得更加通用。大部分內置函數，也是使用迭代器協議訪問對象的。例如， sum函數是Python的內置函數，該函數使用迭代器協議訪問對象，而生成器實現了迭代器協議，所以，我們可以直接這樣計算一系列值的和：

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

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

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

2.3 再看生成器

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

語法上和函數類似：生成器函數和常規函數幾乎是一樣的。它們都是使用def語句進行定義，差別在於，生成器使用yield語句返回一個值，而常規函數使用return語句返回一個值

自動實現迭代器協議：對於生成器，Python會自動實現迭代器協議，以便應用到迭代背景中（如for循環，sum函數）。由於生成器自動實現了迭代器協議，所以，我們可以調用它的next方法，並且，在沒有值可以返回的時候，生成器自動產生StopIteration異常

狀態掛起：生成器使用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

使用生成器的情況：

def index_words(text):

if text:

yield 0

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

if letter == ‘ ‘:

yield index

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

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

不使用生成器的時候，對於每次結果，我們首先看到的是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. 總結

本文深入淺出地介紹了Python中，一個容易被大家忽略的重要特性，即Python的生成器。為了講解生成器，本文先介紹了迭代器協議，然後介紹了生成器函數和生成器表達式，並通過示例演示了生成器的優點和注意事項。在實際工作中，充分利用Python生成器，不但能夠減少內存使用，還能夠提高代碼可讀性。掌握生成器也是Python高手的標配。希望本文能夠幫助大家理解Python的生成器。

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中的迭代器是什麼

迭代器

迭代是訪問集合元素的一種方式。迭代器是一個可以記住遍歷的位置的對象。迭代器對象從集合的第一個元素開始訪問，直到所有的元素被訪問完結束。迭代器只能往前不會後退。

1.可迭代對象

以直接作用於for循環的數據類型有以下幾種：

一類是集合數據類型，如list、tuple、dict、set、str等；

一類是generator，包括生成器和帶yield的generator function。

這些可以直接作用於for循環的對象統稱為可迭代對象：Iterable。

2.判斷是否可以迭代

可以使用isinstance()判斷一個對象是否是Iterable對象：

運行結果：

而生成器不但可以作用於for循環，還可以被next()函數不斷調用並返回下一個值，直到最後拋出StopIteration錯誤表示無法繼續返回下一個值了。

Python中的迭代器與可迭代:iter()和next()

一種自動迭代的更優雅的實現是使用 for循環

在Python中，迭代器（Iterator）和可迭代(iterable)的區別是，迭代器支持 iter ()和 next ()方法；可迭代支持 iter ()方法。可迭代只能在for循環中獲得元素，迭代器還可以用next()方法獲取元素。

list/truple/map/dict都是可迭代，但不是迭代器；這些數據的大小是確定的；迭代器不是，迭代器不知道要執行多少次，所以可以理解為不知道有多少個元素，每調用一次next()，就會往下走一步。

凡是可以for循環的，都是Iterable

凡是可以next()的，都是Iterator

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__() 方法中，如果迭代完成指定的次數，我們可以添加一個終止條件來引發錯誤

原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-hant/n/305033.html