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')]
其他更多示例可参看官方文档