python模块百科_为高效而生_itertools【四】（完结）

一、itertools — 为高效而生

---

itertools — 为高效而生。itertools模块实现一系列迭代器 ，这些迭代器受到APL，Haskell、SML几种语言的启发。

itertools模块标准化了一个快速、高效利用内存的核心工具集，这些工具本身或组合都很有用。它们一起形成了“迭代器代数”，这使得在纯Python中有可能创建简洁又高效的专用工具。

例如，SML有一个制表工具： tabulate(f)，它可产生一个序列 f(0), f(1), ...。在Python中可以组合 map() 和 count() 实现： map(f, count())。

这些工具及其内置对应物也能很好地配合 operator 模块中的快速函数来使用。 例如，乘法运算符可以被映射到两个向量之间执行高效的点积: sum(starmap(operator.mul, zip(vec1, vec2, strict=True)))。

二、无穷迭代器

迭代器	实参	结果	示例
count()	[start[, step]]	start, start+step, start+2step, …	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-

3.6 zip_longest()

itertools.zip_longest() 用于将多个可迭代对象（如列表、元组等）的元素逐一配对，并返回一个迭代器。如果可迭代对象的长度不同，则该函数会将更长的对象“填充”到较短的对象的长度。填充值可以是任何提供的值或默认值，具体取决于调用时是否提供了额外的参数。

函数的基本语法如下：

itertools.zip_longest(*iterables[, fillvalue])

• *iterables：要配对的可迭代对象。
• fillvalue（可选）：当可迭代对象的长度不一致时，用作填充值的值。如果没有提供，则使用 None。

返回值：返回一个迭代器，其中包含配对的元组。

示例1： 等长列表配对

import itertools

a = [1, 2, 3]
b = ['a', 'b', 'c']
result = list(itertools.zip_longest(a, b))
print(result)

# 执行结果
[(1, 'a'), (2, 'b'), (3, 'c')]

示例2： 填充默认值

import itertools

a = [1, 2, 3]
b = ['a', 'b']
result = list(itertools.zip_longest(a, b, fillvalue='default'))
print(result)  

# 执行结果
[(1, 'a'), (2, 'b'), (3, 'default')]

示例3： 不同长度列表，不设默认值

import itertools

a = [1, 2, 3]
b = ['a', 'b', 'c', 'd']
result = list(itertools.zip_longest(a, b))
print(result)

# 执行结果
[(1, 'a'), (2, 'b'), (3, 'c'), (None, 'd')]

四、排列组合迭代器：

迭代器	实参	结果
product()	p, q, … [repeat=1]	笛卡尔积，相当于嵌套的for循环
permutations()	p[, r]	长度r元组，所有可能的排列，无重复元素
combinations()	p, r	长度r元组，有序，无重复元素
combinations_with_replacement()	p, r	长度r元组，有序，元素可重复

例子	结果
product('ABCD', repeat=2)	AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
permutations('ABCD', 2)	AB AC AD BA BC BD CA CB CD DA DB DC
combinations('ABCD', 2)	AB AC AD BC BD CD
combinations_with_replacement('ABCD', 2)	AA AB AC AD BB BC BD CC CD DD

4.1 product()

itertools.product() 用于生成多个可迭代对象的笛卡尔积。这意味着它将为给定的每个可迭代对象生成一个笛卡尔积，并返回一个迭代器。

函数的基本语法如下：

itertools.product(*iterables)

• *iterables：要计算笛卡尔积的可迭代对象。

返回值：返回一个迭代器，其中包含笛卡尔积的元组。

示例1： 等长列表的笛卡尔积

import itertools

a = [1, 2, 3]
b = ['a', 'b', 'c']
result = list(itertools.product(a, b))
print(result)

# 执行结果
[(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b'), (2, 'c'), (3, 'a'), (3, 'b'), (3, 'c')]

示例2： 任意长度电话号码的对应字符组合【LeetCode热题】

import itertools

def letterCombinations(digits):
    if not digits:
        return []
    phoneMap = {
        '2': 'abc', '3': 'def', '4': 'ghi',
        '5': 'jkl', '6': 'mno', '7': 'pqrs',
        '8': 'tuv', '9': 'wxyz',
    }
    groups = (phoneMap[digit] for digit in digits)
    return [''.join(combination) for combination in itertools.product(*groups)]
result = letterCombinations('34')
print(result)

# 执行结果
['dg', 'dh', 'di', 'eg', 'eh', 'ei', 'fg', 'fh', 'fi']

示例3： 额外的参数，改变输出集格式

import itertools

a = [1, 2]
b = ['a', 'b', 'c']
result = list(itertools.product(a, b, repeat=2))  # repeat 参数指定每个元素的重复次数
for aiteritem in result:
    print(aiteritem)

# 执行结果
(1, 'a', 1, 'a')
(1, 'a', 1, 'b')
(1, 'a', 1, 'c')
(1, 'a', 2, 'a')
(1, 'a', 2, 'b')
(1, 'a', 2, 'c')
(1, 'b', 1, 'a')
(1, 'b', 1, 'b')
(1, 'b', 1, 'c')
(1, 'b', 2, 'a')
(1, 'b', 2, 'b')
(1, 'b', 2, 'c')
(1, 'c', 1, 'a')
(1, 'c', 1, 'b')
(1, 'c', 1, 'c')
(1, 'c', 2, 'a')
(1, 'c', 2, 'b')
(1, 'c', 2, 'c')
......
(2, 'c', 2, 'a')
(2, 'c', 2, 'b')
(2, 'c', 2, 'c')

4.2 permutations()

itertools.permutations() 用于生成可迭代对象的所有可能排列。

函数的基本语法如下：

itertools.permutations(iterable, r)

• iterable：要排列的可迭代对象。
• r（可选）：生成的排列的长度。如果省略，则将返回原始可迭代对象的所有排列。

返回值：返回一个迭代器，其中包含所有可能的排列。

示例1： 列表的全集排列

import itertools

a = [1, 2, 3]
result = list(itertools.permutations(a))
print(result)

# 执行结果
[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

示例2： 列表的定长排列

import itertools

a = [1, 2, 3]
result = list(itertools.permutations(a,2))
print(result)

# 执行结果
[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

4.3 combinations()

itertools.combinations() 用于生成可迭代对象的所有可能组合。

函数的基本语法如下：

itertools.combinations(iterable, r)

• iterable：要组合的可迭代对象。
• r：生成的组合的长度。

返回值：返回一个迭代器，其中包含所有可能的组合。

示例1： 列表的定长组合

import itertools

a = [1, 2, 3]
result = list(itertools.combinations(a, 2))
print(result)

# 执行结果
[(1, 2), (1, 3), (2, 3)]

示例2： 列表的全部子集

import itertools

def permute(nums):
    result = [[]]
    for iIdx in range(len(nums)):
        for perm in itertools.combinations(nums, iIdx+1):
            result += [list(perm)]
    return result
result = permute([1, 2, 3])
print(result)

# 执行结果
[[], [1], [2], [3], [1, 2], [1, 3], [2, 3], [1, 2, 3]]

4.4 combinations_with_replacement()

itertools.combinations_with_replacement() 用于生成可迭代对象的所有可能组合，允许值重复。

函数的基本语法如下：

itertools.combinations_with_replacement(iterable, r)

• iterable：要组合的可迭代对象。
• r：生成的组合的长度。

返回值：返回一个迭代器，其中包含所有可能的组合。

示例1： 等长列表的全集组合

import itertools

a = [1, 2, 3]
result = list(itertools.combinations_with_replacement(a, 3))
print(result)

# 执行结果
[(1, 1, 1), (1, 1, 2), (1, 1, 3), (1, 2, 2), (1, 2, 3), (1, 3, 3), (2, 2, 2), (2, 2, 3), (2, 3, 3), (3, 3, 3)]

示例2： 等长列表的短组合

import itertools

a = [1, 2, 3]
result = list(itertools.combinations_with_replacement(a, 2))
print(result)

# 执行结果
[(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)]

示例3： 字符串的短组合

import itertools

s = 'abc'
result = list(itertools.combinations_with_replacement(s, 2))
print(result)

# 执行结果
[('a', 'a'), ('a', 'b'), ('a', 'c'), ('b', 'b'), ('b', 'c'), ('c', 'c')]

---

may the odds be ever in your favor ~