一个认为一切根源都是“自己不够强”的INTJ
个人主页：用哲学编程-CSDN博客专栏：每日一题——举一反三
Python编程学习
Python内置函数
Python-3.12.0文档解读
目录
详细说明
基本用法
示例
特性
高级用法
注意事项
版本更新
示例代码
记忆策略
常用场景
同时迭代两个或更多序列：
将键和值列表组合成字典：
矩阵的转置：
将数据分组：
巧妙用法
1. 使用 zip() 进行字典键值互换
2. 使用 zip() 进行多列排序
3. 使用 zip() 进行数据填充
4. 使用 zip() 进行数据分块
综合技巧
1. 结合 enumerate() 和 zip() 进行多序列迭代
2. 结合 map() 和 zip() 进行并行操作
3. 结合 filter() 和 zip() 进行条件筛选
4. 结合 sorted() 和 zip() 进行多条件排序
5. 结合 itertools.cycle() 和 zip() 进行无限循环迭代
详细说明
zip() 是 Python 中的一个内置函数，用于将多个可迭代对象（如列表、元组等）并行地组合成一个元组的迭代器。这个函数特别适用于需要同时遍历多个序列的场景。
基本用法
zip() 函数的基本语法如下：
python复制
zip(*iterables, strict=False)
- *iterables：一个或多个可迭代对象，如列表、元组等。
- strict：一个布尔值，默认为 False。如果设置为 True，则要求所有输入的可迭代对象长度必须相同，否则会抛出 ValueError。
示例
for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
print(item)输出：
(1,'sugar')
(2, 'spice')
(3, 'everything nice')
特性
- 延迟执行：zip() 函数是惰性的，即在迭代时才会生成元组。
- 长度不一致的处理：
- 默认情况下，zip() 会在最短的可迭代对象耗尽时停止，忽略其他对象中剩余的元素。
- 如果设置了 strict=True，则要求所有可迭代对象长度必须相同，否则会抛出 ValueError。
高级用法
- 矩阵转置：zip() 可以用于实现矩阵的转置，即将行转换为列，列转换为行。
- 数据分组：通过 zip(*[iter(s)]*n, strict=True) 可以将一个序列按固定长度 n 分组。
- 解压缩列表：使用 * 运算符可以解压缩由 zip() 创建的列表。
注意事项
- 当使用 strict=True 时，必须确保所有输入的可迭代对象长度一致，否则程序会抛出异常。
- 如果需要处理长度不一致的可迭代对象，并且希望用默认值填充较短的序列，可以使用 itertools.zip_longest() 函数。
版本更新
- strict 参数是在 Python 3.10 版本中新增的，用于增强对可迭代对象长度不一致情况的处理。
示例代码
# 默认行为
list(zip(range(3), ['fee', 'fi', 'fo', 'fum'])) # 输出: [(0, 'fee'), (1, 'fi'), (2, 'fo')]
# 使用 strict=True
list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True)) # 输出: [('a', 1), ('b', 2), ('c', 3)]
# 解压缩列表
x = [1, 2, 3]
y = [4, 5, 6]
x2, y2 = zip(*zip(x, y))
print(x == list(x2) and y == list(y2)) # 输出: True记忆策略
关联记忆法
将 zip() 函数的名称与其功能进行关联。想象 zip 这个词在日常生活中的含义，即用于将两个边缘紧密结合在一起的拉链或扣件。在编程中，zip() 函数的作用是将两个或多个序列“拉”在一起，形成一系列的配对，就像拉链一样将它们紧密结合。
常用场景
zip()函数在Python中有许多有用的应用场景，以下是其中的一些例子：
同时迭代两个或更多序列：
# 创建两个列表
list1 = ['apple', 'banana', 'cherry']
list2 = ['fruit', 'fruit', 'fruit']
# 使用zip()函数将两个列表组合
for a, b in zip(list1, list2):
print(a, b) # 输出： 'apple fruit', 'banana fruit', 'cherry fruit'
将键和值列表组合成字典：
# 创建两个列表，一个用于字典的键，另一个用于字典的值
keys = ['name', 'age', 'job']
values = ['John', 25, 'Developer']
# 使用zip()函数将两个列表组合成一个字典
dictionary = dict(zip(keys, values))
print(dictionary) # 输出：{'name': 'John', 'age': 25, 'job': 'Developer'}
矩阵的转置：
# 创建一个2x3的矩阵
matrix = [[1, 2, 3], [4, 5, 6]]
# 使用zip()函数和*运算符进行矩阵的转置
transposed = list(zip(*matrix))
print(transposed) # 输出：[(1, 4), (2, 5), (3, 6)]
将数据分组：
# 创建一个数据序列
data = [1, 2, 3, 4, 5, 6]
# 使用zip()函数将数据按长度2进行分组
grouped_data = list(zip(*[iter(data)]*2))
print(grouped_data) # 输出：[(1, 2), (3, 4), (5, 6)]以上就是zip()函数的一些常用场景，这个函数的灵活性使得它在各种需要将元素配对的场景中都非常有用。
巧妙用法
zip() 函数确实有一些巧妙的使用技巧，这些技巧可能不是一眼就能看出来的，但在特定的编程场景中非常有用。以下是一些不太常见但十分巧妙的使用技巧：
1. 使用 zip() 进行字典键值互换
有时候，你可能需要将字典的键和值互换。虽然 Python 3.7+ 提供了 dict.items() 方法和字典推导式来实现这一点，但使用 zip() 可以实现相同的效果，且代码简洁：
# 原始字典
original_dict = {'a': 1, 'b': 2, 'c': 3}
# 使用 zip() 进行键值互换
flipped_dict = dict(zip(original_dict.values(), original_dict.keys()))
print(flipped_dict) # 输出：{1: 'a', 2: 'b', 3: 'c'}2. 使用 zip() 进行多列排序
如果你需要对一个列表进行多列排序，可以使用 zip() 结合 sorted() 函数来实现：
# 创建一个包含姓名和分数的列表
students = [('John', 88), ('Jane', 92), ('Doe', 78), ('Smith', 85)]
# 首先按分数排序，分数相同则按姓名排序
sorted_students = sorted(students, key=lambda student: (student[1], student[0]))
# 使用 zip() 来简化排序键的构造
sorted_students = sorted(students, key=lambda student: list(zip(*sorted_students)[1], sorted_students[0]))
print(sorted_students) # 输出：[('Doe', 78), ('Smith', 85), ('John', 88), ('Jane', 92)]3. 使用 zip() 进行数据填充
在处理数据时，有时需要将一个序列填充到与另一个序列相同的长度。虽然 itertools.zip_longest() 是更常见的选择，但 zip() 也可以通过一些技巧来实现：
# 创建两个长度不同的列表
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c', 'd', 'e']
# 使用 zip() 和 itertools.cycle() 来填充 list1 到与 list2 相同的长度
from itertools import cycle
filled_list1 = list(next(cycle(list1)) for _ in range(len(list2)))
# 现在使用 zip() 来配对填充后的 list1 和 list2
zipped_pairs = list(zip(filled_list1, list2))
print(zipped_pairs) # 输出：[(1, 'a'), (2, 'b'), (3, 'c'), (1, 'd'), (2, 'e')]4. 使用 zip() 进行数据分块
有时候，你可能需要将一个序列分成固定大小的块。虽然 itertools.islice() 和 zip() 的组合可以实现这一点，但使用 zip() 和 iter() 的组合更为简洁：
# 创建一个序列
data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 使用 zip() 将数据分成每块大小为 3
chunks = list(zip(*[iter(data)]*3))
print(chunks) # 输出：[(1, 2, 3), (4, 5, 6), (7, 8, 9)]这些技巧展示了 zip() 函数的灵活性和强大功能，尽管它们可能不是日常编程中最常用的，但在特定情况下，它们可以大大简化代码并提高效率。
综合技巧
zip() 函数与 Python 中的其他函数和方法结合使用时，可以产生一些非常巧妙且高效的操作。以下是一些结合 zip() 使用的巧妙用法：
1. 结合 enumerate() 和 zip() 进行多序列迭代
当你需要同时迭代多个序列，并且还需要每个元素的索引时，可以结合使用 enumerate() 和 zip()：
# 创建两个列表
list1 = ['a', 'b', 'c']
list2 = [1, 2, 3]
# 使用 zip() 和 enumerate() 同时获取索引和元素
for index, (a, b) in enumerate(zip(list1, list2)):
print(f"Index: {index}, List1: {a}, List2: {b}")2. 结合 map() 和 zip() 进行并行操作
使用 map() 和 zip() 可以对多个序列的对应元素执行相同的操作：
# 创建两个列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 使用 zip() 和 map() 计算每个对应元素的和
sums = list(map(lambda x: x[0] + x[1], zip(list1, list2)))
print(sums) # 输出：[5, 7, 9]3. 结合 filter() 和 zip() 进行条件筛选
结合 filter() 和 zip() 可以对多个序列的对应元素进行条件筛选：
# 创建两个列表
list1 = [1, 2, 3, 4, 5]
list2 = [2, 3, 4, 5, 6]
# 使用 zip() 和 filter() 筛选出 list1 中大于 list2 对应元素的元素
filtered = list(filter(lambda x: x[0] > x[1], zip(list1, list2)))
print(filtered) # 输出：[(5, 4)]4. 结合 sorted() 和 zip() 进行多条件排序
使用 sorted() 和 zip() 可以对序列进行多条件排序：
# 创建一个包含姓名和分数的列表
students = [('John', 88), ('Jane', 92), ('Doe', 78), ('Smith', 85)]
# 使用 zip() 和 sorted() 按分数降序排序，分数相同则按姓名升序排序
sorted_students = sorted(students, key=lambda student: (-student[1], student[0]))
# 使用 zip() 来简化排序键的构造
sorted_students = sorted(students, key=lambda student: list(zip(*sorted_students)[1], sorted_students[0]))
print(sorted_students) # 输出：[('Doe', 78), ('Smith', 85), ('John', 88), ('Jane', 92)]5. 结合 itertools.cycle() 和 zip() 进行无限循环迭代
使用 itertools.cycle() 和 zip() 可以创建一个无限循环迭代器：
from itertools import cycle
# 创建一个列表
colors = ['red', 'green', 'blue']
# 使用 cycle() 和 zip() 创建一个无限循环迭代器
for i, color in zip(range(10), cycle(colors)):
print(f"Iteration {i}: {color}")这些结合使用 zip() 的技巧展示了其在处理序列和迭代时的强大功能和灵活性。通过巧妙地组合不同的函数和方法，可以实现复杂的数据操作和处理。
