当谈到在Python中优雅地处理迭代任务时，itertools库是一个不可或缺的工具。这个强大的库提供了一系列用于创建、操作和合并迭代器的函数，能够让你的代码更加紧凑、高效，并且更易于阅读和维护。无论是解决排列组合问题、处理无限序列，还是简化循环结构，itertools都能够成为你的得力助手。
Python itertool
- 迭代器：无处不在的序列掌舵者
- Python中的组合迭代器
- 在最短输入序列上终止的迭代器
- 1. accumulate(iterable [,func])
- 2. chain(*iterables)
- 3. chain.from_iterable(iterable)
- 4. compress(data, selectors)
- 5. dropwhile(predicate, iterable)
- 6. filterfalse(predicate, iterable)
- 7. groupby(iterable, key=None)
- 8. islice(iterable, stop)
- 9. starmap(function, iterable)
- 10. takewhile(predicate, iterable)
- 11. tee(n=2)
- 12. zip_longest(*iterables, fillvalue=None)
迭代器：无处不在的序列掌舵者
在深入探讨itertools之前，让我们先来了解一下什么是迭代器。在Python中，迭代器是一种对象，它可以逐个地返回元素，而无需事先将所有元素加载到内存中。这在处理大型数据集时尤为重要，因为它允许我们按需处理数据，而不必一次性加载全部内容。
例如，你可以使用以下方式创建一个简单的迭代器，以输出从1到5的数字：
class SimpleIterator:
def __init__(self, start, end):
self.current = start
self.end = end
def __iter__(self):
return self
def __next__(self):
if self.current <= self.end:
value = self.current
self.current += 1
return value
else:
raise StopIteration
# 使用自定义迭代器输出数字
my_iterator = SimpleIterator(1, 5)
for num in my_iterator:
print(num)
然而，Python的itertools库将迭代器的创建和操作提升到了一个全新的水平，让我们能够以更简洁的方式处理各种迭代任务。
1.count(start=0, step=1)
count() 函数可以接受两个参数：start 和 step。它会从 start 开始，以步长为 step 生成一个值序列。
from itertools import count
# 从10开始，步长为2的计数器
for i in count(10, 2):
print(i)
if i > 25:
break
输出：
10
12
14
16
18
20
22
24
26
此外，count() 也可以只使用一个参数，表示从该值开始，步长为1：
from itertools import count
# 从2开始，步长为1的计数器
for i in count(2):
print(i)
输出：
2
3
4
5
6
7
...
如果不传入任何参数，默认从0开始：
from itertools import count
# 从0开始，步长为1的计数器
for i in count():
print(i)
输出：
0
1
2
3
4
5
...
请注意，当使用无限循环时，最好加上终止条件以避免无限循环。在上述示例中，我在 for 循环中添加了 if i > 25: break 以确保循环在某个条件下终止。
通过使用 count() 函数，你可以轻松生成各种连续数字序列，并根据需要调整起始值和步长。这在许多数字生成的场景中都非常有用，如生成时间序列、索引等。
2.cycle(iterable)
cycle() 函数会从可迭代对象中生成一个迭代器，并保存其元素的副本。一旦原始可迭代对象的元素被耗尽，它会无限循环地返回这些副本中的元素。
from itertools import cycle
colors = cycle(['red', 'green', 'blue'])
for color in colors:
print(color)
输出：
red
green
blue
red
green
blue
red
green
blue
...
cycle() 函数可以处理任何类型的可迭代对象
3.repeat(elem [,n])
repeat() 函数会将元素 elem 重复生成 n 次，或者如果不提供 n，则会无限次重复生成到迭代器中。
from itertools import repeat
# 将元素 'Red' 重复生成 3 次
for i in repeat('Red', 3):
print(i)
输出：
Red
Red
Red
如果不指定重复次数，它会无限次重复：
from itertools import repeat
# 将元素 'Red' 无限次重复生成
for i in repeat('Red'):
print(i)
输出：
Red
Red
Red
Red
Red
...
在使用 repeat() 时，要注意避免无限循环。与之前提到的函数一样，在处理无限循环时最好添加终止条件，以确保循环不会无限运行。
通过使用 cycle() 和 repeat() 函数，你可以轻松地生成重复序列，无论是从一个固定的集合中循环获取元素，还是生成一组重复的值。这在创建模拟数据或执行特定重复操作时非常有用。
Python中的组合迭代器
组合（Combinatorial）指的是离散数学元素的排列、操作和选择。现在，让我们来谈谈关于组合迭代器的内容。
1. product(*iterables, repeat=1)
product() 函数返回输入可迭代对象的笛卡尔积。这等效于一个嵌套的 for 循环。
from itertools import product
# 两个可迭代对象的笛卡尔积
for i in product([1, 2, 3], [4, 5, 6]):
print(i)
输出：
(1, 4)
(1, 5)
(1, 6)
(2, 4)
(2, 5)
(2, 6)
(3, 4)
(3, 5)
(3, 6)
这与使用生成器对象进行的嵌套 for 循环等效：
for i in ((i, j) for i in [1, 2, 3] for j in [4, 5, 6]):
print(i)
输出同上。
product() 函数可以处理任何类型的可迭代对象，并生成它们的笛卡尔积。
2. permutations(iterable, r=None)
permutations() 函数返回可迭代对象中长度为 r 的排列。
它按字典顺序生成所有可能的排列，且元素不重复。
from itertools import permutations
# 'ABCD' 中的排列
for i in permutations('ABCD'):
print(i)
输出：
('A', 'B', 'C', 'D')
('A', 'B', 'D', 'C')
('A', 'C', 'B', 'D')
('A', 'C', 'D', 'B')
...
如果不传入第二个参数，它会生成与可迭代对象长度相等的元组。
3. combinations(iterable, r)
combinations() 函数从可迭代对象中生成长度为 r 的子序列。
from itertools import combinations
# 'ABCD' 中的长度为 2 的子序列
for i in combinations('ABCD', 2):
print(i)
输出：
('A', 'B')
('A', 'C')
('A', 'D')
('B', 'C')
('B', 'D')
('C', 'D')
combinations() 生成的元组是按照字典顺序递增的。
4. combinations_with_replacement(iterable, r)
combinations_with_replacement() 函数返回长度为 r 的子序列，其中元素可能重复。
from itertools import combinations_with_replacement as cwr
# 'ABCD' 中的长度为 2 的子序列，元素可能重复
for i in cwr('ABCD', 2):
print(i)
输出：
('A', 'A')
('A', 'B')
('A', 'C')
('A', 'D')
('B', 'B')
('B', 'C')
('B', 'D')
('C', 'C')
('C', 'D')
('D', 'D')
通过使用这些组合迭代器函数，你可以在处理排列组合问题时，以一种优雅、高效的方式生成所需的组合序列。无论是生成元素排列、子序列还是笛卡尔积，itertools 都能让你的代码变得更加简洁和易于理解。
在最短输入序列上终止的迭代器
1. accumulate(iterable [,func])
accumulate() 函数创建一个累积求和的迭代器（或根据指定的二元函数进行累积运算）。
from itertools import accumulate
# 对列表中的元素进行累积求和
for i in accumulate([0, 1, 0, 1, 1, 2, 3, 5]):
print(i)
输出：
0
1
1
2
3
4
7
12
这也可以用来打印斐波那契数列。
另一个例子：
import operator
# 使用乘法函数对列表中的元素进行累积运算
for i in accumulate([1, 2, 3, 4, 5], operator.mul):
print(i)
输出：
1
2
6
24
120
2. chain(*iterables)
chain() 函数从第一个可迭代对象开始生成迭代器，然后是第二个，以此类推。
一旦一个可迭代对象耗尽，它会切换到下一个可迭代对象。
from itertools import chain
# 连接多个可迭代对象的元素
for i in chain('Hello', 'World', 'Bye'):
print(i)
输出：
H
e
l
l
o
W
o
r
l
d
B
y
e
3. chain.from_iterable(iterable)
chain.from_iterable() 是 chain() 的替代构造函数。它从单个可迭代对象参数中获取链接的输入，并以惰性方式进行评估。
from itertools import chain
# 与上例相同，但不需要额外导入
for i in chain.from_iterable(['Hello', 'World', 'Bye']):
print(i)
输出同上。
4. compress(data, selectors)
compress() 函数根据选择器值为 True 的情况，对数据进行过滤。
from itertools import compress
# 根据选择器过滤数据
for i in compress('ABCDEF', [1, 0, 1, True, 0, ' ']):
print(i)
输出：
A
C
D
F
5. dropwhile(predicate, iterable)
只要谓词为 True，就从可迭代对象中丢弃元素。一旦谓词为 False，就开始返回每个元素。
from itertools import dropwhile
# 丢弃满足条件的元素
for i in dropwhile(lambda x: x < 7, [1, 2, 7, 9, 5, 3, 2, 9]):
print(i)
输出：
7
9
5
3
2
9
6. filterfalse(predicate, iterable)
filterfalse() 函数根据谓词为 True 的情况，对可迭代对象中的元素进行过滤。
from itertools import filterfalse
# 根据条件过滤元素
for i in filterfalse(lambda x: x < 7, [1, 2, 7, 9, 5, 3, 2, 9]):
print(i)
输出：
7
9
9
# 根据条件过滤奇数
for i in filterfalse(lambda x: x % 2, [1, 2, 7, 9, 5, 3, 2, 9]):
print(i)
输出：
2
2
7
在使用 filterfalse() 时，根据谓词的真值来过滤可迭代对象中的元素。
7. groupby(iterable, key=None)
groupby() 函数创建一个迭代器，它将可迭代对象的元素按照键分组。
from itertools import groupby
# 按照键进行分组
for key, group in groupby('AAAAABBCCCCCDDDCCCBBA'):
print(list(group))
输出：
['A', 'A', 'A', 'A', 'A']
['B', 'B']
['C', 'C', 'C', 'C', 'C']
['D', 'D', 'D']
['C', 'C', 'C']
['B', 'B']
['A']
groupby() 根据键将连续的元素分组成子迭代器。
8. islice(iterable, stop)
islice() 函数创建一个迭代器，从可迭代对象中选择指定的元素。
from itertools import islice
# 选择前 2 个元素
for i in islice([1, 2, 3, 4, 5], 2):
print(i)
输出：
1
2
# 选择索引从 2 到 4 的元素
for i in islice([1, 2, 3, 4, 5], 2, 5):
print(i)
输出：
3
4
5
# 选择索引从 0 到 4，步长为 2 的元素
for i in islice([1, 2, 3, 4, 5], 0, 5, 2):
print(i)
输出：
1
3
5
9. starmap(function, iterable)
starmap() 函数根据可迭代对象中的参数计算结果。
from itertools import starmap
# 对参数进行减法计算
for i in starmap(operator.sub, [(2, 1), (7, 3), (15, 10)]):
print(i)
输出：
1
4
5
10. takewhile(predicate, iterable)
takehile() 函数创建一个迭代器，它从可迭代对象中返回元素，只要谓词为 True。与 dropwhile() 正好相反。
from itertools import takewhile
# 返回满足条件的元素
for i in takewhile(lambda x: x < 7, [1, 2, 7, 9, 5, 3, 2, 9]):
print(i)
输出：
1
2
11. tee(n=2)
tee() 函数将一个迭代器拆分为 n 个独立的迭代器。
from itertools import tee
# 将一个迭代器拆分为 3 个独立的迭代器
for i in tee([1, 2, 3, 4, 5, 6, 7], 3):
for j in i:
print(j)
print()
输出：
1
2
3
4
5
6
7
1
2
3
4
5
6
7
1
2
3
4
5
6
7
12. zip_longest(*iterables, fillvalue=None)
zip_longest() 函数通过聚合每个可迭代对象的元素创建一个迭代器。fillvalue 参数指定了较短可迭代对象中剩余位置的填充值。
from itertools import zip_longest
# 聚合两个可迭代对象的元素，填充为 '*'
for i in zip_longest('ABC', '12345', fillvalue='*'):
print(i)
输出：
('A', '1')
('B', '2')
('C', '3')
('*', '4')
('*', '5')
# 聚合三个可迭代对象的元素，填充为 '*'
for i in zip_longest('ABC', '12345', 'Hello', fillvalue='*'):
print(i)
输出：
('A', '1', 'H')
('B', '2', 'e')
('C', '3', 'l')
('*', '4', 'l')
('*', '5', 'o')
以上这些迭代器函数可以在不同场景中帮助你处理迭代数据，进行累积、分组、选择等各种操作。通过使用它们，你可以更高效地处理和操作数据序列。