19-深入理解迭代器和生成器
你肯定用過的容器、可迭代物件和迭代器
容器這個概念非常好理解。我們說過,在Python 中一切皆物件,物件的抽象就是類,而物件的集合就是容器。
列表(list: [0, 1, 2]),元組(tuple: (0, 1, 2)),字典(dict: {0:0, 1:1, 2:2}),集合(set: set([0, 1, 2]))都是容器。對於容器,你可以很直觀地想象成多個元素在一起的單元;而不同容器的區別,正是在於內部資料結構的實現方法。然後,你就可以針對不同場景,選擇不同時間和空間複雜度的容器。
所有的容器都是可迭代的(iterable)。這裡的迭代,和列舉不完全一樣。迭代可以想象成是你去買蘋果,賣家並不告訴你他有多少庫存。這樣,每次你都需要告訴賣家,你要一個蘋果,然後賣家採取行為:要麼給你拿一個蘋果;要麼告訴你,蘋果已經賣完了。你並不需要知道,賣家在倉庫是怎麼擺放蘋果的。
嚴謹地說,迭代器(iterator)提供了一個 next 的方法。呼叫這個方法後,你要麼得到這個容器的下一個物件,要麼得到一個 StopIteration 的錯誤(蘋果賣完了)。你不需要像列表一樣指定元素的索引,因為字典和集合這樣的容器並沒有索引一說。比如,字典採用雜湊表實現,那麼你就只需要知道,next 函式可以不重複不遺漏地一個一個拿到所有元素即可。
而可迭代物件,通過 iter() 函式返回一個迭代器,再通過 next() 函式就可以實現遍歷。for in 語句將這個過程隱式化,所以,你只需要知道它大概做了什麼就行了。
我們來看下面這段程式碼,主要向你展示怎麼判斷一個物件是否可迭代。當然,這還有另一種做法,是 isinstance(obj, Iterable)。
def is_iterable(param): try: iter(param) return True except TypeError: return False params = [ 1234, '1234', [1, 2, 3, 4], set([1, 2, 3, 4]), {1:1, 2:2, 3:3, 4:4}, (1, 2, 3, 4) ] for param in params: print('{} is iterable? {}'.format(param, is_iterable(param))) ########## 輸出 ########## 1234 is iterable? False 1234 is iterable? True [1, 2, 3, 4] is iterable? True {1, 2, 3, 4} is iterable? True {1: 1, 2: 2, 3: 3, 4: 4} is iterable? True (1, 2, 3, 4) is iterable? True
通過這段程式碼,你就可以知道,給出的型別中,除了數字 1234 之外,其它的資料型別都是可迭代的。
生成器,又是什麼?
據我所知,很多人對生成器這個概念會比較陌生,因為生成器在很多常用語言中,並沒有相對應的模型。
這裡,你只需要記著一點:生成器是懶人版本的迭代器。
我們知道,在迭代器中,如果我們想要列舉它的元素,這些元素需要事先生成。這裡,我們先來看下面這個簡單的樣例。
import os
import psutil
# 顯示當前 python 程式佔用的記憶體大小
def show_memory_info(hint):
pid = os.getpid()
p = psutil.Process(pid)
info = p.memory_full_info()
memory = info.uss / 1024. / 1024
print('{} memory used: {} MB'.format(hint, memory))
def test_iterator():
show_memory_info('initing iterator')
list_1 = [i for i in range(100000000)]
show_memory_info('after iterator initiated')
print(sum(list_1))
show_memory_info('after sum called')
def test_generator():
show_memory_info('initing generator')
list_2 = (i for i in range(100000000))
show_memory_info('after generator initiated')
print(sum(list_2))
show_memory_info('after sum called')
%time test_iterator()
%time test_generator()
########## 輸出 ##########
initing iterator memory used: 48.9765625 MB
after iterator initiated memory used: 3920.30078125 MB
4999999950000000
after sum called memory used: 3920.3046875 MB
Wall time: 17 s
initing generator memory used: 50.359375 MB
after generator initiated memory used: 50.359375 MB
4999999950000000
after sum called memory used: 50.109375 MB
Wall time: 12.5 s
宣告一個迭代器很簡單,[i for i in range(100000000)]
就可以生成一個包含一億元素的列表。每個元素在生成後都會儲存到記憶體中,你通過程式碼可以看到,它們佔用了巨量的記憶體,記憶體不夠的話就會出現 OOM 錯誤。
不過,我們並不需要在記憶體中同時儲存這麼多東西,比如對元素求和,我們只需要知道每個元素在相加的那一刻是多少就行了,用完就可以扔掉了。
於是,生成器的概念應運而生,在你呼叫 next() 函式的時候,才會生成下一個變數。生成器在 Python 的寫法是用小括號括起來,(i for i in range(100000000))
,即初始化了一個生成器。
這樣一來,你可以清晰地看到,生成器並不會像迭代器一樣佔用大量記憶體,只有在被使用的時候才會呼叫。而且生成器在初始化的時候,並不需要執行一次生成操作,相比於 test_iterator() ,test_generator() 函式節省了一次生成一億個元素的過程,因此耗時明顯比迭代器短。
到這裡,你可能說,生成器不過如此嘛,我有的是錢,不就是多佔一些記憶體和計算資源嘛,我多出點錢就是了唄。
哪怕你是土豪,請坐下先喝點茶,再聽我繼續講完,這次,我們來實現一個自定義的生成器。
生成器,還能玩什麼花樣?
數學中有一個恆等式,(1 + 2 + 3 + ... + n)^2 = 1^3 + 2^3 + 3^3 + ... + n^3
,想必你高中就應該學過它。現在,我們來驗證一下這個公式的正確性。老規矩,先放程式碼,你先自己閱讀一下,看不懂的也不要緊,接下來我再來詳細講解。
def generator(k):
i = 1
while True:
yield i ** k
i += 1
gen_1 = generator(1)
gen_3 = generator(3)
print(gen_1)
print(gen_3)
def get_sum(n):
sum_1, sum_3 = 0, 0
for i in range(n):
next_1 = next(gen_1)
next_3 = next(gen_3)
print('next_1 = {}, next_3 = {}'.format(next_1, next_3))
sum_1 += next_1
sum_3 += next_3
print(sum_1 * sum_1, sum_3)
get_sum(8)
########## 輸出 ##########
<generator object generator at 0x000001E70651C4F8>
<generator object generator at 0x000001E70651C390>
next_1 = 1, next_3 = 1
next_1 = 2, next_3 = 8
next_1 = 3, next_3 = 27
next_1 = 4, next_3 = 64
next_1 = 5, next_3 = 125
next_1 = 6, next_3 = 216
next_1 = 7, next_3 = 343
next_1 = 8, next_3 = 512
1296 1296
這段程式碼中,你首先注意一下 generator() 這個函式,它返回了一個生成器。
接下來的yield 是魔術的關鍵。對於初學者來說,你可以理解為,函式執行到這一行的時候,程式會從這裡暫停,然後跳出,不過跳到哪裡呢?答案是 next() 函式。那麼 i ** k
是幹什麼的呢?它其實成了 next() 函式的返回值。
這樣,每次 next(gen) 函式被呼叫的時候,暫停的程式就又復活了,從 yield 這裡向下繼續執行;同時注意,區域性變數 i 並沒有被清除掉,而是會繼續累加。我們可以看到 next_1 從 1 變到 8,next_3 從 1 變到 512。
聰明的你應該注意到了,這個生成器居然可以一直進行下去!沒錯,事實上,迭代器是一個有限集合,生成器則可以成為一個無限集。我只管呼叫 next(),生成器根據運算會自動生成新的元素,然後返回給你,非常便捷。
到這裡,土豪同志應該也坐不住了吧,那麼,還能再給力一點嗎?
別急,我們再來看一個問題:給定一個 list 和一個指定數字,求這個數字在 list 中的位置。
下面這段程式碼你應該不陌生,也就是常規做法,列舉每個元素和它的 index,判斷後加入 result,最後返回。
def index_normal(L, target):
result = []
for i, num in enumerate(L):
if num == target:
result.append(i)
return result
print(index_normal([1, 6, 2, 4, 5, 2, 8, 6, 3, 2], 2))
########## 輸出 ##########
[2, 5, 9]
那麼使用迭代器可以怎麼做呢?二話不說,先看程式碼。
def index_generator(L, target):
for i, num in enumerate(L):
if num == target:
yield i
print(list(index_generator([1, 6, 2, 4, 5, 2, 8, 6, 3, 2], 2)))
########## 輸出 ##########
[2, 5, 9]
聰明的你應該看到了明顯的區別,我就不做過多解釋了。唯一需要強調的是, index_generator 會返回一個 Generator 物件,需要使用 list 轉換為列表後,才能用 print 輸出。
這裡我再多說兩句。在Python 語言規範中,用更少、更清晰的程式碼實現相同功能,一直是被推崇的做法,因為這樣能夠很有效提高程式碼的可讀性,減少出錯概率,也方便別人快速準確理解你的意圖。當然,要注意,這裡“更少”的前提是清晰,而不是使用更多的魔術操作,雖說減少了程式碼卻反而增加了閱讀的難度。
迴歸正題。接下來我們再來看一個問題:給定兩個序列,判定第一個是不是第二個的子序列。(LeetCode 連結如下:https://leetcode.com/problems/is-subsequence/ )
先來解讀一下這個問題本身。序列就是列表,子序列則指的是,一個列表的元素在第二個列表中都按順序出現,但是並不必挨在一起。舉個例子,[1, 3, 5] 是 [1, 2, 3, 4, 5] 的子序列,[1, 4, 3] 則不是。
要解決這個問題,常規演算法是貪心演算法。我們維護兩個指標指向兩個列表的最開始,然後對第二個序列一路掃過去,如果某個數字和第一個指標指的一樣,那麼就把第一個指標前進一步。第一個指標移出第一個序列最後一個元素的時候,返回 True,否則返回 False。
不過,這個演算法正常寫的話,寫下來怎麼也得十行左右。
那麼如果我們用迭代器和生成器呢?
def is_subsequence(a, b):
b = iter(b)
return all(i in b for i in a)
print(is_subsequence([1, 3, 5], [1, 2, 3, 4, 5]))
print(is_subsequence([1, 4, 3], [1, 2, 3, 4, 5]))
########## 輸出 ##########
True
False
這簡短的幾行程式碼,你是不是看得一頭霧水,不知道發生了什麼?
來,我們先把這段程式碼複雜化,然後一步步看。
def is_subsequence(a, b):
b = iter(b)
print(b)
gen = (i for i in a)
print(gen)
for i in gen:
print(i)
gen = ((i in b) for i in a)
print(gen)
for i in gen:
print(i)
return all(((i in b) for i in a))
print(is_subsequence([1, 3, 5], [1, 2, 3, 4, 5]))
print(is_subsequence([1, 4, 3], [1, 2, 3, 4, 5]))
########## 輸出 ##########
<list_iterator object at 0x000001E7063D0E80>
<generator object is_subsequence.<locals>.<genexpr> at 0x000001E70651C570>
1
3
5
<generator object is_subsequence.<locals>.<genexpr> at 0x000001E70651C5E8>
True
True
True
False
<list_iterator object at 0x000001E7063D0D30>
<generator object is_subsequence.<locals>.<genexpr> at 0x000001E70651C5E8>
1
4
3
<generator object is_subsequence.<locals>.<genexpr> at 0x000001E70651C570>
True
True
False
False
首先,第二行的b = iter(b)
,把列表 b 轉化成了一個迭代器,這裡我先不解釋為什麼要這麼做。
接下來的gen = (i for i in a)
語句很好理解,產生一個生成器,這個生成器可以遍歷物件 a,因此能夠輸出 1, 3, 5。而 (i in b)
需要好好揣摩,這裡你是不是能聯想到 for in 語句?
沒錯,這裡的(i in b)
,大致等價於下面這段程式碼:
while True:
val = next(b)
if val == i:
yield True
這裡非常巧妙地利用生成器的特性,next() 函式執行的時候,儲存了當前的指標。比如再看下面這個示例:
b = (i for i in range(5))
print(2 in b)
print(4 in b)
print(3 in b)
########## 輸出 ##########
True
True
False
至於最後的 all() 函式,就很簡單了。它用來判斷一個迭代器的元素是否全部為 True,如果是則返回 True,否則就返回 False.
於是到此,我們就很優雅地解決了這道面試題。不過你一定注意,面試的時候儘量不要用這種技巧,因為你的面試官有可能並不知道生成器的用法,他們也沒有看過我的極客時間專欄。不過,在這個技術知識點上,在實際工作的應用上,你已經比很多人更加熟練了。繼續加油!
總結
總結一下,今天我們講了四種不同的物件,分別是容器、可迭代物件、迭代器和生成器。
- 容器是可迭代物件,可迭代物件呼叫 iter() 函式,可以得到一個迭代器。迭代器可以通過 next() 函式來得到下一個元素,從而支援遍歷。
- 生成器是一種特殊的迭代器(注意這個邏輯關係反之不成立)。使用生成器,你可以寫出來更加清晰的程式碼;合理使用生成器,可以降低記憶體佔用、優化程式結構、提高程式速度。
- 生成器在 Python 2 的版本上,是協程的一種重要實現方式;而 Python 3.5 引入 async await 語法糖後,生成器實現協程的方式就已經落後了。我們會在下節課,繼續深入講解 Python 協程。