【摸鱼笔记】了解itertools，优雅处理list

背景

迭代器（Iterator）在 Python 中是一种很常用的数据结构；

相比 list ，迭代器最大的优势就是只有当迭代到某个值时才会计算这个值的结果，避免占用不必要的内存，

所以面对大型的数据集时，迭代器一般比 list 效率更高；

itertools 就是用来操作迭代器的 Python 内置模块。

简介

itertools 库是 Python 中处理迭代操作的标准工具，

在处理序列和集合时，它可以像函数式编程过程一样，在处理过程中直接过滤内容，

并且在组合处理其他序列或集合时，无需显式地创建中间序列或集合，

可以显著提高代码的开发效率和可读性。

示例：itertools 各方法使用

itertools.count(start=0, step=1)

根据传入的参数生成无限长的一串数值；

start: 指定迭代开始值，默认为 0;

step: 指定迭代的步长，默认为 1;

示例

import itertools

for i in itertools.count(start=2, step=2):
    if i > 12:
        break
    print("count 输出", i)
1
2
3
4
5
6

运行结果

count 输出 2
count 输出 4
count 输出 6
count 输出 8
count 输出 10
count 输出 12
1
2
3
4
5
6

itertools.cycle(iterable)

从传入的 iterable 中取值，当 iterable 里的值取完，会跳到 iterable 的开头重复取值，一直重复下去；

iterable: 可迭代对象，一般是 list；

示例

import itertools

l = 0

for i in itertools.cycle(range(6)):
    print("cycle 输出", i)
    if l > 8:
        break
    l += 1
1
2
3
4
5
6
7
8
9

运行结果

cycle 输出 0
cycle 输出 1
cycle 输出 2
cycle 输出 3
cycle 输出 4
cycle 输出 5
cycle 输出 0
cycle 输出 1
cycle 输出 2
cycle 输出 3
1
2
3
4
5
6
7
8
9
10

itertools.repeat(object,times)

将一个对象重复指定次数或者无限次；

object：指定重复的对象；

times：指定重复的次数，如果 times 没有传入，那么是无限次；

示例

import itertools

# 指定重复次数
for i in itertools.repeat("a", 5):
    print("指定重复次数，重复输出：", i)

# 不指定重复次数，无限循环
l = 0

for i in itertools.repeat("b"):
    print("不指定重复次数，输出：", i)
    if l > 6:
        break
    l += 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果

指定重复次数，重复输出： a
指定重复次数，重复输出： a
指定重复次数，重复输出： a
指定重复次数，重复输出： a
指定重复次数，重复输出： a
不指定重复次数，输出： b
不指定重复次数，输出： b
不指定重复次数，输出： b
不指定重复次数，输出： b
不指定重复次数，输出： b
不指定重复次数，输出： b
不指定重复次数，输出： b
不指定重复次数，输出： b
1
2
3
4
5
6
7
8
9
10
11
12
13

itertools.product(*iterables, repeat=1)

返回可迭代对象的笛卡儿积；

这些可迭代对象之间的笛卡儿积，也可以使用 for 循环来实现，

例如 product (A, B) 与 ((x,y) for x in A for y in B) 就实现一样的功能。

*iterables： 一个或多个可迭代对象；

repeat: 可迭代对象的重复次数；

示例

import itertools

# product 输出
for i in itertools.product([1, 2], [3, 4]):
    print("product 输出", i)

# for 循环实现
for i in ((x, y) for x in [1, 2] for y in [3, 4]):
    print("for 循环实现", i)
1
2
3
4
5
6
7
8
9

运行结果

product 输出 (1, 3)
product 输出 (1, 4)
product 输出 (2, 3)
product 输出 (2, 4)
for 循环实现 (1, 3)
for 循环实现 (1, 4)
for 循环实现 (2, 3)
for 循环实现 (2, 4)
1
2
3
4
5
6
7
8

repeat 参数不为默认值 1 时，可迭代对象会重复的被用在计算过程中，可以替代手动地多次传入同一个可迭代对象；

例如 product (A, repeat=2) 与 product (A, A) 实现的功能一样。

示例

import itertools

# 手动传参
for i in itertools.product([1, 2], [1, 2]):
    print("手动传参", i)
# 指定repeat
for i in itertools.product([1, 2], repeat=2):
    print("指定repeat", i)
1
2
3
4
5
6
7
8

运行结果

手动传参 (1, 1)
手动传参 (1, 2)
手动传参 (2, 1)
手动传参 (2, 2)
指定repeat (1, 1)
指定repeat (1, 2)
指定repeat (2, 1)
指定repeat (2, 2)
1
2
3
4
5
6
7
8

itertools.permutations(iterable,r=None)

返回 iterable 内元素的排列组合，不包含重复的结果；

iterable: 指定可迭代对象；

r: 返回值元组的长度，当 r 为 None 时，返回值元组长度与 iterable 相同；

示例

import itertools

# 不指定 返回值的长度
for i in itertools.permutations([1, 2, 3]):
    print("不指定 返回值的长度", "输出", i)
# 指定 返回值的长度
for i in itertools.permutations([1, 2, 3], 2):
    print("指定 返回值的长度", "输出", i)
1
2
3
4
5
6
7
8

运行结果

不指定 返回值的长度 输出 (1, 2, 3)
不指定 返回值的长度 输出 (1, 3, 2)
不指定 返回值的长度 输出 (2, 1, 3)
不指定 返回值的长度 输出 (2, 3, 1)
不指定 返回值的长度 输出 (3, 1, 2)
不指定 返回值的长度 输出 (3, 2, 1)
指定 返回值的长度 输出 (1, 2)
指定 返回值的长度 输出 (1, 3)
指定 返回值的长度 输出 (2, 1)
指定 返回值的长度 输出 (2, 3)
指定 返回值的长度 输出 (3, 1)
指定 返回值的长度 输出 (3, 2)
1
2
3
4
5
6
7
8
9
10
11
12

itertools.combinations(iterable,r)

返回所有 iterable 内元素长度为 r 的组合，每个元素不会和自己组合；

iterable: 指定可迭代对象；

r: 返回值元组的长度，r 不可为 None；

示例

import itertools

for i in itertools.combinations('1234', 2):
    print("combinations", "输出", i)
1
2
3
4

运行结果

combinations 输出 ('1', '2')
combinations 输出 ('1', '3')
combinations 输出 ('1', '4')
combinations 输出 ('2', '3')
combinations 输出 ('2', '4')
combinations 输出 ('3', '4')
1
2
3
4
5
6

itertools.combinations_with_replacement(iterable, r)

返回所有 iterable 内元素长度为 r 的组合，用法类似于 combinations 但每个元素会和自己组合；

iterable: 指定可迭代对象；

r: 返回值元组的长度，r 不可为 None；

示例

import itertools

for i in itertools.combinations_with_replacement('1234', 2):
    print("combinations_with_replacement", "输出", i)
1
2
3
4

运行结果

combinations_with_replacement 输出 ('1', '1')
combinations_with_replacement 输出 ('1', '2')
combinations_with_replacement 输出 ('1', '3')
combinations_with_replacement 输出 ('1', '4')
combinations_with_replacement 输出 ('2', '2')
combinations_with_replacement 输出 ('2', '3')
combinations_with_replacement 输出 ('2', '4')
combinations_with_replacement 输出 ('3', '3')
combinations_with_replacement 输出 ('3', '4')
combinations_with_replacement 输出 ('4', '4')
1
2
3
4
5
6
7
8
9
10

itertools.chain(*iterables)

可以把多个可迭代对象组合起来的迭代器，类似 list 的 list1 + list2。

*iterable: 一个或多个可迭代对象；

示例

import itertools

for i in itertools.chain([1, 2, 3], [1, 2]):
    print("chain", "输出", i)
1
2
3
4

运行结果

chain 输出 1
chain 输出 2
chain 输出 3
chain 输出 1
chain 输出 2
1
2
3
4
5

itertools.groupby(iterable,key=None)

可以把相邻元素按照 key 函数 分组，并返回相应的 key 和 分组后的数据；

iterable: 指定可迭代对象；

key: 分组的关键词，如果 key 为 None，则只有相同的元素才能放在一组，相当于 key=lambda x: x。

示例

import itertools

# 指定 key,在key中转换大小写
for key, group in itertools.groupby('AaBbbCccc', lambda x: x.lower().strip()):
    print("转换大小写", "输出", key, list(group))

# lambda x: x
for key, group in itertools.groupby('AaBbbCccc', lambda x: x):
    print("lambda x: x", "输出", key, list(group))

# 不指定 key
for key, group in itertools.groupby('AaBbbCccc'):
    print("不指定 key", "输出", key, list(group))

1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果

转换大小写 输出 a ['A', 'a']
转换大小写 输出 b ['B', 'b', 'b']
转换大小写 输出 c ['C', 'c', 'c', 'c']
lambda x: x 输出 A ['A']
lambda x: x 输出 a ['a']
lambda x: x 输出 B ['B']
lambda x: x 输出 b ['b', 'b']
lambda x: x 输出 C ['C']
lambda x: x 输出 c ['c', 'c', 'c']
不指定 key 输出 A ['A']
不指定 key 输出 a ['a']
不指定 key 输出 B ['B']
不指定 key 输出 b ['b', 'b']
不指定 key 输出 C ['C']
不指定 key 输出 c ['c', 'c', 'c']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

itertools.accumulate(iterable, func, initial=None])，

返回 iterable 内元素，通过 func 累计计算的值；

iterable：可迭代对象

func：计算的函数，默认为累加，也可以使用 max (),min (), 其他操作 可以指定 operator 模块提供的函数比如 operator.mul ()；

initial： 累计计算的初始值，默认为空，如果有传入，则会将 initial 作为第一个值，相当于 iterable 内的值排在 initial 后面，再计算。

示例

import itertools
import operator as opt

# 默认累加
for i in itertools.accumulate([1, 2, 2, 3]):
    print("默认累加", "输出", i)
# 每次累计取最大值
for i in itertools.accumulate([1, 2, 2, 3], max):
    print("最大值", "输出", i)
# operator.mul 乘法操作
for i in itertools.accumulate([1, 2, 2, 3], func=opt.mul):
    print("乘法操作", "输出", i)
# operator.mul 乘法操作，初始值为4
for i in itertools.accumulate([1, 2, 2, 3], func=opt.mul, initial=4):
    print("初始值为4", "输出", i)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行结果

默认累加 输出 1
默认累加 输出 3
默认累加 输出 5
默认累加 输出 8
最大值 输出 1
最大值 输出 2
最大值 输出 2
最大值 输出 3
乘法操作 输出 1
乘法操作 输出 2
乘法操作 输出 4
乘法操作 输出 12
初始值为4 输出 4
初始值为4 输出 4
初始值为4 输出 8
初始值为4 输出 16
初始值为4 输出 48
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

itertools.compress(data, selectors)

返回与 selectors 真值选择器元素相对应的 data 对象内元素。

如果 data，selectors 长度不同，则会安装短的那一个截取长度再计算；

data: 选择值的范围；

selectors：真值选择器；

示例

import itertools

# data 比 selectors 长
for i in itertools.compress(range(4), (True, True, True)):
    print("data 比 selectors 长", "输出", i)
# data 比 selectors 短
for i in itertools.compress(range(2), (True, False, True)):
    print("data 比 selectors 短", "输出", i)
1
2
3
4
5
6
7
8

运行结果

data 比 selectors 长 输出 0
data 比 selectors 长 输出 1
data 比 selectors 长 输出 2
data 比 selectors 短 输出 0
1
2
3
4

itertools.filterfalse(function, iterable, /)

返回 iterable 中传入 function 后结果为 True 的元素

iterable：可迭代对象

function：用于过滤计算的函数；

示例

import itertools

# 丢弃 符合大于5的值
for i in itertools.filterfalse(lambda x: x > 5, range(10)):
    print("filterfalse", "输出", i)
1
2
3
4
5

运行结果

filterfalse 输出 0
filterfalse 输出 1
filterfalse 输出 2
filterfalse 输出 3
filterfalse 输出 4
filterfalse 输出 5
1
2
3
4
5
6

itertools.dropwhile(predicate, iterable, /)

返回丢弃 iterable 中传入 predicate 后结果为 True 的元素所剩下的部分值；

iterable：可迭代对象

predicate：用于过滤计算的函数；

示例

import itertools

# 丢弃 符合大于5的值
for i in itertools.dropwhile(lambda x: x > 5, [8, 6, 4, 2]):
    print("dropwhile", "输出", i)
1
2
3
4
5

运行结果

dropwhile 输出 4
dropwhile 输出 2
1
2

itertools.takewhile(predicate, iterable, /)

返回 iterable 中传入 predicate 后结果为 True 的元素，直到结果为 False；

iterable：可迭代对象

predicate：用于过滤计算的函数；

示例

import itertools

# 返回大于5 的值
for i in itertools.takewhile(lambda x: x > 5, [8, 6, 4, 2]):
    print("takewhile", "输出", i)
1
2
3
4
5

运行结果

takewhile 输出 8
takewhile 输出 6
1
2

itertools.starmap(function, iterable, /)

返回 iterable 中传入 function 后计算出的结果；

iterable：可迭代对象

function：用于计算结果的函数；

示例

import itertools

li = [(2, 3), (3, 1), (4, 6), (5, 3), (6, 5), (7, 2)]

for i in itertools.starmap(lambda x, y: x + y, li):
    print("starmap", "输出", i)
1
2
3
4
5
6

运行结果

starmap 输出 5
starmap 输出 4
starmap 输出 10
starmap 输出 8
starmap 输出 11
starmap 输出 9
1
2
3
4
5
6

itertools.islice(iterable, start, stop[, step])

返回迭代器的切片，可以选择两种参数传递方式，itertools.islice (iterable, stop)；

iterable: 可迭代对象；

start：切片开始位置；

stop：切片结束位置；

step：切片获取值时跳过的步长；

示例

import itertools

# 不指定步长
for i in itertools.islice(range(20), 6):
    print("不指定步长", "输出", i)
# 指定步长
for i in itertools.islice(range(20), 0, 6, 3):
    print("指定步长", "输出", i)
1
2
3
4
5
6
7
8

运行结果

不指定步长 输出 0
不指定步长 输出 1
不指定步长 输出 2
不指定步长 输出 3
不指定步长 输出 4
不指定步长 输出 5
指定步长 输出 0
指定步长 输出 3
1
2
3
4
5
6
7
8