迭代器模式：一種惰性獲取數(shù)據(jù)項(xiàng)的方式，即按需一次獲取一個(gè)數(shù)據(jù)項(xiàng)嚷硫。

關(guān)于迭代器和生成器的區(qū)別：

在Python社區(qū)中检访，大多數(shù)時(shí)候把迭代器和生成器視為同一概念。

如果需要細(xì)分的話仔掸，那么迭代器用于從集合中取出數(shù)據(jù)烛谊，而生成器用于憑空生成元素。

一嘉汰、序列

所有序列都是可以迭代的丹禀。我們接下來要實(shí)現(xiàn)一個(gè) Sentence（句子）類，我們向這個(gè)類的構(gòu)造方法傳入包含一些文本的字符串鞋怀，然后可以逐個(gè)單詞迭代双泪。

sentence.py

import re
import reprlib

RE_WORD = re.compile('\w+')


class Sentence:
    def __init__(self, text):
        self.text = text
        self.words = RE_WORD.findall(text)  # re.findall 函數(shù)返回一個(gè)字符串列表

    def __getitem__(self, index):
        return self.words[index]

    def __len__(self):
        return len(self.words)

    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)  # reprlib.repr 函數(shù)用于生成大型數(shù)據(jù)結(jié)構(gòu)的簡略字符串表示形式

接下來測試 Sentence 實(shí)例能否迭代

In [11]: s = sentence.Sentence("'winter is coming!', he said.")

In [12]: s
Out[12]: Sentence("'winter is c...g!', he said.")

In [13]: for word in s:
    ...:     print(word)
    ...:     
winter
is
coming
he
said

In [14]: list(s)
Out[14]: ['winter', 'is', 'coming', 'he', 'said']

序列可以迭代的原因：

iter()

解釋器需要迭代對象 x 時(shí)，會自動調(diào)用iter(x)密似。

內(nèi)置的 iter 函數(shù)有以下作用：

1. 檢查對象是否實(shí)現(xiàn)了__iter__方法焙矛，如果實(shí)現(xiàn)了就調(diào)用他，獲取一個(gè)迭代器残腌。
2. 如果沒有實(shí)現(xiàn)__iter__方法村斟，但是實(shí)現(xiàn)了__getitem__方法贫导，Python會創(chuàng)建一個(gè)迭代器，嘗試按順序（從索引 0 開始）獲取元素蟆盹。
3. 如果嘗試失敗孩灯，Python 拋出 TypeError 異常，通常會提示"XXX object is not iterable"逾滥，其中 XXX 是目標(biāo)對象所屬的類峰档。

由于序列都實(shí)現(xiàn)了__getitem__方法，所以都可以迭代寨昙。

從 Python3.4 開始讥巡，檢查對象 x 能否迭代，最準(zhǔn)確的方式是調(diào)用 iter(x)舔哪，如果不可迭代欢顷，再處理 TypeError 異常，這比使用 isistance(x, abc.Iterable)更準(zhǔn)確捉蚤，因?yàn)閕ter(x)函數(shù)會考慮__getitem__方法抬驴。

二、可迭代對象與迭代器的對比

可迭代對象：使用內(nèi)置函數(shù) iter() 可以獲取迭代器的對象外里。

與迭代器的關(guān)系：Python 從可迭代對象中獲取迭代器怎爵。

下面用for循環(huán)迭代一個(gè)字符串，這里字符串 'abc' 是可迭代的對象盅蝗，用 for 循環(huán)迭代時(shí)是有生成器鳖链，只是 Python 隱藏了。

In [19]: s = 'abc'

In [20]: for char in s:
    ...:     print(char)
    ...:     
    ...:     
a
b
c

如果沒有 for 語句墩莫，使用 while 循環(huán)模擬芙委，要寫成下面這樣：

In [21]: s = 'abc'

In [22]: it = iter(s)  # 使用可迭代對象構(gòu)建迭代器

In [23]: while True:
    ...:     try:
    ...:         print(next(it)) # 在迭代器上不斷調(diào)用 next() 獲取下一個(gè)字符
    ...:     except StopIteration: # 如果沒有字符了，迭代器會拋出 StopIteration 異常
    ...:         del it # 釋放對 it 的引用狂秦，即廢棄迭代器對象
    ...:         break
    ...:     
a
b
c

Python 內(nèi)部會處理 for 循環(huán)和其他迭代上下文（如列表推導(dǎo)灌侣，元組拆包等等）中的 StopIteration 異常。

標(biāo)準(zhǔn)的迭代器接口有兩個(gè)方法：

__next__：返回下一個(gè)可用的元素裂问，如果沒有元素了侧啼，拋出 StopIteration 異常。

__iter__：返回 self堪簿，以便在需要使用可迭代對象的地方使用迭代器痊乾，如 for 循環(huán)中。

迭代器：實(shí)現(xiàn)了無參數(shù)的__next__方法椭更，返回序列中的下一個(gè)元素哪审；如果沒有元素了，那么拋出 StopIteration 異常虑瀑。Python 中的迭代器還實(shí)現(xiàn)了__iter__方法湿滓，因此迭代器也可以迭代滴须。

接下來使用迭代器模式實(shí)現(xiàn) Sentence 類：

sentence_iter.py

import re
import reprlib

RE_WORD = re.compile('\w+')



# 可迭代對象類
class Sentence:
    def __init__(self, text):
        self.text = text
        self.words = RE_WORD.findall(text)

    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)

    def __iter__(self):
        # 實(shí)例化一個(gè)新的迭代器
        return SentenceIterator(self.words)

   
# 迭代器類
class SentenceIterator:
    def __init__(self, words):
        self.words = words
        self.index = 0

    # 實(shí)現(xiàn) __next__ 返回單個(gè)元素
    def __next__(self):
        try:
            word = self.words[self.index]
        except IndexError:
            raise StopIteration()
        self.index += 1
        return word
    
    # 實(shí)現(xiàn) __iter__ 返回自身
    def __iter__(self):
        return self

注意，不要在 Sentence 類中實(shí)現(xiàn) __next__ 方法叽奥，讓 Sentence 實(shí)例既是可迭代對象扔水，也是自身的迭代器。

迭代器模式可用來：

• 訪問一個(gè)聚合對象的內(nèi)容而無需暴露它的內(nèi)部表示
• 支持對聚合對象的多種遍歷
• 為遍歷不同的聚合結(jié)構(gòu)提供一個(gè)統(tǒng)一的接口（即支持多臺迭代）

為了“支持多種遍歷”而线，必須能從同一個(gè)可迭代的實(shí)例中獲取多個(gè)獨(dú)立的迭代器铭污，而且各個(gè)迭代器要能維護(hù)自身的內(nèi)部狀態(tài)恋日，因此這一模式正確的實(shí)現(xiàn)方式是膀篮，每次調(diào)用 iter(my_iterable) 都新建一個(gè)獨(dú)立的迭代器。

所以總結(jié)下來就是：

• 可迭代對象一定不能是自身的迭代器岂膳，也就是說誓竿，可迭代對象必須實(shí)現(xiàn) __iter__方法，但是不能實(shí)現(xiàn)__next__方法
• 迭代器應(yīng)該一直可以迭代谈截，而且他的__iter__方法應(yīng)該返回自身筷屡。

三、生成器

實(shí)現(xiàn)相同功能簸喂，但卻符合 Python 習(xí)慣的方式是毙死，用生成器函數(shù)代替 SentenceIteror 類。

sentence_gen.py

import re
import reprlib

RE_WORD = re.compile('\w+')


class Sentence:
    def __init__(self, text):
        self.text = text
        self.words = RE_WORD.findall(text)

    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)
    
    # 是一個(gè)生成器函數(shù)喻鳄，調(diào)用時(shí)會構(gòu)建一個(gè)實(shí)現(xiàn)了迭代器接口的生成器對象扼倘，因此不用再定義 SentenceIterator類了。
    def __iter__(self):
        for word in self.words:
            yield word

只要 Python 函數(shù)的定義體中有 yield 關(guān)鍵字除呵，該函數(shù)就是生成器函數(shù)再菊。調(diào)用生成器函數(shù)，就會返回一個(gè)生成器對象颜曾。

生成器函數(shù)會創(chuàng)建一個(gè)生成器對象纠拔，包裝生成器函數(shù)的定義體，把生成器傳給 next(...) 函數(shù)時(shí)泛豪，生成器函數(shù)會向前稠诲，執(zhí)行函數(shù)定義體中的下一個(gè) yield 語句，返回產(chǎn)出的值诡曙，并在函數(shù)定義體的當(dāng)前位置暫停臀叙，。最終岗仑，函數(shù)的定義體返回時(shí)匹耕，外層的生成器對象會拋出 StopIteration 異常，這一點(diǎn)與迭代器協(xié)議一致荠雕。

注意稳其，我說的是產(chǎn)出或生成值驶赏。調(diào)用生成器函數(shù)返回生成器，生成器產(chǎn)出或生成值既鞠。生成器不會以常規(guī)的方式“返回”值煤傍，生成器函數(shù)定義體中的 return 語句會觸發(fā)生成器對象拋出 StopIteration 異常。（Python3.3 之前有 return 語句會報(bào)錯(cuò)）

關(guān)于 for 循環(huán)：

for 循環(huán)會隱式的調(diào)用 next()嘱蛋，而且在使用 for 循環(huán)到生成器函數(shù)定義體的末尾時(shí)蚯姆，for 循環(huán)會捕獲異常，因此循環(huán)終止時(shí)沒有報(bào)錯(cuò)洒敏。

如今這一版 Sentence 類相較之前簡短多了龄恋，但是還不夠慵懶。惰性凶伙，是如今人們認(rèn)為最好的特質(zhì)郭毕。惰性實(shí)現(xiàn)是指盡可能延后生成值，這樣做能節(jié)省內(nèi)存函荣，或許還能避免做無用的處理显押。

四、惰性實(shí)現(xiàn)

目前實(shí)現(xiàn)的幾版 Sentence 類都不具有惰性傻挂，因?yàn)?__init__方法急迫的構(gòu)建好了文本中的單詞列表乘碑，然后將其綁定到 self.words 屬性上。這樣就得處理整個(gè)文本金拒，列表使用的內(nèi)存量可能與文本本身一樣多（或許更多兽肤，取決于文本中有多少非單詞字符）。

re.finditer 函數(shù)是 re.findall函數(shù)的惰性版本殖蚕，返回的是一個(gè)生成器轿衔，按需生成 re.MatchObject 實(shí)例。我們可以使用這個(gè)函數(shù)來讓 Sentence 類變得懶惰睦疫，即只在需要時(shí)才生成下一個(gè)單詞害驹。

sentence_gen2.py


import re
import reprlib

RE_WORD = re.compile('\w+')


class Sentence:
    def __init__(self, text):
        self.text = text

    def __repr__(self):
        return "Sentence(%s)" % reprlib.repr(self.text)

    def __iter__(self):
        for match in RE_WORD.finditer(self.text):
            yield match.group() # match.group()方法從 MatchObject 實(shí)例中提取匹配正則表達(dá)式的具體文本。

五蛤育、標(biāo)準(zhǔn)庫中的生成器函數(shù)

標(biāo)準(zhǔn)庫提供了很多生成器函數(shù)宛官，有用于逐行迭代純文本文件的對象，還有出色的 os.walk 函數(shù)等等瓦糕。本節(jié)專注于通用的函數(shù)：參數(shù)為任意的可迭代對象底洗，返回值是生成器，用于生成選中的咕娄、計(jì)算出的和重新排列的元素亥揖。

第一組是用于過濾的生成器函數(shù)：從輸入的可迭代對象中產(chǎn)出元素的子集，而且不修改元素本身。這種函數(shù)大多數(shù)都接受一個(gè)斷言參數(shù)(predicate)费变，這個(gè)參數(shù)是個(gè)布爾函數(shù)摧扇，有一個(gè)參數(shù)，會應(yīng)用到輸入中的每個(gè)元素上挚歧，用于判斷元素是否包含在輸出中扛稽。

以下為這些函數(shù)的演示：

>>> def vowel(c):
...     return c.lower() in 'aeiou'
... 
>>> list(filter(vowel, 'Aardvark'))
['A', 'a', 'a']
>>> import itertools
>>> list(itertools.filterfalse(vowel, 'Aardvark'))
['r', 'd', 'v', 'r', 'k']
>>> list(itertools.dropwhile(vowel, 'Aardvark'))
['r', 'd', 'v', 'a', 'r', 'k'] # 不再進(jìn)一步檢查亲雪，即相同真值只跳過一次
>>> list(itertools.takewhile(vowel, 'Aardvark'))
['A', 'a'] # 同上，不再進(jìn)一步檢查
>>> list(itertools.compress('Aardvark', (1, 0, 1, 1, 0, 1)))
['A', 'r', 'd', 'a'] # selector_it 是(1, 0, 1, 1, 0, 1)疚膊，所以'Aardvark'中位置對應(yīng)1的生成出來了义辕。
>>> list(itertools.islice('Aardvark', 4))
['A', 'a', 'r', 'd']
>>> list(itertools.islice('Aardvark', 4, 7))
['v', 'a', 'r']
>>> list(itertools.islice('Aardvark', 1, 7, 2))
['a', 'd', 'a']

第二組是用于映射的生成器函數(shù)：在輸入的單個(gè)/多個(gè)可迭代對象中的各個(gè)元素上做計(jì)算，然后返回結(jié)果寓盗。

以下為這些函數(shù)的用法：

>>> sample = [5, 4, 2, 8, 7, 6, 3, 0, 9, 1]
>>> import itertools
>>> list(itertools.accumulate(sample))
[5, 9, 11, 19, 26, 32, 35, 35, 44, 45]
>>> import operator
>>> list(itertools.accumulate(range(1, 11), operator.mul)) # 1! 到 10!的階乘
[1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800] 
>>> list(map(operator.mul, range(11), range(11)))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> list(map(operator.mul, range(11), [2, 4, 8]))
[0, 4, 16]
>>> list(itertools.starmap(operator.mul, enumerate('albatroz', 1))) # 從 1 開始读串，根據(jù)字母所在位置聊记，把字母重復(fù)相應(yīng)的次數(shù)
['a', 'll', 'bbb', 'aaaa', 'ttttt', 'rrrrrr', 'ooooooo', 'zzzzzzzz']

第三組是用于合并的生成器函數(shù)，這些函數(shù)都可以從輸入的多個(gè)可迭代對象中產(chǎn)出元素恢暖。

以下為演示：

>>> list(itertools.chain('ABC', range(2)))
['A', 'B', 'C', 0, 1]
>>> list(itertools.chain.from_iterable(enumerate('ABC')))
[0, 'A', 1, 'B', 2, 'C']
>>> list(zip('ABC', range(5)))
[('A', 0), ('B', 1), ('C', 2)]
>>> list(itertools.zip_longest('ABC', range(5), fillvalue='?'))
[('A', 0), ('B', 1), ('C', 2), ('?', 3), ('?', 4)]
>>> list(itertools.product('ABC', range(2)))
[('A', 0), ('A', 1), ('B', 0), ('B', 1), ('C', 0), ('C', 1)]

第四組是從一個(gè)元素中產(chǎn)出多個(gè)值饥漫，擴(kuò)展輸入的可迭代對象榨呆。

以下為演示：

>>> ct = itertools.count()
>>> next(ct), next(ct), next(ct)
(0, 1, 2)
>>> list(itertools.islice(cy, 7))
['A', 'B', 'C', 'A', 'B', 'C', 'A']
>>> list(itertools.repeat(7, 4))
[7, 7, 7, 7]
>>> list(map(operator.mul, range(11), itertools.repeat(5))) # repeat 常見用途：為 map 函數(shù)提供固定參數(shù)
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50]
>>> list(itertools.combinations('ABC', 2)) # 'ABC'中每兩個(gè)元素的各種組合，元素順序無意義不见，不含相同元素的組合
[('A', 'B'), ('A', 'C'), ('B', 'C')]
>>> list(itertools.combinations_with_replacement('ABC', 2)) # 'ABC'中每兩個(gè)元素的各種組合澳化，元素順序無意義，含相同元素的組合
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]
>>> list(itertools.permutations('ABC',2)) # 'ABC'中每兩個(gè)元素的各種排列稳吮，元素的順序有意義
[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]

第五組生成器函數(shù)用于產(chǎn)出輸入的可迭代對象中的全部元素缎谷，不過會以某種方式重新排列。

>>> import itertools
>>> list(itertools.groupby('LLLAAAXXXX'))
[('L', <itertools._grouper object at 0x7f467ea946a0>), ('A', <itertools._grouper object at 0x7f467ea946d8>), ('X', <itertools._grouper object at 0x7f467ea94710>)]
>>> for char, group in itertools.groupby('LLLAAAXXXX'):
...     print(char, '->', list(group))
... 
L -> ['L', 'L', 'L']
A -> ['A', 'A', 'A']
X -> ['X', 'X', 'X', 'X']
>>> words = ['x','ss','zzz','dsas','xs']
>>> words.sort(key=len) # 使用 groupby 時(shí)需要先進(jìn)行排序或進(jìn)行分組
>>> words
['x', 'ss', 'xs', 'zzz', 'dsas']
>>> for length, group in itertools.groupby(words, len):
...     print(length, '->', list(group))
... 
1 -> ['x']
2 -> ['ss', 'xs']
3 -> ['zzz']
4 -> ['dsas']

>>> g1, g2 = itertools.tee('ABC')
>>> next(g1)
'A'
>>> next(g1)
'B'
>>> next(g2)
'A'
>>> list(g2)
['B', 'C']

六、可迭代的歸約函數(shù)

下面的函數(shù)都接受一個(gè)可迭代的對象鲫懒，然后返回單個(gè)結(jié)果嫩实，這種函數(shù)叫“歸約函數(shù)”，“合攏函數(shù)”或“累加函數(shù)”刀疙，其實(shí)舶赔，這些內(nèi)置函數(shù)都可以用 functools.reduce 函數(shù)實(shí)現(xiàn)，但內(nèi)置更加方便谦秧，而且還有一些優(yōu)點(diǎn)。

參考教程：
《流暢的python》 P330 - 363