itertools的常用函数及使用示例

itertools

itertools,正如官方文档描述Functions creating iterators for efficient looping,本模块标准化了一个快速、高效利用内存的核心工具集,这些工具本身或组合都很有用。至于什么是迭代器iterator可进一步参看之前的文章可迭代对象、迭代器、生成器

常用方法及示例

无穷迭代器:

迭代器 实参 结果 示例
count() start, [step] start, start+step, start+2*step, ... count(10) --> 10 11 12 13 14 ...
cycle() p p0, p1, ... plast, p0, p1, ... cycle('ABCD') --> A B C D A B C D ...
repeat() elem [,n] elem, elem, elem, ... 重复无限次或n次 repeat(10, 3) --> 10 10 10

根据最短输入序列长度停止的迭代器:

迭代器 实参 结果 示例
accumulate() p [,func] p0, p0+p1, p0+p1+p2, ... accumulate([1,2,3,4,5]) --> 1 3 6 10 15
chain() p, q, ... p0, p1, ... plast, q0, q1, ... chain('ABC', 'DEF') --> A B C D E F
chain.from_iterable() iterable p0, p1, ... plast, q0, q1, ... chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
compress() data, selectors (d[0] if s[0]), (d[1] if s[1]), ... compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
dropwhile() pred, seq seq[n], seq[n+1], ... 从pred首次真值测试失败开始 dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1
filterfalse() pred, seq seq中pred(x)为假值的元素,x是seq中的元素。 filterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8
groupby() iterable[, key] 根据key(v)值分组的迭代器
islice() seq, [start,] stop [, step] seq[start:stop:step]中的元素 islice('ABCDEFG', 2, None) --> C D E F G
starmap() func, seq func(*seq[0]), func(*seq[1]), ... starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000
takewhile() pred, seq seq[0], seq[1], ..., 直到pred真值测试失败 takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4
tee() it, n it1, it2, ... itn 将一个迭代器拆分为n个迭代器
zip_longest() p, q, ... (p[0], q[0]), (p[1], q[1]), ... zip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-

排列组合迭代器:

迭代器 实参 结果 示例
product() p, q, ... [repeat=1] 笛卡尔积,相当于嵌套的for循环 product('ABCD', repeat=2)-->AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
permutations() p[, r] 长度r元组,所有可能的排列,无重复元素 permutations('ABCD', 2)-->AB AC AD BA BC BD CA CB CD DA DB DC
combinations() p, r 长度r元组,有序,无重复元素 combinations('ABCD', 2)-->AB AC AD BC BD CD
combinations_with_replacement() p, r 长度r元组,有序,元素可重复 combinations_with_replacement('ABCD', 2)-->AA AB AC AD BB BC BD CC CD DD
  • repeat(object[, times]):重复无限次或times次
import itertools

a = itertools.repeat(10, 3)
print(a, type(a))
print(next(a))
print(next(a))
print(next(a))
# print(next(a)) # StopIteration

print(list(itertools.repeat([1, 2, 3], 3)))
--------------输出结果-------------
repeat(10, 3) <class 'itertools.repeat'>
10
10
10
[[1, 2, 3], [1, 2, 3], [1, 2, 3]]
  • chain(*iterables):将多个序列(可迭代对象)处理为单个序列
  • chain.from_iterable(iterable):从一个单独的可迭代参数中得到链式输入
import itertools

a = [1, 2, 4]
b = range(5)
print(list(itertools.chain(a, b)))
print(list(itertools.chain.from_iterable(['abc', 'def'])))
----------输出结果-----------
[1, 2, 4, 0, 1, 2, 3, 4]
['a', 'b', 'c', 'd', 'e', 'f']
  • dropwhile(predicate, iterable):按照真值函数丢弃掉列表和迭代器前面(如果为真则丢弃)的元素
  • filterfalse(predicate, iterable):只返回 iterable 中 predicate 为 False 的元素
import itertools

print(list(itertools.dropwhile(lambda x: x < 5, [1, 3, 4, 9, 8, 1, 3, 4])))
print(list(itertools.filterfalse(lambda x: x < 5, [1, 3, 4, 9, 8, 1, 3, 4])))
---------------------输出结果------------------------
[9, 8, 1, 3, 4]
[9, 8]
  • groupby(iterable, key=None):创建一个迭代器,返回 iterable 中连续的键和组,key 是一个计算元素键值函数
import itertools

l = [1, 2, 2, 1, 1, 3, 3, 5, 7, 7]

for k, v in itertools.groupby(l):
    print(k, list(v))

print('*' * 30)

for k, v in itertools.groupby(l, key=lambda x: x < 5):
    print(k, list(v))
-------------输出结果--------------------
1 [1]
2 [2, 2]
1 [1, 1]
3 [3, 3]
5 [5]
7 [7, 7]
******************************
True [1, 2, 2, 1, 1, 3, 3]
False [5, 7, 7]
  • takewhile(predicate, iterable):创建一个迭代器,只要 predicate 为真就从可迭代对象中返回元素
import itertools

print(list(itertools.takewhile(lambda x: x < 5, [1, 4, 6, 4, 1])))
---------------输出结果-----------------
[1, 4]
  • zip_longest(*iterables, fillvalue=None):创建一个迭代器,从每个可迭代对象中收集元素。如果可迭代对象的长度未对齐,将根据 fillvalue 填充缺失值,可参考对比zip函数
import itertools

print(list(itertools.zip_longest('abc', 'de')))
print(list(itertools.zip_longest('abc', 'de', fillvalue='default')))
-------------输出结果-------------------
[('a', 'd'), ('b', 'e'), ('c', None)]
[('a', 'd'), ('b', 'e'), ('c', 'default')]
  • product(*iterables, repeat=1):可迭代对象输入的笛卡儿积,大致相当于生成器表达式中的嵌套循环。例如, product(A, B) 和 ((x,y) for x in A for y in B) 返回结果一样
import itertools

print(list(itertools.product('abc', 'de')))
print(list(itertools.product('abc', 'abc')))
print(list(itertools.product('abc', repeat=2)))
-----------------输出结果-----------------
[('a', 'd'), ('a', 'e'), ('b', 'd'), ('b', 'e'), ('c', 'd'), ('c', 'e')]
[('a', 'a'), ('a', 'b'), ('a', 'c'), ('b', 'a'), ('b', 'b'), ('b', 'c'), ('c', 'a'), ('c', 'b'), ('c', 'c')]
[('a', 'a'), ('a', 'b'), ('a', 'c'), ('b', 'a'), ('b', 'b'), ('b', 'c'), ('c', 'a'), ('c', 'b'), ('c', 'c')]

其他更多示例可参看官方文档

参考及扩展阅读