python迭代器模块itertools的常用方法

itertools是python中内置的一种高效的生成各种迭代器或者是类的模块,这些函数的返回值为一个迭代器,经常被用在for循环中,当然,也可直接使用next()方法取值,今天就来说说itertools中的常用方法。

itertools按照迭代器的功能可分为三类:
无限迭代器: 生成一个无限序列，比如自然数序列 1, 2, 3, 4, …
有限迭代器: 接收一个或多个序列（sequence）作为参数，进行组合、分组和过滤等；
组合迭代器: 序列的排列、组合，求序列的笛卡儿积等

一、无限迭代器

1、itertools.count(start=0, step=1)
创建一个迭代器，生成从start开始的连续(+step)整数。start默认为0，step默认为1。

import itertools
a = itertools.count()
for x in a:
    if x > 5:
        break
    print(x)
>>>
0
1
2
3
4
5

b = itertools.count(2,3)
for x in b:
    if x > 10:
        break
    print(x)
>>>
2
5
8

2、itertools.cycle(iterable)
创建一个迭代器，对iterable中的元素反复执行循环操作，内部会生成iterable中的元素的一个副本，此副本用于返回循环中的重复项。iterable: 可迭代对象,可以为一个列表、字符串、元组等

import itertools
a = ['a','b','c']
i = 0
for x in itertools.cycle(a):
    i = i +1
    if i > 5:
        break
    print(i,x)
>>>
1 a
2 b
3 c
4 a
5 b

3、itertools.repeat(object[, times])
创建一个迭代器，重复生成object，times（如果已提供）指定重复计数，如果未提供times，将无止尽返回该对象。object: 需要重复的对象，对象是个整体；times: 重复次数。

import itertools
for x in itertools.repeat([1,2,3],3):
    print(x)
>>>
[1,2,3]
[1,2,3]
[1,2,3]

二、有限迭代器
1、itertools.chain(iterable1, iterable2, …)
将多个迭代器作为参数, 但只返回单个迭代器, 它产生所有参数迭代器的内容, 就好像他们是来自于一个单一的序列。参数为多个可迭代对象,就好像被链条衔接起来了一样。

import itertools
for x in itertools.chain([1,2,3],'abc'):
    print(x)
>>>
1
2
3
a
b
c

需要注意的是：'abc'被拆成了'a','b','c'。

for x in itertools.chain([1,2,3],['a','b','c']):
    print(x)
>>>
1
2
3
a
b
c

2、itertools.chain.from_iterable(iterable)
接收一个可迭代对象作为参数，返回一个迭代器

import itertools
a = [['first','second','thrid'],['a','b','c']]
b = [[1,2,3],[4,5,6]]
for x in range(len(a)):
    print(list(itertools.chain.from_iterable(zip(a[x],b[x]))))
>>>
['first', 1, 'second', 2, 'thrid', 3]
['a', 4, 'b', 5, 'c', 6]

3、itertools.compress(data, selectors)
可用于对数据进行筛选，当 selectors 的某个元素为 true 时，则保留 data 对应位置的元素，否则去除
data: 待筛选数据
selectors: 当为真时,保留data对应位的数据,为假或为空时则去除

for x in itertools.compress(['a','b','c','d'],[1,0,2]):
    print(x)
>>>
a
c

4、itertools.dropwhile(predicate, iterable)
创建一个迭代器，只要函数predicate(item)为True，就丢弃iterable中的项，如果predicate返回False，就会生成iterable中的项和所有后续项,即第一个不满足条件的项及它后面所有的项都返回。predicate: 函数；iterable: 可迭代对象

print(list(itertools.dropwhile(lambda x: x < 5, [1, 3, 6, 2, 1])))
>>>
[6, 2, 1]

从6开始不符合x < 5 条件,所以6及6后面所有的项都需要返回。

5、itertools.takewhile(predicate, iterable)
创建一个迭代器，如果predicate返回False,立即停止迭代。

print(list(list(itertools.takewhile(lambda x: x < 5, [1, 3, 6, 2, 1]))))
>>>
[1, 3]

6、itertools.ifilter(predicate, iterable)
创建一个迭代器，仅生成iterable中predicate(item)为True的项，如果predicate为None，将返回iterable中所有计算为True的项predicate: 函数；iterable: 可迭代对象
Python3将该方法移除了，Python内置的filter可以实现相同功能。filter()函数能够从可迭代对象（如字典、列表）中筛选某些元素，并生成一个新的迭代器。

l = [3, 6, 1, 0, 9, 5, 6]
print(list(filter(lambda x: x < 6, l)))
>>>
[3, 1, 0, 5]

l = [3, 6, 1, 0, 9, 5, [], 6, '', None, 1, False]
print(list(filter(None, l)))
>>>
[3, 6, 1, 9, 5, 6, 1]

 7、itertools.ifilterfalse(predicate, iterable)
创建一个迭代器，仅生成iterable中predicate(item)为False的项，如果predicate为None，将返回iterable中所有计算False的项,该函数正好跟ifilter相反。
Python3将该方法移除了，itertools.filterfalse可以实现相同功能。filterfalse()函数能够从可迭代对象（如字典、列表）中筛选某些元素，并生成一个新的迭代器。与filter相反。

import itertools

l = [3, 6, 1, 0, 9, 5, 6]
print(list(itertools.filterfalse(lambda x: x < 6, l)))
>>>
[6, 9, 6]

import itertools

l = [3, 6, 1, 0, 9, 5, [], 6, '', None, 1, False]
print(list(itertools.filterfalse(None, l)))
>>>
[0, [], '', None, False]

8、itertools.groupby(iterable[, key])

返回一个产生按照key进行分组后的值集合的迭代器。iterable:可迭代对象；key: 一个函数,该函数的返回值做为分组的标准

a = ['aa', 'ab', 'abc', 'bcd', 'abcde']
for i, k in itertools.groupby(a, len):
    print(i, list(k))
>>>
2 ['aa', 'ab']
3 ['abc', 'bcd']
5 ['abcde']

9、itertools.islice(iterable, start, stop[, step])
切片，创建一个从可迭代对象中返回选定元素的迭代器。iterable 是可迭代对象，start 是开始索引,默认为0，stop 是结束索引，step 是步长，默认为1，start 和 step 可选。

print(list(itertools.islice([10, 6, 2, 8, 1, 3, 9], 5)))
>>>
[10, 6, 2, 8, 1]

print(list(itertools.islice(itertools.count(), 3, 10, 2)))#这里的count()为文章第一个函数,用来产生自然数无限序列
>>>
[3, 5, 7, 9]

 10、itertools.imap(func, iter1, iter2, iter3, …)
返回一个迭代器, 它是调用了一个其值在输入迭代器上的函数, 返回结果。Python3将该方法移除了，Python的内置函数map()函数可以实现相同功能。根据提供的函数对指定的序列做映射。

print(list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])))
>>>
[3, 7, 11, 15, 19]

print(list(map(lambda x, y: (x ** y, x + y), [2, 4, 6], [3, 2, 1])))
>>>
[(8, 5), (16, 6), (6, 7)]

11、itertools.izip(*iterables)
用于将多个可迭代对象对应位置的元素作为一个元组，将所有元组『组成』一个迭代器，并返回。Python3将该方法移除了，Python的内置函数zip()函数可以实现相同功能。

print(dict(zip([1, 2, 3], ['a', 'b', 'c', 'd', 'e'])))
for item in zip([1, 2, 3], ['a', 'b', 'c', 'd', 'e']):
    print(item)
>>>
{1: 'a', 2: 'b', 3: 'c'}
(1, 'a')
(2, 'b')
(3, 'c')

三、组合迭代器
1、itertools.product(iterables[, repeat])
创建一个迭代器，生成表示item1，item2等中的项目的笛卡尔积的元组，repeat是一个关键字参数，指定重复生成序列的次数。用来产生笛卡尔积。

a = (1, 2, 3)
b = ('A', 'B', 'C')
c = itertools.product(a, b)
print(list(c))
>>>
[(1, 'A'), (1, 'B'), (1, 'C'), (2, 'A'), (2, 'B'), (2, 'C'), (3, 'A'), (3, 'B'), (3, 'C')]

print(list(itertools.product('ABC', repeat=3)))
>>>
[('A', 'A', 'A'), ('A', 'A', 'B'), ('A', 'A', 'C'), ('A', 'B', 'A'), ('A', 'B', 'B'), ('A', 'B', 'C'), ('A', 'C', 'A'), ('A', 'C', 'B'), ('A', 'C', 'C'), ('B', 'A', 'A'), ('B', 'A', 'B'), ('B', 'A', 'C'), ('B', 'B', 'A'), ('B', 'B', 'B'), ('B', 'B', 'C'), ('B', 'C', 'A'), ('B', 'C', 'B'), ('B', 'C', 'C'), ('C', 'A', 'A'), ('C', 'A', 'B'), ('C', 'A', 'C'), ('C', 'B', 'A'), ('C', 'B', 'B'), ('C', 'B', 'C'), ('C', 'C', 'A'), ('C', 'C', 'B'), ('C', 'C', 'C')]

for i, j in itertools.product(range(10),range(10))等同于两层for循环rang(10)
2、itertools.permutations(iterable[, r])
创建一个迭代器，返回iterable中所有长度为r的项目序列，如果省略了r，那么序列的长度与iterable中的项目数量相同： 返回p中任意取r个元素做排列的元组的迭代器

print(list(itertools.permutations('ABC', 2)))
>>>
[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]

3、itertools.combinations(iterable, r)
创建一个迭代器，返回iterable中所有长度为r的子序列，返回的子序列中的项按输入iterable中的顺序排序 (不带重复)

print(list(itertools.combinations('ABC', 2)))
>>>
[('A', 'B'), ('A', 'C'), ('B', 'C')]

4、itertools.combinations_with_replacement(iterable, r)
创建一个迭代器，返回iterable中所有长度为r的子序列，返回的子序列中的项按输入iterable中的顺序排序 (带重复)

print(list(itertools.combinations_with_replacement('ABC', 2)))
>>>
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]