1、permutations

在 Python 中，itertools 模块提供了一个非常实用的函数 permutations，它能够生成一个可迭代对象中元素的所有排列。排列是指从给定的一组元素中，按照特定的顺序选择出一些元素的不同组合，顺序是关键。如果顺序不同，即使元素相同，它们的排列也被视为不同。

1.1、permutations 函数的基本使用

itertools.permutations(iterable, r=None) 函数有两个参数：

• iterable：需要排列的可迭代对象（如列表、元组、字符串等）。
• r：表示每个排列中要选择的元素个数，默认为 None，即排列整个可迭代对象的所有元素。如果指定了 r，则表示每个排列只包含 r 个元素。

1.2、返回值

permutations 返回一个迭代器，生成一个个的排列，每个排列以元组的形式返回，元组中的元素是从 iterable 中选出的元素，并且排列顺序不同。由于返回的是迭代器，可以通过迭代的方式逐一获取排列，也可以将结果转化为列表或其他数据结构。

1.3、示例说明

1. 排列一个列表的所有元素

如果不指定 r，则生成 iterable 中所有元素的排列：

from itertools import permutations

items = [1, 2, 3]
result = permutations(items)

for perm in result:
    print(perm)

输出：

(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)

在这个例子中，permutations 返回了所有 items 列表元素的排列，共有 6 种排列方式。

2. 只排列部分元素

通过指定参数 r，可以生成包含 r 个元素的所有排列。例如，若只需要从 3 个元素中选择 2 个元素的排列，可以这样做：

from itertools import permutations

items = [1, 2, 3]
result = permutations(items, 2)

for perm in result:
    print(perm)

输出：

(1, 2)
(1, 3)
(2, 1)
(2, 3)
(3, 1)
(3, 2)

3. 排列字符串中的字符

permutations 不仅限于列表和数字，还可以处理字符串。例如，要生成字符串 "AB" 的所有排列：

from itertools import permutations

string = "AB"
result = permutations(string)

for perm in result:
    print(''.join(perm))

输出：

AB
BA

4. 实战

4.1.【问题描述】

给定四个字符串 a, b, c, d，请将这四个字符串按照任意顺序依次连接拼成一个字符串。 请问拼成的字符串字典序最小是多少？

4.2【输入格式】

输入四行，每行包含一个字符串。

4.3【输出格式】

输出一行包含一个字符串，表示答案。

4.4【样例输入】

LAN
LAN
QIAO
BEI

4.5【样例输出】

BEILANLANQIAO

4.6 【解答代码】

from itertools import permutations

a = 'LAN'
b = 'LAN'
c = 'QIAO'
d = 'BEI'

lst = [a, b, c, d]
print(min(''.join(i) for i in permutations(lst)))

---

2、product

itertools.product 是 Python 标准库 itertools 模块中的一个函数，它用于计算多个可迭代对象的笛卡尔积。笛卡尔积是指从多个集合中各取一个元素所组成的所有可能的有序对集合。

1. 计算两个列表的笛卡尔积

from itertools import product

# 定义两个列表
list1 = [1, 2]
list2 = ['a', 'b']

# 使用 product 函数计算笛卡尔积
result = product(list1, list2)

# 遍历结果并打印
for item in result:
    print(item)

在上述代码中，product(list1, list2) 会生成 list1 和 list2 的笛卡尔积。最终输出为：

(1, 'a')
(1, 'b')
(2, 'a')
(2, 'b')

2. 计算多个列表的笛卡尔积

from itertools import product

# 定义三个列表
list1 = [1, 2]
list2 = ['a', 'b']
list3 = [True, False]

# 使用 product 函数计算笛卡尔积
result = product(list1, list2, list3)

# 遍历结果并打印
for item in result:
    print(item)

这里 product(list1, list2, list3) 会生成这三个列表的笛卡尔积，输出结果会包含所有可能的组合。

3. 对单个可迭代对象进行多次重复计算笛卡尔积

from itertools import product

# 定义一个列表
list1 = [1, 2]

# 对 list1 进行 3 次重复计算笛卡尔积
result = product(list1, repeat=3)

# 遍历结果并打印
for item in result:
    print(item)

repeat 参数指定了对同一个可迭代对象重复计算笛卡尔积的次数。上述代码会生成 list1 重复 3 次的笛卡尔积，输出为所有可能的长度为 3 的元素组合。

4. 在实际问题中的应用

假设你要生成一个长度为 n 的由 0 和 1 组成的所有可能的序列，就可以使用 product 函数：

from itertools import product

n = 3
# 生成长度为 n 的 0 和 1 的所有可能组合
sequences = product([0, 1], repeat=n)

# 遍历结果并打印
for seq in sequences:
    print(seq)

这段代码会生成所有长度为 3 的由 0 和 1 组成的序列，如 (0, 0, 0)、(0, 0, 1) 等。

5. 实战

假设你正在开发一个密码生成器，用户会指定密码的长度范围、密码可能包含的字符集（如数字、小写字母、大写字母），然后程序会生成该长度范围内所有可能的密码组合。

from itertools import product

# 定义不同类型的字符集
digits = '0123456789'
lowercase_letters = 'abcdefghijklmnopqrstuvwxyz'
uppercase_letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

# 合并所有可能的字符集
all_characters = digits + lowercase_letters + uppercase_letters

def generate_passwords(min_length, max_length):
    all_passwords = []
    # 遍历指定的长度范围
    for length in range(min_length, max_length + 1):
        # 使用 product 函数生成该长度下的所有可能组合
        password_combinations = product(all_characters, repeat=length)
        # 将每个组合转换为字符串并添加到结果列表中
        for combination in password_combinations:
            password = ''.join(combination)
            all_passwords.append(password)
    return all_passwords

# 示例：生成长度在 2 到 3 之间的所有可能密码
min_length = 2
max_length = 3
passwords = generate_passwords(min_length, max_length)

# 打印前 10 个生成的密码（因为可能生成的密码数量非常大）
print("前 10 个生成的密码:")
for password in passwords[:10]:
    print(password)

print(f"总共生成了 {len(passwords)} 个密码。")

代码解释

1. 字符集定义：首先定义了数字、小写字母和大写字母这三种不同类型的字符集，然后将它们合并成一个包含所有可能字符的大字符集 all_characters。
2. generate_passwords 函数：该函数接受两个参数 min_length 和 max_length，表示密码的最小长度和最大长度。在函数内部，使用 for 循环遍历这个长度范围，对于每个长度，使用 product 函数生成该长度下所有可能的字符组合。接着将每个组合转换为字符串并添加到 all_passwords 列表中。
3. 生成示例密码：设置 min_length 为 2，max_length 为 3，调用 generate_passwords 函数生成所有可能的密码。
4. 结果输出：打印出前 10 个生成的密码，并输出总共生成的密码数量。

---

3、combinations

功能

从可迭代对象中生成所有 不重复且不考虑顺序 的组合。

itertools.combinations(iterable, r)

• iterable：输入的可迭代对象（如列表、元组、字符串）。
• r：要选择的元素个数。

返回值

一个生成器，按字典序逐个产出元组形式的组合。

2. 示例

from itertools import combinations

lst = [1, 2, 3]
for combo in combinations(lst, 2):
    print(combo)

输出：

(1, 2)
(1, 3)
(2, 3)

3. 关键特性

特性 1：不考虑顺序

组合中的元素顺序无关，例如 (1, 2) 和 (2, 1) 视为同一个组合。

特性 2：不包含重复元素

• 若输入包含重复元素，生成的组合会保留重复元素。例如：

  for combo in combinations([1, 1, 2], 2):
      print(combo)  # 输出 (1,1), (1,2), (1,2)
  

  若需去重，可将结果转换为集合：python

  unique_combos = set(combinations([1, 1, 2], 2))
  print(unique_combos)  # 输出 {(1, 1), (1, 2)}
  

特性 3：元素不可重复选取

同一元素不能在同一个组合中出现多次。例如，combinations([1,2,3], 2) 不会生成 (1,1)。

4. 应用场景

• 团队组建：从 10 人中选 3 人，不考虑顺序。
• 子集生成：生成所有大小为 k 的子集。
• 数据分析：计算不同元素的组合对结果的影响。

5. 与 permutations 的对比

函数	是否考虑顺序	是否包含重复元素组合	结果数量（以 [1,2,3] 选 2 个为例）	输出示例（元素 [1,2]，k=2）
combinations	否	否	3	(1,2)
permutations	是	是	6	(1,2), (2,1)

6. 扩展：生成所有可能的组合长度

若要生成从 1 到 n 的所有组合长度，可以嵌套循环：

from itertools import combinations

lst = [1, 2, 3]
for r in range(1, len(lst)+1):
    for combo in combinations(lst, r):
        print(combo)

输出：

(1,)
(2,)
(3,)
(1, 2)
(1, 3)
(2, 3)
(1, 2, 3)

如果需要更复杂的组合功能（如允许元素重复选取），可以使用 itertools.combinations_with_replacement。