搞清楚 Python 的迭代器、可迭代物件、生成器

小小後端發表於2018-11-14
Python物件

很多夥伴對 Python 的迭代器、可迭代物件、生成器這幾個概念有點搞不清楚，我來說說我的理解，希望對需要的朋友有所幫助。

1 迭代器協議

迭代器協議是核心，搞懂了這個，上面的幾個概念也就很好理解了。

所謂迭代器協議，就是要求一個迭代器必須要實現如下兩個方法

iterator.__iter__()

Return the iterator object itself.

iterator.__next__()

Return the next item from the container.

也就是說，一個物件只要支援上面兩個方法，就是迭代器。__iter__() 需要返回迭代器本身，而 __next__() 需要返回下一個元素。

2 可迭代物件

知道了迭代器的概念，那可迭代物件又是啥呢？

這個更簡單，只要物件實現了 __iter__() 方法，並且返回的是一個迭代器，那麼這個物件就是可迭代物件。

比如我們常見的列表就是可迭代物件

>>> l = [1, 3, 5]
>>> iter(l)
<list_iterator object at 0x101a1d9e8>
複製程式碼

使用 iter() 會呼叫對應的 __iter__() 方法，這裡返回的是一個列表迭代器，所以說列表就是一個可迭代物件。

3 手寫一個迭代器

迭代器的實現有不同的方式，相信大家首先能想到的就是自定義類，我們就從這個說起。

便於說明，我們手寫一個迭代器，用於生成奇數序列。

按照迭代器協議，我們實現上述的兩個方法。

class Odd:
    def __init__(self, start=1):
        self.cur = start

    def __iter__(self):
        return self

    def __next__(self):
        ret_val = self.cur
        self.cur += 2
        return ret_val
複製程式碼

終端裡，我們例項化一個 Odd 類得到一個物件 odd

>>> odd = Odd()
>>> odd
<__main__.Odd object at 0x101a1d9b0>
複製程式碼

使用 iter() 方法會呼叫類裡的 __iter__ 方法，得到它本身

>>> iter(odd)
<__main__.Odd object at 0x101a1d9b0>
複製程式碼

使用 next() 方法會呼叫對應的 __next__() 方法，得到下一個元素

>>> next(odd)
1
>>> next(odd)
3
>>> next(odd)
5
複製程式碼

其實，odd 物件就是一個迭代器了。

我們可以用 for 來遍歷它

odd = Odd()
for v in odd:
	print(v)
複製程式碼

細心的夥伴可能會發現，這個其實會無限的列印下去，那怎麼解決呢？

我們拿一個列表做做實驗，先得到它的迭代器物件

>>> l = [1, 3, 5]
>>> li = iter(l)
>>> li
<list_iterator object at 0x101a1da90>
複製程式碼

然後手動獲取下一個元素，直到沒有下一個元素為止，看下會發生什麼

>>> next(li)
1
>>> next(li)
3
>>> next(li)
5
>>> next(li)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
複製程式碼

原來列表迭代器會在沒有下一個元素的時候丟擲 StopIteration 異常，估計 for 語句就是根據這個異常來確定是否結束。

我們修改一下原來的程式碼，能生成指定範圍內的奇數

class Odd:
    def __init__(self, start=1, end=10):
        self.cur = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.cur > self.end:
            raise StopIteration
        ret_val = self.cur
        self.cur += 2
        return ret_val
複製程式碼

我們使用 for 試一下

>>> odd = Odd(1, 10)
>>> for v in odd:
...     print(v)
...
1
3
5
7
9
複製程式碼

果然，和預期一致。

我們用 while 迴圈模擬 for 的執行過程

目的碼

for v in iterable:
	print(v)
複製程式碼

翻譯後的程式碼

iterator = iter(iterable)
while True:
	try:
		v = next(iterator)
		print(v)
	except StopIteration:
		break
複製程式碼

事實上 Python 的 for 語句原理也就是這樣，可以將 for 理解為一個語法糖。

4 建立迭代器的其它方式

生成器其實也是迭代器，所以可以使用生成器的建立方式建立迭代器。

4.1 生成器函式

和普通函式的 return 返回不同，生成器函式使用 yield。

>>> def odd_func(start=1, end=10):
...     for val in range(start, end + 1):
...         if val % 2 == 1:
...             yield val
...
>>> of = odd_func(1, 5)
>>> of
<generator object odd_func at 0x101a14200>
>>> iter(of)
<generator object odd_func at 0x101a14200>
>>> next(of)
1
>>> next(of)
3
>>> next(of)
5
>>> next(of)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
複製程式碼

4.2 生成器表示式

>>> g = (v for v in range(1, 5 + 1) if v % 2 == 1)
>>> g
<generator object <genexpr> at 0x101a142b0>
>>> iter(g)
<generator object <genexpr> at 0x101a142b0>
>>> next(g)
1
>>> next(g)
3
>>> next(g)
5
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
複製程式碼

4.3 怎麼選擇

到現在為止，我們知道了建立迭代器的 3 種方式，那麼該如何選擇？

不用說也知道，最簡單的就是生成器表示式，如果表示式能滿足需求，那麼就是它；如果需要新增比較複雜的邏輯就選生成器函式；如果前兩者沒法滿足需求，那就自定義類實現吧。總之，選擇最簡單的方式就行。

5 迭代器的特點

5.1 惰性

迭代器並不是把所有的元素提前計算出來，而是在需要的時候才計算返回。

5.2 支援無限個元素

比如上面我們建立的第一個 Odd 類，它的例項 odd 表示大於 start 的所有奇數，而列表等容器沒法容納無限個元素的。

5.3 省空間

比如存 10000 個元素

>>> from sys import getsizeof
>>> a = [1] * 10000
>>> getsizeof(a)
80064
複製程式碼

列表佔用 80K 左右。

而迭代器呢？

>>> from itertools import repeat
>>> b = repeat(1, times=10000)
>>> getsizeof(b)
56
複製程式碼

只佔用了 56 個位元組。

也正因為迭代器惰性的特點，才有了這個優勢。

6 一些需要注意的細節

6.1 迭代器同時也是可迭代物件

因為迭代器的 __iter__() 方法返回了它自身，而正好它本身就是個迭代器，所以說迭代器也是可迭代物件。

6.2 迭代器遍歷完一次就不能從頭開始了

看一個奇怪的例子

>>> l = [1, 3, 5]
>>> li = iter(l)
>>> li
<list_iterator object at 0x101a1da90>
>>> 3 in li
True
>>> 3 in li
False
複製程式碼

因為 li 是列表迭代器，第一次查詢 3 的時候，找到了，所以返回 True，但是由於第一次迭代，已經跳過了 3 那個元素，第二次就找不到了，所以會出現 False。

因此，記得迭代器是「一次性」的。

當然，列表是可迭代物件，不管查詢幾次都是正常的。（不好理解的話，想想上面 for 語句的執行原理，每次都會從可迭代物件那通過 iter() 方法取到新的迭代器）

>>> 3 in l
True
>>> 3 in l
True
複製程式碼

7 小節

  • 實現了迭代器協議的物件都是迭代器
  • 實現了 __iter__() 方法並返回迭代器的物件是可迭代物件
  • 生成器也是一種迭代器
  • 建立迭代器有三種方式，生成器表示式、生成器函式、自定義類，看情況選擇最簡單的就好
  • 迭代器同時也是可迭代物件
  • 迭代器是「一次性」的

前面 3 小項是重點，這 3 點理解了，其它的也都能領會。搞清楚標題的那幾個名詞的概念的自然也沒有問題。

8 參考

本文首發於公眾號「小小後端」，關注並回復「HMPython2018」領取 18 年很讚的 Python 學習教程。

相關文章