python3常用库之itertools使用

无限迭代器

import itertools


# 无限迭代器
# 无限序列只有在for迭代时才会无限地迭代下去，如果只是创建了一个迭代对象，它不会事先把无限个元素生成出来，事实上也不可能在内存中创建无限多个元素。
natuals = itertools.count(1)
odd = itertools.count(0, 2)
cs = itertools.cycle("ABC")
ns = itertools.repeat("A")

# repeat提供第二个参数就可以限定重复次数
ns = itertools.repeat("A", 3)
print(list(ns))  # ['A', 'A', 'A']

accumulate

将可迭代对象中的元素累积起来，可指定累积的函数

# 将可迭代对象中的元素累积起来，可指定累积的函数
res = itertools.accumulate([1, 2, 3, 4, 5])
print(list(res))  # [1, 3, 6, 10, 15]

chain

把一组迭代对象串联起来，形成一个更大的迭代器

# 把一组迭代对象串联起来，形成一个更大的迭代器
c = itertools.chain("abc", "xyz")
print(list(c))  # ['a', 'b', 'c', 'x', 'y', 'z']

c = itertools.chain.from_iterable(["abc", "xyz"])
print(list(c))  # ['a', 'b', 'c', 'x', 'y', 'z']

groupby

groupby()把迭代器中相邻的重复元素挑出来放在一起

# groupby()把迭代器中相邻的重复元素挑出来放在一起
for key, group in itertools.groupby("AAABBBCCAAA"):
    print(key, list(group))

# A ["A", "A", "A"]
# B ["B", "B", "B"]
# C ["C", "C"]
# A ["A", "A", "A"]

for key, group in itertools.groupby("AaaBBbcCAAa", lambda c: c.upper()):
    print(key, list(group))

# A ["A", "a", "a"]
# B ["B", "B", "b"]
# C ["c", "C"]
# A ["A", "A", "a"]

dropwhile

返回在预测失败之后的序列元素

# 返回在预测失败之后的序列元素
l = itertools.dropwhile(lambda x: x < 5, [1, 3, 5, 2])
print(list(l))  # [5, 2]

filterfalse

筛选使预测结果为假的序列元素

# 筛选使预测结果为假的序列元素
l = itertools.filterfalse(lambda x: x < 5, [1, 3, 5, 2])
print(list(l))  # [5]

 takewhile

 根据条件判断来截取出一个有限的序列 

# 根据条件判断来截取出一个有限的序列
ns = itertools.takewhile(lambda x: x <= 5, natuals)
print(list(ns))  # [1, 2, 3, 4, 5]

 compress

通过选择器筛选数据元素序列

# 通过选择器筛选数据元素序列
res = itertools.compress("ABCDE", [1, 0, 1, 1, 0])
print(list(res))  # ['A', 'C', 'D']

 islice

# 切片
res = itertools.islice("ABCDE", 2)
print(list(res))  # ['A', 'B']

res = itertools.islice("ABCDE", 2, None)
print(list(res))  # ['C', 'D', 'E']

 pairwise

返回序列中两两相邻的元素

# 返回序列中两两相邻的元素
res = itertools.pairwise("ABCD")
print(list(res))  # [('A', 'B'), ('B', 'C'), ('C', 'D')]

 starmap

 对可迭代对象中的元素应用函数，元素以参数元组的形式传递给函数 

# 对可迭代对象中的元素应用函数，元素以参数元组的形式传递给函数
res = itertools.starmap(pow, [(2, 3), [3, 4]])
print(list(res))  # [8, 81]

 tee

将一个迭代器拆分成多个相同的迭代器

# 将一个迭代器拆分成多个相同的迭代器
iter1, iter2 = itertools.tee("ABC")
print(list(iter1))  # ['A', 'B', 'C']
print(list(iter2))  # ['A', 'B', 'C']

zip_longest

将多个迭代器中的元素逐个配对，以最长的迭代器为准，可以指定填充值

# 将多个迭代器中的元素逐个配对，以最长的迭代器为准，可以指定填充值
res = itertools.zip_longest(["k1", "k2", "k3"], ["v1", "v2"], fillvalue="")
print(list(res))  # [('k1', 'v1'), ('k2', 'v2'), ('k3', '')]

product

用于计算多个可迭代对象的笛卡尔积，生成所有可能的组合

# product 用于计算多个可迭代对象的笛卡尔积，生成所有可能的组合
res = itertools.product([1, 2], [3, 4])
print(list(res))  # [(1, 3), (1, 4), (2, 3), (2, 4)]

 permutations

用于生成可迭代对象中长度为 r 的所有排列

# permutations 函数用于生成可迭代对象中长度为 r 的所有排列
res = itertools.permutations([1, 2, 3], 2)
print(list(res))  # [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

 combinations

# combinations 函数用于生成可迭代对象中长度为 r 的所有组合，按照排序顺序生成
res = itertools.combinations([1, 2, 3], 2)
print(list(res))  # [(1, 2), (1, 3), (2, 3)]

# combinations_with_replacement 函数与 combinations 类似，用于生成可迭代对象中长度为 r 的所有组合，可以包含重复元素
res = itertools.combinations_with_replacement([1, 2, 3], 2)
print(list(res))  # [(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)]