迭代器的特點是：惰性求值（Lazy evaluation），即只有當迭代至某個值時，它纔會被計算，這個特點使得迭代器特別適合於遍歷大文件或無限集合等，因爲我們不用一次性將它們存儲在內存中。
Python 內置的 itertools 模塊包含了一系列用來產生不同類型迭代器的函數或類，這些函數的返回都是一個迭代器，我們可以通過 for 循環來遍歷取值，也可以使用 next() 來取值。
itertools 模塊提供的迭代器函數有以下幾種類型：
無限迭代器：生成一個無限序列，比如自然數序列 1, 2, 3, 4, ...；
有限迭代器：接收一個或多個序列（sequence）作爲參數，進行組合、分組和過濾等；
組合生成器：序列的排列、組合，求序列的笛卡兒積等；
無限迭代器
itertools 模塊提供了三個函數（事實上，它們是類）用於生成一個無限序列迭代器：
count(firstval=0, step=1)創建一個從 firstval (默認值爲 0) 開始，以 step (默認值爲 1) 爲步長的的無限整數迭代器
cycle(iterable)對 iterable 中的元素反覆執行循環，返回迭代器
repeat(object [,times]反覆生成 object，如果給定 times，則重複次數爲 times，否則爲無限
下面，讓我們看看一些例子。
count
count() 接收兩個參數，第一個參數指定開始值，默認爲 0，第二個參數指定步長，默認爲 1：
>>> import itertools >>> >>> nums = itertools.count() >>> for i in nums: ... if i > 6: ... break ... print i ... 0 1 2 3 4 5 6 >>> nums = itertools.count(10, 2) # 指定開始值和步長 >>> for i in nums: ... if i > 20: ... break ... print i ... 10 12 14 16 18 20
cycle
cycle() 用於對 iterable 中的元素反覆執行循環：
>>> import itertools
>>>
>>> cycle_strings = itertools.cycle('ABC')
>>> i = 1
>>> for string in cycle_strings:
... if i == 10:
... break
... print i, string
... i += 1
...
1 A
2 B
3 C
4 A
5 B
6 C
7 A
8 B
9 Crepeat
repeat() 用於反覆生成一個 object：
>>> import itertools
>>>
>>> for item in itertools.repeat('hello world', 3):
... print item
...
hello world
hello world
hello world
>>>
>>> for item in itertools.repeat([1, 2, 3, 4], 3):
... print item
...
[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4]有限迭代器
itertools 模塊提供了多個函數（類），接收一個或多個迭代對象作爲參數，對它們進行組合、分組和過濾等：
chain()
compress()
dropwhile()
groupby()
ifilter()
ifilterfalse()
islice()
imap()
starmap()
tee()
takewhile()
izip()
izip_longest()
chain
chain 的使用形式如下：
chain(iterable1, iterable2, iterable3, ...)
chain 接收多個可迭代對象作爲參數，將它們『連接』起來，作爲一個新的迭代器返回。
>>> from itertools import chain >>> >>> for item in chain([1, 2, 3], ['a', 'b', 'c']): ... print item ... 1 2 3 a b c
chain 還有一個常見的用法：
chain.from_iterable(iterable)
接收一個可迭代對象作爲參數，返回一個迭代器：
>>> from itertools import chain
>>>
>>> string = chain.from_iterable('ABCD')
>>> string.next()
'A'compress
compress 的使用形式如下：
compress(data, selectors)
compress 可用於對數據進行篩選，當 selectors 的某個元素爲 true 時，則保留 data 對應位置的元素，否則去除：
>>> from itertools import compress >>> >>> list(compress('ABCDEF', [1, 1, 0, 1, 0, 1])) ['A', 'B', 'D', 'F'] >>> list(compress('ABCDEF', [1, 1, 0, 1])) ['A', 'B', 'D'] >>> list(compress('ABCDEF', [True, False, True])) ['A', 'C']
dropwhile
dropwhile 的使用形式如下：
dropwhile(predicate, iterable)
其中，predicate 是函數，iterable 是可迭代對象。對於 iterable 中的元素，如果 predicate(item) 爲 true，則丟棄該元素，否則返回該項及所有後續項。
>>> from itertools import dropwhile >>> >>> list(dropwhile(lambda x: x < 5, [1, 3, 6, 2, 1])) [6, 2, 1] >>> >>> list(dropwhile(lambda x: x > 3, [2, 1, 6, 5, 4])) [2, 1, 6, 5, 4]
groupby
groupby 用於對序列進行分組，它的使用形式如下：
groupby(iterable[, keyfunc])
其中，iterable 是一個可迭代對象，keyfunc 是分組函數，用於對 iterable 的連續項進行分組，如果不指定，則默認對 iterable 中的連續相同項進行分組，返回一個 (key, sub-iterator) 的迭代器。
>>> from itertools import groupby
>>>
>>> for key, value_iter in groupby('aaabbbaaccd'):
... print key, ':', list(value_iter)
...
a : ['a', 'a', 'a']
b : ['b', 'b', 'b']
a : ['a', 'a']
c : ['c', 'c']
d : ['d']
>>>
>>> data = ['a', 'bb', 'ccc', 'dd', 'eee', 'f']
>>> for key, value_iter in groupby(data, len): # 使用 len 函數作爲分組函數
... print key, ':', list(value_iter)
...
1 : ['a']
2 : ['bb']
3 : ['ccc']
2 : ['dd']
3 : ['eee']
1 : ['f']
>>>
>>> data = ['a', 'bb', 'cc', 'ddd', 'eee', 'f']
>>> for key, value_iter in groupby(data, len):
... print key, ':', list(value_iter)
...
1 : ['a']
2 : ['bb', 'cc']
3 : ['ddd', 'eee']
1 : ['f']ifilter
ifilter 的使用形式如下：
ifilter(function or None, sequence)
將 iterable 中 function(item) 爲 True 的元素組成一個迭代器返回，如果 function 是 None，則返回 iterable 中所有計算爲 True 的項。
>>> from itertools import ifilter >>> >>> list(ifilter(lambda x: x < 6, range(10))) [0, 1, 2, 3, 4, 5] >>> >>> list(ifilter(None, [0, 1, 2, 0, 3, 4])) [1, 2, 3, 4]
ifilterfalse
ifilterfalse 的使用形式和 ifilter 類似，它將 iterable 中 function(item) 爲 False 的元素組成一個迭代器返回，如果 function 是 None，則返回 iterable 中所有計算爲 False 的項。
>>> from itertools import ifilterfalse >>> >>> list(ifilterfalse(lambda x: x < 6, range(10))) [6, 7, 8, 9] >>> >>> list(ifilter(None, [0, 1, 2, 0, 3, 4])) [0, 0]
islice
islice 是切片選擇，它的使用形式如下：
islice(iterable, [start,] stop [, step])
其中，iterable 是可迭代對象，start 是開始索引，stop 是結束索引，step 是步長，start 和 step 可選。
>>> from itertools import count, islice >>> >>> list(islice([10, 6, 2, 8, 1, 3, 9], 5)) [10, 6, 2, 8, 1] >>> >>> list(islice(count(), 6)) [0, 1, 2, 3, 4, 5] >>> >>> list(islice(count(), 3, 10)) [3, 4, 5, 6, 7, 8, 9] >>> list(islice(count(), 3, 10 ,2)) [3, 5, 7, 9]
imap
imap 類似 map 操作，它的使用形式如下：
imap(func, iter1, iter2, iter3, ...)
imap 返回一個迭代器，元素爲 func(i1, i2, i3, ...)，i1，i2 等分別來源於 iter, iter2。
>>> from itertools import imap >>> >>> imap(str, [1, 2, 3, 4]) <itertools.imap object at 0x10556d050> >>> >>> list(imap(str, [1, 2, 3, 4])) ['1', '2', '3', '4'] >>> >>> list(imap(pow, [2, 3, 10], [4, 2, 3])) [16, 9, 1000]
tee
tee 的使用形式如下：
tee(iterable [,n])
tee 用於從 iterable 創建 n 個獨立的迭代器，以元組的形式返回，n 的默認值是 2。
>>> from itertools import tee
>>>
>>> tee('abcd') # n 默認爲 2，創建兩個獨立的迭代器
(<itertools.tee object at 0x1049957e8>, <itertools.tee object at 0x104995878>)
>>>
>>> iter1, iter2 = tee('abcde')
>>> list(iter1)
['a', 'b', 'c', 'd', 'e']
>>> list(iter2)
['a', 'b', 'c', 'd', 'e']
>>>
>>> tee('abc', 3) # 創建三個獨立的迭代器
(<itertools.tee object at 0x104995998>, <itertools.tee object at 0x1049959e0>, <itertools.tee object at 0x104995a28>)takewhile
takewhile 的使用形式如下：
takewhile(predicate, iterable)
其中，predicate 是函數，iterable 是可迭代對象。對於 iterable 中的元素，如果 predicate(item) 爲 true，則保留該元素，只要 predicate(item) 爲 false，則立即停止迭代。
>>> from itertools import takewhile >>> >>> list(takewhile(lambda x: x < 5, [1, 3, 6, 2, 1])) [1, 3] >>> list(takewhile(lambda x: x > 3, [2, 1, 6, 5, 4])) []
izip
izip 用於將多個可迭代對象對應位置的元素作爲一個元組，將所有元組『組成』一個迭代器，並返回。它的使用形式如下：
izip(iter1, iter2, ..., iterN)
如果某個可迭代對象不再生成值，則迭代停止。
>>> from itertools import izip
>>>
>>> for item in izip('ABCD', 'xy'):
... print item
...
('A', 'x')
('B', 'y')
>>> for item in izip([1, 2, 3], ['a', 'b', 'c', 'd', 'e']):
... print item
...
(1, 'a')
(2, 'b')
(3, 'c')izip_longest
izip_longest 跟 izip 類似，但迭代過程會持續到所有可迭代對象的元素都被迭代完。它的形式如下：
izip_longest(iter1, iter2, ..., iterN, [fillvalue=None])
如果有指定 fillvalue，則會用其填充缺失的值，否則爲 None。
>>> from itertools import izip_longest
>>>
>>> for item in izip_longest('ABCD', 'xy'):
... print item
...
('A', 'x')
('B', 'y')
('C', None)
('D', None)
>>>
>>> for item in izip_longest('ABCD', 'xy', fillvalue='-'):
... print item
...
('A', 'x')
('B', 'y')
('C', '-')
('D', '-')組合生成器
itertools 模塊還提供了多個組合生成器函數，用於求序列的排列、組合等：
product
permutations
combinations
combinations_with_replacement
product
product 用於求多個可迭代對象的笛卡爾積，它跟嵌套的 for 循環等價。它的一般使用形式如下：
product(iter1, iter2, ... iterN, [repeat=1])
其中，repeat 是一個關鍵字參數，用於指定重複生成序列的次數，
>>> from itertools import product
>>>
>>> for item in product('ABCD', 'xy'):
... print item
...
('A', 'x')
('A', 'y')
('B', 'x')
('B', 'y')
('C', 'x')
('C', 'y')
('D', 'x')
('D', 'y')
>>>
>>> list(product('ab', range(3)))
[('a', 0), ('a', 1), ('a', 2), ('b', 0), ('b', 1), ('b', 2)]
>>>
>>> list(product((0,1), (0,1), (0,1)))
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]
>>>
>>> list(product('ABC', repeat=2))
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]
>>>permutations
permutations 用於生成一個排列，它的一般使用形式如下：
permutations(iterable[, r])
其中，r 指定生成排列的元素的長度，如果不指定，則默認爲可迭代對象的元素長度。
>>> from itertools import permutations
>>>
>>> permutations('ABC', 2)
<itertools.permutations object at 0x1074d9c50>
>>>
>>> list(permutations('ABC', 2))
[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
>>>
>>> list(permutations('ABC'))
[('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')]
>>>combinations
combinations 用於求序列的組合，它的使用形式如下：
combinations(iterable, r)
其中，r 指定生成組合的元素的長度。
>>> from itertools import combinations
>>>
>>> list(combinations('ABC', 2))
[('A', 'B'), ('A', 'C'), ('B', 'C')]combinations_with_replacement
combinations_with_replacement 和 combinations 類似，但它生成的組合包含自身元素。
>>> from itertools import combinations_with_replacement
>>>
>>> list(combinations_with_replacement('ABC', 2))
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]小結
itertools 模塊提供了很多用於產生多種類型迭代器的函數，它們的返回值不是 list，而是迭代器。