在第一次接觸 Python 的時(shí)候，你可能寫過類似 for i in [2, 3, 5, 7, 11, 13]: print(i) 這樣的語句。for in 語句理解起來很直觀形象，比起 C++ 和 java 早期的 for (int i = 0; i < n; i ++) printf("%d\n", a[i]) 這樣的語句，不知道簡潔清晰到哪里去了。
但是，你想過 Python 在處理 for in 語句的時(shí)候，具體發(fā)生了什么嗎？什么樣的對象可以被 for in 來枚舉呢？
我們深入到 Python 的容器類型實(shí)現(xiàn)底層去走走，了解一種叫做迭代器和生成器的東西。
你肯定用過的容器、可迭代對象和迭代器
容器這個(gè)概念非常好理解。我們說過，在Python 中一切皆對象，對象的抽象就是類，而對象的集合就是容器。
列表（list: [0, 1, 2]），元組（tuple: (0, 1, 2)），字典（dict: {0:0, 1:1, 2:2}），集合（set: set([0, 1, 2])）都是容器。對于容器，你可以很直觀地想象成多個(gè)元素在一起的單元；而不同容器的區(qū)別，正是在于內(nèi)部數(shù)據(jù)結(jié)構(gòu)的實(shí)現(xiàn)方法。然后，你就可以針對不同場景，選擇不同時(shí)間和空間復(fù)雜度的容器。
所有的容器都是可迭代的（iterable）。這里的迭代，和枚舉不完全一樣。迭代可以想象成是你去買蘋果，賣家并不告訴你他有多少庫存。這樣，每次你都需要告訴賣家，你要一個(gè)蘋果，然后賣家采取行為：要么給你拿一個(gè)蘋果；要么告訴你，蘋果已經(jīng)賣完了。你并不需要知道，賣家在倉庫是怎么擺放蘋果的。
嚴(yán)謹(jǐn)?shù)卣f，迭代器（iterator）提供了一個(gè) next 的方法。調(diào)用這個(gè)方法后，你要么得到這個(gè)容器的下一個(gè)對象，要么得到一個(gè) StopIteration 的錯(cuò)誤（蘋果賣完了）。你不需要像列表一樣指定元素的索引，因?yàn)樽值浜图线@樣的容器并沒有索引一說。比如，字典采用哈希表實(shí)現(xiàn)，那么你就只需要知道，next 函數(shù)可以不重復(fù)不遺漏地一個(gè)一個(gè)拿到所有元素即可。
而可迭代對象，通過 iter() 函數(shù)返回一個(gè)迭代器，再通過 next() 函數(shù)就可以實(shí)現(xiàn)遍歷。for in 語句將這個(gè)過程隱式化，所以，你只需要知道它大概做了什么就行了。
來看下面這段代碼，主要向你展示怎么判斷一個(gè)對象是否可迭代。當(dāng)然，這還有另一種做法，是 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
通過這段代碼，你就可以知道，給出的類型中，除了數(shù)字 1234 之外，其它的數(shù)據(jù)類型都是可迭代的。
生成器，又是什么？
據(jù)我所知，很多人對生成器這個(gè)概念會比較陌生，因?yàn)樯善髟诤芏喑Ｓ谜Z言中，并沒有相對應(yīng)的模型。
這里，你只需要記著一點(diǎn)：生成器是懶人版本的迭代器。
我們知道，在迭代器中，如果我們想要枚舉它的元素，這些元素需要事先生成。這里，我們先來看下面這個(gè)簡單的樣例。
import os
import psutil
顯示當(dāng)前 python 程序占用的內(nèi)存大小
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
聲明一個(gè)迭代器很簡單，[i for i in range(100000000)]就可以生成一個(gè)包含一億元素的列表。每個(gè)元素在生成后都會保存到內(nèi)存中，你通過代碼可以看到，它們占用了巨量的內(nèi)存，內(nèi)存不夠的話就會出現(xiàn) OOM 錯(cuò)誤。
不過，我們并不需要在內(nèi)存中同時(shí)保存這么多東西，比如對元素求和，我們只需要知道每個(gè)元素在相加的那一刻是多少就行了，用完就可以扔掉了。
于是，生成器的概念應(yīng)運(yùn)而生，在你調(diào)用 next() 函數(shù)的時(shí)候，才會生成下一個(gè)變量。生成器在 Python 的寫法是用小括號括起來，(i for i in range(100000000))，即初始化了一個(gè)生成器。
這樣一來，你可以清晰地看到，生成器并不會像迭代器一樣占用大量內(nèi)存，只有在被使用的時(shí)候才會調(diào)用。而且生成器在初始化的時(shí)候，并不需要運(yùn)行一次生成操作，相比于 test_iterator() ，test_generator() 函數(shù)節(jié)省了一次生成一億個(gè)元素的過程，因此耗時(shí)明顯比迭代器短。
到這里，你可能說，生成器不過如此嘛，我有的是錢，不就是多占一些內(nèi)存和計(jì)算資源嘛，我多出點(diǎn)錢就是了唄。
哪怕你是土豪，請坐下先喝點(diǎn)茶，再聽我繼續(xù)講完，這次，我們來實(shí)現(xiàn)一個(gè)自定義的生成器。
生成器，還能玩什么花樣？
數(shù)學(xué)中有一個(gè)恒等式，(1 + 2 + 3 + ... + n)^2 = 1^3 + 2^3 + 3^3 + ... + n^3，想必你高中就應(yīng)該學(xué)過它?，F(xiàn)在，我們來驗(yàn)證一下這個(gè)公式的正確性。老規(guī)矩，先放代碼，你先自己閱讀一下，看不懂的也不要緊，接下來我再來詳細(xì)講解。
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() 這個(gè)函數(shù)，它返回了一個(gè)生成器。
接下來的yield 是魔術(shù)的關(guān)鍵。對于初學(xué)者來說，你可以理解為，函數(shù)運(yùn)行到這一行的時(shí)候，程序會從這里暫停，然后跳出，不過跳到哪里呢？答案是 next() 函數(shù)。那么 i ** k 是干什么的呢？它其實(shí)成了 next() 函數(shù)的返回值。
這樣，每次 next(gen) 函數(shù)被調(diào)用的時(shí)候，暫停的程序就又復(fù)活了，從 yield 這里向下繼續(xù)執(zhí)行；同時(shí)注意，局部變量 i 并沒有被清除掉，而是會繼續(xù)累加。我們可以看到 next_1 從 1 變到 8，next_3 從 1 變到 512。
聰明的你應(yīng)該注意到了，這個(gè)生成器居然可以一直進(jìn)行下去！沒錯(cuò)，事實(shí)上，迭代器是一個(gè)有限集合，生成器則可以成為一個(gè)無限集。我只管調(diào)用 next()，生成器根據(jù)運(yùn)算會自動生成新的元素，然后返回給你，非常便捷。
到這里，土豪同志應(yīng)該也坐不住了吧，那么，還能再給力一點(diǎn)嗎？
別急，我們再來看一個(gè)問題：給定一個(gè) list 和一個(gè)指定數(shù)字，求這個(gè)數(shù)字在 list 中的位置。
下面這段代碼你應(yīng)該不陌生，也就是常規(guī)做法，枚舉每個(gè)元素和它的 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]
聰明的你應(yīng)該看到了明顯的區(qū)別，我就不做過多解釋了。唯一需要強(qiáng)調(diào)的是， index_generator 會返回一個(gè) Generator 對象，需要使用 list 轉(zhuǎn)換為列表后，才能用 print 輸出。
這里我再多說兩句。在Python 語言規(guī)范中，用更少、更清晰的代碼實(shí)現(xiàn)相同功能，一直是被推崇的做法，因?yàn)檫@樣能夠很有效提高代碼的可讀性，減少出錯(cuò)概率，也方便別人快速準(zhǔn)確理解你的意圖。當(dāng)然，要注意，這里“更少”的前提是清晰，而不是使用更多的魔術(shù)操作，雖說減少了代碼卻反而增加了閱讀的難度。
回歸正題。接下來我們再來看一個(gè)問題：給定兩個(gè)序列，判定第一個(gè)是不是第二個(gè)的子序列。（LeetCode 鏈接如下：https://leetcode.com/problems/is-subsequence/ ）
先來解讀一下這個(gè)問題本身。序列就是列表，子序列則指的是，一個(gè)列表的元素在第二個(gè)列表中都按順序出現(xiàn)，但是并不必挨在一起。舉個(gè)例子，[1, 3, 5] 是 [1, 2, 3, 4, 5] 的子序列，[1, 4, 3] 則不是。
要解決這個(gè)問題，常規(guī)算法是貪心算法。我們維護(hù)兩個(gè)指針指向兩個(gè)列表的最開始，然后對第二個(gè)序列一路掃過去，如果某個(gè)數(shù)字和第一個(gè)指針指的一樣，那么就把第一個(gè)指針前進(jìn)一步。第一個(gè)指針移出第一個(gè)序列最后一個(gè)元素的時(shí)候，返回 True，否則返回 False。
不過，這個(gè)算法正常寫的話，寫下來怎么也得十行左右。
那么如果我們用迭代器和生成器呢？
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
這簡短的幾行代碼，你是不是看得一頭霧水，不知道發(fā)生了什么？
來，我們先把這段代碼復(fù)雜化，然后一步步看。
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 轉(zhuǎn)化成了一個(gè)迭代器，這里我先不解釋為什么要這么做。
接下來的gen = (i for i in a)語句很好理解，產(chǎn)生一個(gè)生成器，這個(gè)生成器可以遍歷對象 a，因此能夠輸出 1, 3, 5。而 (i in b)需要好好揣摩，這里你是不是能聯(lián)想到 for in 語句？
沒錯(cuò)，這里的(i in b)，大致等價(jià)于下面這段代碼：
while True:
val = next(b)
if val == i:
yield True
這里非常巧妙地利用生成器的特性，next() 函數(shù)運(yùn)行的時(shí)候，保存了當(dāng)前的指針。比如再看下面這個(gè)示例：
b = (i for i in range(5))
print(2 in b)
print(4 in b)
print(3 in b)
########## 輸出 ##########
True
True
False
至于最后的 all() 函數(shù)，就很簡單了。它用來判斷一個(gè)迭代器的元素是否全部為 True，如果是則返回 True，否則就返回 False.
于是到此，我們就很優(yōu)雅地解決了這道面試題。在這個(gè)技術(shù)知識點(diǎn)上，在實(shí)際工作的應(yīng)用上，你已經(jīng)比很多人更加熟練了。繼續(xù)加油！
總結(jié)一下，今天我們講了四種不同的對象，分別是容器、可迭代對象、迭代器和生成器。
