关于itertools模块

关于itertools模块

——用来操作迭代器（Iterator）的一个模块，包含的函数能够创建迭代器。
函数共分为3种：

无限迭代器

1. count( start,[step] )：start指定迭代开始位置，默认为0；step指定步长，默认为1

import itertools
for i in itertools.count(1,2):
    if i<20:
        print(i,end='  ')

1  3  5  7  9  11  13  15  17  19  

2. cycle(iterables)：p为可迭代对象，如列表字符串等，用于复制自己的值并一直循环下去

import itertools
for i in itertools.cycle("1234"):
    print(i,end=' ')

1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4...

3. repeat(elem [,n])：对元素elem重复n次：

import itertools
for i in itertools.repeat("1234",3):
    print(i)

1234
1234
1234

有限迭代器

1. accumulate(iterables [,func])：计算出一个迭代器，这个迭代器是由特定的二元函数的累计结果生成的，如果不指定的话(通过func参数)，默认函数为求和函数。
   输出的元素数量与输入的可迭代对象是一致的。 但是，如果提供了关键字参数 initial，则累加会以 initial 值开始，这样输出就比输入的可迭代对象多一个元素。

import itertools
for i in itertools.accumulate([1,2,3,4,5]):
    print(i,end=' ')
for i in itertools.accumulate([1,2,3,4,5],initial=10):#指定初始值
    print(i,end=' ')
for i in itertools.accumulate([1,2,0,9,5],max):#指定最大值函数
    print(i,end=' ')

1 3 6 10 15
10 11 13 16 20 25
1 2 2 9 9 

2. chain(iterables)：把多个可迭代对象组合起来，形成一个更大的迭代器

import itertools
for i in itertools.chain('hello','python'):#指定最大值函数
    print(i,end=' ')

h e l l o p y t h o n 

3. compress(data,selectors)：返回 data 中经 selectors 真值测试为 True 的元素。迭代器在两者较短的长度处停止

import itertools
for i in itertools.compress('ABCDEFGH',[1,0,1,0,0,1]):
    print(i,end=' ')

A C F 

4. dropwhile(predicate, iterable)：如果 predicate 为true，迭代器丢弃这些元素，然后返回其他元素。注意，迭代器在 predicate 首次为false之前不会产生任何输出

import itertools
for i in itertools.dropwhile(lambda x: x<5, [1,4,6,7,2,1]):
    print(i,end=' ')

6 7 2 1 

5. filterfalse(predicate, iterable)： 只返回 iterable 中 predicate 为 False 的元素。如果 predicate 是 None，返回真值测试为false的元素。

import itertools
for i in itertools.filterfalse(lambda x: x<5, [1,4,5,7,2,1]):
    print(i,end=' ')

5 7

6. groupby(iterable[, key])：相邻元素按照 key 函数分组，并返回相应的 key 和 groupby，如果key函数为 None，则只有相同的元素才能放在一组。

import itertools
for key,group in itertools.groupby('AaAABBbCC'):
    print(list(group))
print('-----------------------------')
for key,group in itertools.groupby('AaAABBbCC',lambda c:c.upper()):
    print(list(group))

['A']
['a']
['A', 'A']
['B', 'B']
['b']
['C', 'C']
-----------------------------
['A', 'a', 'A', 'A']
['B', 'B', 'b']
['C', 'C']

7. islice(iterable, start, stop[, step])/islice(iterable, stop)
   返回从 iterable 里选中的元素。如果 start 不是0，跳过 iterable 中的元素，直到到达 start 这个位置。之后迭代器连续返回元素，除非 step 设置的值很高导致被跳过。如果 stop 为 None，迭代器耗光为止；否则，在指定的位置停止。与普通的切片不同，islice() 不支持将 start ， stop ，或 step 设为负值。

import itertools
for i in itertools.islice('123456789',4):#在第4个位置上停止
    print(i,end=' ')
print('------------------------------------')
for i in itertools.islice('123456789',2,4):#在第2个位置后开始，第4个位置上停止
    print(i,end=' ')
print('------------------------------------')
for i in itertools.islice('123456789',2,8,2):#在第2个位置后开始，第8个位置上停止，步长为2
    print(i,end=' ')
print('------------------------------------')
for i in itertools.islice('123456789',2,None,2):#在第2个位置后开始，最后一个位置上停止，步长为2
    print(i,end=' ')

1 2 3 4 ------------------------------------
3 4 ------------------------------------
3 5 7 ------------------------------------
3 5 7 9 

8. starmap(function, iterable)：使用从可迭代对象中获取的参数来计算该函数

import itertools
for i in itertools.starmap(pow,[(2,3),(3,2),(4,2)]):#计算2^3，3^2,4^2
    print(i,end=' ')

8 9 16

9. takewhile(predicate, iterable)：创建一个迭代器， predicate 为真则从可迭代对象中返回元素

import itertools
for i in itertools.takewhile(lambda x:x<5,[1,2,3,4,5,6,7,8,9]):#计算2^3，3^2,4^2
    print(i,end=' ')

1 2 3 4

10. tee(iterable, n=2)：从一个可迭代对象中返回 n 个独立的迭代器。
11. zip_longest(*iterables, fillvalue=None)：从每个可迭代对象中收集元素。如果可迭代对象的长度未对齐，将根据 fillvalue 填充缺失值

import itertools
for i in itertools.zip_longest('ABCD', 'xy', fillvalue='-'):
    print(i,end=' ')

('A', 'x') ('B', 'y') ('C', '-') ('D', '-') 

组合迭代器

1. product(*iterables, repeat=1)：迪卡尔积
   如：product(A, B) 和 ((x,y) for x in A for y in B)作用相同
   repeat 设定为要重复的次数。例如，product(A, repeat=4) 和 product(A, A, A, A) 作用相同

import itertools
for i in itertools.product(['a','b'],[1,2,3]):
    print(i)
for i in itertools.product('01',repeat=2):
    print(i)

('a', '1')  ('a', '2')  ('a', '3')  ('b', '1')  ('b', '2')  ('b', '3')  
('0', '0')  ('0', '1')  ('1', '0')  ('1', '1')  

2. permutations(iterable,r=None)：返回可迭代元素中的长度为r的排列组合（若r=None，则返回全排列），并且是按顺序返回的，且不包含重复的结果。

import itertools
for i in itertools.permutations('abc'):
    print(i,end='  ')
for i in itertools.permutations('abc'，r=2):
    print(i,end='  ')

('a', 'b', 'c')  ('a', 'c', 'b')  ('b', 'a', 'c')  ('b', 'c', 'a')  ('c', 'a', 'b')  ('c', 'b', 'a')  
('a', 'b')  ('a', 'c')  ('b', 'a')  ('b', 'c')  ('c', 'a')  ('c', 'b')  

3. combinations(iterable,r)： 返回可迭代对象所有的长度为 r 的子序列（这里返回所有组合，permutations返回的是排列）

import itertools
for i in itertools.combinations('abc',r=2):
    print(i,end='  ')

('a', 'b')  ('a', 'c')  ('b', 'c')  

4. combinations_with_replacement(iterable, r) ：返回一个可与自身重复的元素组合，用法类似于 combinations

import itertools
for i in itertools.combinations_with_replacement('abc',r=2):
    print(i,end='  ')

('a', 'a')  ('a', 'b')  ('a', 'c')  ('b', 'b')  ('b', 'c')  ('c', 'c')