itertools常用函数

Python 内置的 itertools 模块包含了一系列用来产生不同类型迭代器的函数或类，这些函数的返回都是一个迭代器，我们可以通过 for 循环来遍历取值，也可以使用 next() 来取值。

itertools模块提供了一下三种类型的迭代器

• 无穷迭代器：生成一个无限序列，比如像自然数1,2,3,4......
• 有限迭代器：接收一个或多个序列（可迭代对象）作为参数，进行组合、分组或过滤等；
• 组合生成器：序列（可迭代对象）的排序、组合等运算。

无穷迭代器

1.count(firstval=0,step=1)：

接收两个参数，创建一个以firstval为起始，step为步长的无限序列，默认下这两个参数分别为0,1

import itertools
#什么都没传，默认参数
nums=itertools.count()
for i in nums:
    if i >6:
        break
    print(i)
    
#count()传入两个参数，起始值，和步长
nums=itertools.count(2,3)
for i in nums:
    if i>10:
        break
    print('i',i)

2.cycle(iterable)：

创建一个迭代器，返回iterable中所有元素并保存一个副本，当取玩iterable中所有元素，返回副本中所有元素，无限重复

#cycle()用于对itertools中的元素反复循环
import itertools
cycle_strings=itertools.cycle('ABC')
k=0
for i in cycle_strings:
    k+=1
    if k>7:
        break
    print(i)

#输出
# A
# B
# C
# A
# B
# C
# A

3.repeat(object[,times])：

创建一个迭代器，不断重复object，若设置了times，则将object重复times次，否则无限循环重复

#反复生成object，若给定times,则重复次数为times，否则为无限次
import itertools
for item in itertools.repeat('hello world',3):
    print(item)
    
# 输出
# hello world
# hello world
# hello world

有限迭代器

1.accumulate(iterable[,func])：

生成一个迭代器，若没有指定func这默认将iterable中各个部分进行累加

from itertools import accumulate
import operator
a=[1,2,3,4,5]
print(list(accumulate(a)))
#输出[1, 3, 6, 10, 15]，
print(list(accumulate(a,operator.mul)))
#输出[1, 2, 6, 24, 120]

2.chain(iter1,iter2,...)：

可以将多个iter1，iter2...中的元素进行连接输出

from itertools import chain

for item in chain([1,2,3],['a','b','c','d']):
    print(item)
# 1
# 2
# 3
# a
# b
# c
# d

3.compress(data,selectors)：

创建一个迭代器，返回经selectors进行真值测试后为True相应位置的值，若输入两个参数长短不一，那么在按照短的进行输出。

from itertools import compress
list(compress("ABCDE",[1,-1,1,0,1,1,1,1]))
# ['A', 'B', 'C', 'E']

4.dropwhile(predicate,iterable)：

创建一个迭代器，若predicate为true，丢弃iterable中相应位置的元素，这相当于一个元素筛选过程。

from itertools import dropwhile
list(dropwhile(lambda x :x<5,[1,3,6,2,1,6]))
# [6, 2, 1, 6]

5.filterfalse(predicate,iterable)：

只返回iterable中predicate为False的元素，如果predicate为None，返回真值测试为false的元素。

from itertools import filterfalse
print(list(filterfalse(None,range(1,10))))
#[]
print(list(filterfalse(lambda x: x%2,range(1,10))))
#[2, 4, 6, 8]

6.groupby(iterable,key=None)：

返回iterable中连续的键和组，key 是一个计算元素键值函数。如果未指定或为 None，key 缺省为恒等函数（identity function），返回元素不变。一般来说，iterable 需用同一个键值函数预先排序。

from itertools import groupby
for key,value_iter in groupby('aaabbbbaaccd'):
    print(key,":",list(value_iter))
print('-------------------------------')
data=['a','bb','ccc','dd','eeee','f']
for key,value_iter in groupby(data,len):
    print(key,":",list(value_iter))
    
# a : ['a', 'a', 'a']
# b : ['b', 'b', 'b', 'b']
# a : ['a', 'a']
# c : ['c', 'c']
# d : ['d']
# -------------------------------
# 1 : ['a']
# 2 : ['bb']
# 3 : ['ccc']
# 2 : ['dd']
# 4 : ['eeee']
# 1 : ['f']

7.islice(iterable,stop)或islice(iterable,start,stop[,step])：

相当于切片

from itertools import islice
print(list(islice([10,6,2,8,1,3,9],5)))#选择前5个元素，包括第五个
#[10, 6, 2, 8, 1]
print(list(islice([10,6,2,8,1,3,9],1,5)))
# [6, 2, 8, 1]

8.startmap(func,iterable)：

创建一个迭代器，使用从可迭代对象中获取的参数来计算该函数。当参数对应的形参已从一个单独可迭代对象组合为元组时（数据已被“预组对”）可用此函数代替 map()。

from itertools import starmap
list(starmap(pow,[(2,5),[3,2],[10,3]]))
# [32, 9, 1000]

9.takewhile(predicate,iterable)：

创建一个迭代器，只要 predicate 为真就从可迭代对象中返回元素

from itertools import takewhile
list(takewhile(lambda x:x<5,[1,2,3,6,2,1]))
# [1, 2, 3]

10.tee(iterable,n=2)：

从一个可迭代对象中返回 n 个独立的迭代器

from itertools import tee
iter1 = tee('abcde')
for key,item in enumerate(iter1):
    print(list(item))
# ['a', 'b', 'c', 'd', 'e']
# ['a', 'b', 'c', 'd', 'e']

11.zip_longest(*iterables,fillvalue=None)：

创建一个迭代器，从每个可迭代对象中收集元素。如果可迭代对象的长度未对齐，将根据 fillvalue 填充缺失值。迭代持续到耗光最长的可迭代对象。

from itertools import zip_longest
list(zip_longest('a','bbbb','dabcfd',fillvalue='-'))
# 输出：
# [('a', 'b', 'd'),
#  ('-', 'b', 'a'),
#  ('-', 'b', 'b'),
#  ('-', 'b', 'c'),
#  ('-', '-', 'f'),
#  ('-', '-', 'd')]

组合生成器

1.product(*iterables,repeat=1)：

可迭代对象输入的笛卡儿积。用于求解多个可迭代对象的笛卡尔积。与嵌套for循环等价。其中，repeat 是一个关键字参数，用于指定重复生成序列的次数。

from itertools import product
for item in product('ab','c'):
    print(item)
# ('a', 'c')
# ('b', 'c')

print(list(product('ab','c',repeat=2)))

# [('a', 'c', 'a', 'c'), ('a', 'c', 'b', 'c'), ('b', 'c', 'a', 'c'), ('b', 'c', 'b', 'c')]

2.permutations(iterable,r=None)：

连续返回由 iterable 元素生成长度为 r 的排列。

如果 r 未指定或为 None ，r 默认设置为 iterable 的长度，这种情况下，生成所有全长排列。

排列依字典序发出。因此，如果 iterable 是已排序的，排列元组将有序地产出。

即使元素的值相同，不同位置的元素也被认为是不同的。如果元素值都不同，每个排列中的元素值不会重复。

from itertools import permutations
print(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')]

3.combinations(iterable,r)：

返回由输入 iterable 中元素组成长度为 r 的子序列。

组合按照字典序返回。所以如果输入 iterable 是有序的，生成的组合元组也是有序的。

即使元素的值相同，不同位置的元素也被认为是不同的。如果元素各自不同，那么每个组合中没有重复元素。

from itertools import combinations,permutations

print("permutations：",list(permutations('ABC',2)))
print("combinations：",list(combinations("ABC",2)))

# permutations： [('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
# combinations： [('A', 'B'), ('A', 'C'), ('B', 'C')]

4.combinations_with_replacement(iterable, r)：

返回由输入 iterable 中元素组成的长度为 r 的子序列，允许每个元素可重复出现。

组合按照字典序返回。所以如果输入 iterable 是有序的，生成的组合元组也是有序的。

不同位置的元素是不同的，即使它们的值相同。因此如果输入中的元素都是不同的话，返回的组合中元素也都会不同。

from itertools import combinations_with_replacement,permutations

print('permutations：',list(permutations('ABC',2)))
print('combinations_with_replacement：',list(combinations_with_replacement("ABC",2)))

# permutations： [('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
# combinations_with_replacement： [('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]