itertools.accumulate(iterable [, func]

)

　　返回一個叠代序列的累加值序列（沒有func的情況下）。

　　當指定了func（參數必須為兩個）後，將通過func進行累加。

　　註1: 當沒有傳入func時，func相當於 operator.add

　　註2: 返回值為叠代器

>>> data = [1,2,3,4]
>>> a = itertools.accumulate(data)
>>> list(a)
[1, 3, 6, 10]
#[1,2,3,4] --> [1, 1+2, (1+2)+3, ((1+2)+3)+4]

>>> b = itertools.accumulate(data, operator.mul)
 
>>> list(b)
[1, 2, 6, 24]
#[1,2,3,4] --> [1, 1*2, (1*2)*3, ((1*2)*3)*4]

itertools.chain(*iterables)

　　連接多個叠代序列為一個叠代序列，適用於需要連續遍歷多個序列場景。

　　註`: 返回值為叠代器

>>> a = [1,2,3,4,5]
>>> b = [6,7,8,9,10]
>>> c = itertools.chain(a,b)
>>> list(c)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

itertools.chain.from_iterable(iterable)

　　通過一個叠代序列來創建 itertools.chain 的對象。

　　類似於將叠代序列中的每一個對象作為 itertools.chain 的參數，因此傳入的叠代序列中的每一個對象應該也是可叠代的。

　　註1: 返回值為叠代器

>>> a = itertools.chain.from_iterable([‘abc‘, ‘def‘, ‘hjk‘])
>>> list(a)
[‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘h‘, ‘j‘, ‘k‘]
>>>
>>> b = itertools.chain.from_iterable([1,2,3])
>>> list(b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: ‘int‘ object is not iterable

itertools.combinations(iterable, r)

　　將叠代序列中的對象進行"不重復的"組合並返回所有組合的元組列表，每個組合的元素個數為r。

　　註1: 這裏的“不重復”是指叠代序列中的對象不會使用多次，但並不代表相同的值不會使用多次。

　　註2: 返回的組合順序依賴傳入的叠代序列中的順序。

　　註3: 返回值為叠代器。

>>> a = itertools.combinations(‘ABC‘,2)
>>> list(a)
[(‘A‘, ‘B‘), (‘A‘, ‘C‘), (‘B‘, ‘C‘)]
>>>
>>> b = itertools.combinations(‘CBA‘,2)
>>> list(b)
[(‘C‘, ‘B‘), (‘C‘, ‘A‘), (‘B‘, ‘A‘)]
>>>
>>> c = itertools.combinations(‘AAC‘,2)
>>> list(c)
[(‘A‘, ‘A‘), (‘A‘, ‘C‘), (‘A‘, ‘C‘)]

itertools.combinations_with_replacement(iterable, r)

　　將叠代序列中的對象進行"可重復的"組合並返回所有組合的元組列表，每個組合的元素個數為r。

　　註1: 與 itertools.combinations 的唯一區別就是元素可以重復使用。

　　註2: 返回的組合順序依賴傳入的叠代序列中的順序。

　　註3: 返回值為叠代器

>>> a = itertools.combinations_with_replacement(‘ABC‘, 2)
>>> list(a)
[(‘A‘, ‘A‘), (‘A‘, ‘B‘), (‘A‘, ‘C‘), (‘B‘, ‘B‘), (‘B‘, ‘C‘), (‘C‘, ‘C‘)]

itertools.compress(data, selectors)

　　對 data 中的數據進行過濾，只保留 selectors 中對應位置為 True 的對象。

　　data和selectors的序列長度可以不等，其中任意一個叠代終結，整個叠代即終結。

　　註1: 返回值為叠代器

>>> a = itertools.compress(‘ABCDE‘, [1,1,0,0,0])
>>> list(a)
[‘A‘, ‘B‘]
>>>
>>> b = itertools.compress(‘ABCDE‘, [1,1])
>>> list(b)
[‘A‘, ‘B‘]
>>>
>>> c = itertools.compress(‘ABC‘, [1,1,0,0,1])
>>> list(c)
[‘A‘, ‘B‘]

itertools.count(start=0, step=1)

　　生成一個計數叠代器，可以指定起始點和步進，但是沒有終點，可以一直叠代下去。

　　一般需要配合其他的叠代器一起使用，例如作為map(), zip()的參數等。

>>> a = itertools.count(start=1, step=2)
>>> next(a)
1
>>> next(a)
3
>>> next(a)
5
>>> next(a)
7
>>> next(a)
9
>>> next(a)
11
>>> next(a)
13
>>> 
>>> b = itertools.count(start=100, step=1)
>>> list(zip(b, ‘ABCDE‘))
[(100, ‘A‘), (101, ‘B‘), (102, ‘C‘), (103, ‘D‘), (104, ‘E‘)]

itertools.cycle(iterable)

　　生成一個循環叠代器，循環遍歷傳入叠代器中的對象，沒有終結。

　　一般需要配合其他叠代器一起使用，例如map(), zip() 的參數等

>>> a = itertools.cycle(‘ABC‘)
>>> next(a)
‘A‘
>>> next(a)
‘B‘
>>> next(a)
‘C‘
>>> next(a)
‘A‘
>>> next(a)
‘B‘
>>> next(a)
‘C‘
>>> next(a)
‘A‘
>>> 
>>> b = itertools.cycle(range(1,4))
>>> list(zip(‘ABCDEFG‘, b))
[(‘A‘, 1), (‘B‘, 2), (‘C‘, 3), (‘D‘, 1), (‘E‘, 2), (‘F‘, 3), (‘G‘, 1)]

itertools.dropwhile(predicate, iterable)

　　對叠代器中的對象按照 predicate 進行斷言，丟棄第一個斷言為False之前的所有對象。

　　也可以理解為從第一個斷言為False的對象開始輸出。

　　註1: 當出現第一個斷言為False的對象後，之後的對象不再進行斷言。

　　註2: predicate 代表的函數只能有一個參數。

　　註3: 返回值為叠代器

>>> a = itertools.dropwhile(lambda x: x<5, [3,4,5,6,5,4,3])
>>> list(a)
[5, 6, 5, 4, 3]

itertools.filterfalse(predicate, iterable)

　　過濾掉叠代器中按照 predicate 斷言為 True 的對象。

　　如果 predicate 傳入None, 則過濾掉值為 True 的對象。

　　註1: 返回值為叠代器

>>> a = itertools.filterfalse(lambda x: x%2==0, range(10))
>>> list(a)
[1, 3, 5, 7, 9]
>>> 
>>> b = itertools.filterfalse(None, [1,0,1,0,1,0])
>>> list(b)
[0, 0, 0]

itertools.groupby(iterable, key=None)

　　對叠代序列中的對象按照key進行分組，如果key為None則按照對象本身的值進行分組。

　　註1: 如果叠代序列中key值相等的對象中間間隔了其他的key值，則不會分在一個組。

　　註2: 返回值為一個叠代器且返回的是一個有兩個元素的元組，第一個元素為key值，第二個元素為分組對象的叠代器

>>> data = [‘abc-0‘, ‘def-0‘, ‘xyz-1‘, ‘tty-1‘, ‘kkk-2‘]
>>> a = itertools.groupby(data, lambda x:x[-1])
>>> [(k, list(g)) for k, g in a]
[(‘0‘, [‘abc-0‘, ‘def-0‘]), (‘1‘, [‘xyz-1‘, ‘tty-1‘]), (‘2‘, [‘kkk-2‘])]
>>> 
>>> 
>>> b = itertools.groupby(‘AAABBBCC‘)
>>> [(k, list(g)) for k, g in b]
[(‘A‘, [‘A‘, ‘A‘, ‘A‘]), (‘B‘, [‘B‘, ‘B‘, ‘B‘]), (‘C‘, [‘C‘, ‘C‘])]

itertools.islice(iterable, stop) itertools.islice(iterable, start, stop [, step])

　　對叠代序列進行分片，類似 slice()，但是本函數中 start, stop, step 都不能為負數。

　　參數 start 如果為 None, 則 start = 0

　　參數 stop 如果為 None, 則叠代到最後一個

　　參數 step 如果為 None, 則 step = 1

　　註1: 返回值為一個叠代器

>>> data = ‘ABCDEFG‘
>>> a = itertools.islice(data, 3)
>>> list(a)
[‘A‘, ‘B‘, ‘C‘]
>>> 
>>> b = itertools.islice(data, 1, 5, 2)
>>> list(b)
[‘B‘, ‘D‘]
>>> 
>>> c = itertools.islice(data, None, 3)
>>> list(c)
[‘A‘, ‘B‘, ‘C‘]
>>> 
>>> d = itertools.islice(data, 3, None)
>>> list(d)
[‘D‘, ‘E‘, ‘F‘, ‘G‘]

itertools.permutations(iterable, r=None)

　　將叠代序列中的對象進行"不重復的"排列組合並返回所有組合的元組列表，每個組合的元素個數為r。

　　如果r為None，則長度為叠代序列的長度。

　　註1: 這裏的“不重復”是指叠代序列中的對象不會使用多次，但並不代表相同的值不會使用多次。

　　註2: 返回的組合順序依賴傳入的叠代序列中的順序。

　　註3: 返回值為叠代器。

>>> a = itertools.permutations(‘ABC‘, 2)
>>> list(a)
[(‘A‘, ‘B‘), (‘A‘, ‘C‘), (‘B‘, ‘A‘), (‘B‘, ‘C‘), (‘C‘, ‘A‘), (‘C‘, ‘B‘)]
>>> 
>>> b = itertools.permutations(‘ABC‘)
>>> list(b)
[(‘A‘, ‘B‘, ‘C‘), (‘A‘, ‘C‘, ‘B‘), (‘B‘, ‘A‘, ‘C‘), (‘B‘, ‘C‘, ‘A‘), (‘C‘, ‘A‘, ‘B‘), (‘C‘, ‘B‘, ‘A‘)]

itertools.product(*iterables, repeat=1)

　　返回多個叠代序列的笛卡爾乘積，repeat值相當於把傳入的叠代器參數重復的次數。

　　註1: 返回值是一個叠代器

>>> a = itertools.product(‘ABCD‘, ‘xy‘)
>>> list(a)
[(‘A‘, ‘x‘), (‘A‘, ‘y‘), (‘B‘, ‘x‘), (‘B‘, ‘y‘), (‘C‘, ‘x‘), (‘C‘, ‘y‘), (‘D‘, ‘x‘), (‘D‘, ‘y‘)]
>>> 
>>> b = itertools.product(range(2), repeat=3)
>>> list(b)
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]
# 相當於 itertools.product(range(2), range(2), range(2))

itertools.repeat(object [, times])

　　返回一個叠代器，重復傳入的對象。重復的次數為 times 。

　　如果沒有傳入times參數，則無限重復。

>>> a = itertools.repeat(‘hello‘, 3)
>>> list(a)
[‘hello‘, ‘hello‘, ‘hello‘]
>>> 
>>> b = itertools.repeat(‘test‘)
>>> list(map(lambda x, y: x + y, b, ‘ABCD‘))
[‘testA‘, ‘testB‘, ‘testC‘, ‘testD‘]

itertools.starmap(function, iterable)

　　和 map() 類似。但是這裏 function 的參數封裝在叠代器中的每一個對象中。

　　註1: 叠代器中的每一個對象也必須是可叠代的，哪怕函數只有一個參數。

>>> a = itertools.starmap(lambda x,y: x**y, [(2,1), (2,2), (2,3)])
>>> list(a)
[2, 4, 8]
>>> 
>>> b = itertools.starmap(lambda x: x*x, [(1,),(2,),(3,)])
>>> list(b)
[1, 4, 9]

itertools.takewhile(predicate, iterable)

　　與 dropwhile() 相反，對叠代器中的對象按照 predicate 進行斷言，輸出第一個斷言為False之前的所有對象。

　　註1: 當出現第一個斷言為False的對象後，叠代即終止。

　　註2: predicate 代表的函數只能有一個參數。

　　註3: 返回值為叠代器

>>> a = itertools.takewhile(lambda x: x<5, [3,4,5,6,5,4,3])
>>> list(a)
[3, 4]

itertools.tee(iterable, n=2)

　　將一個叠代器復制n次，返回一個有n個叠代器的元組。n默認為2

>>> a = itertools.tee(‘ABC‘)
>>> [list(x) for x in a]
[[‘A‘, ‘B‘, ‘C‘], [‘A‘, ‘B‘, ‘C‘]]
>>> 
>>> b = itertools.tee(range(5), 3)
>>> [list(x) for x in b]
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]

itertools.zip_longest(*iterables, fillvalue=None)

　　類似於 zip()。但是這裏按照最長的叠代序列進行打包，缺少的元素用 fillvalue 的值進行填充。

　　註1: fillvalue 默認為None, 並且如果是None，填充的就是None

>>> a = itertools.zip_longest(‘ABC‘, ‘xy‘, fillvalue=‘*‘)
>>> list(a)
[(‘A‘, ‘x‘), (‘B‘, ‘y‘), (‘C‘, ‘*‘)]
>>>
>>> b = itertools.zip_longest(‘ABC‘, ‘xy‘)
>>> list(b)
[(‘A‘, ‘x‘), (‘B‘, ‘y‘), (‘C‘, None)]

Python標準庫(3.x): itertools庫掃盲