对话实录

小白：（苦恼）我有两个列表，一个存名字，一个存年龄，想把它们对应起来，好麻烦啊！

专家：（掏出魔法棒）用zip函数，一键搞定数据配对难题！

zip函数基础直击

1 zip类接收2个参数

• iterables：接受一个或多个可迭代对象，如列表、元组、字符串、字典的键或值（通过keys(), values(), items()等方法获取),range对象等。
• strict=False（该参数是python3.10版本增加）：默认为False，表示当迭代对象的length不同时，zip默认使用最小length组成元组，不会报错。否则传入True时会报某对象的length不一致的错误。

2 zip对象处理逻辑示意图

3. 简单配对

zip函数能将多个可迭代对象（如列表、元组）按元素位置配对，返回一个可迭代的zip对象。

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
pairs = zip(names, ages) #返回zip对象
print(list(pairs)) # 转换为列表查看结果
# 输出：[('Alice', 25), ('Bob', 30), ('Charlie', 35)]

这里，zip函数把names和ages中对应位置的元素组合在一起。

4. 多对象配对

它不仅能处理两个可迭代对象，多个也不在话下。

subjects = ['Math', 'Science', 'History']
grades = [85, 90, 78]
result = zip(names, ages, subjects, grades)
print(list(result))
# 输出：[('Alice', 25, 'Math', 85), ('Bob', 30, 'Science', 90), ('Charlie', 35, 'History', 78)]

多个列表通过zip函数，轻松实现多维度数据配对。

5 strict参数的作用

举例：定义两个不同长度的list，设置strict=True，zip对象执行会报错

list1 = ['name', 'age', 'color','height']
list2 = ['wang', '12', 'black']
new_iter = zip(list1,list2,strict=True)

执行后报ValueError的错误：

参数默认为False则不会报错，结果如下：

new_iter = zip(list1,list2)
print(list(new_iter))
[('name', 'wang'), ('age', '12'), ('color', 'black')]

常用功能及案例

案例 1：创建字典

利用zip函数，能快速将两个列表转换为字典。

keys = ['name', 'age', 'city']
values = ['Alice', 25, 'New York']
person = dict(zip(keys, values)) #dict函数将zip对象转为字典
print(person)
# 输出：{'name': 'Alice', 'age': 25, 'city': 'New York'}

这种方式在数据处理中，构建键值对字典时十分便捷。

案例 2：并行迭代

在循环中使用zip，可以对多个列表进行并行操作。

fruits = ['apple', 'banana', 'cherry']
prices = [1.5, 0.5, 2.0]
for fruit, price in zip(fruits, prices):
  print(f"{fruit} 的价格是 {price} 美元")

# 输出：
# apple 的价格是 1.5 美元
# banana 的价格是 0.5 美元
# cherry 的价格是 2.0 美元

大大简化了同时遍历多个相关列表的代码。

案例 3：矩阵转置

zip函数还能巧妙实现矩阵转置。

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed = list(map(list, zip(*matrix)))
print(transposed)
# 输出：[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

通过*运算符解包矩阵，再用zip和map函数完成转置。

闭坑指南

长度不一致问题

当参与zip的可迭代对象长度不同时，zip会在最短的可迭代对象耗尽时停止。

nums1 = [1, 2, 3]
nums2 = [4, 5, 6, 7]
result = list(zip(nums1, nums2))
print(result)
# 输出：[(1, 4), (2, 5), (3, 6)]

如果需要处理长度不同的情况，可以使用itertools.zip_longest。

from itertools import zip_longest
nums1 = [1, 2, 3]
nums2 = [4, 5, 6, 7]
result = list(zip_longest(nums1, nums2, fillvalue='N/A'))
#fillvalue可以不填，默认填充为None
print(result)
# 输出：[(1, 4), (2, 5), (3, 6), ('N/A', 7)]

zip对象的一次性

zip返回的对象是一次性的，遍历后就为空。

nums = [1, 2, 3]
letters = ['a', 'b', 'c']

zipped = zip(nums, letters)
first_result = list(zipped)
second_result = list(zipped)

print(first_result) # 有数据
# 输出：[(1, 'a'), (2, 'b'), (3, 'c')]
print(second_result) # 为空
# 输出：[]

如果需要多次使用，可将其转换为列表或元组保存。

嵌套结构的误解

对嵌套列表使用zip时，要注意其操作方式。

list1 = [[1, 2], [3, 4]]
list2 = [[5, 6], [7, 8]]

result = list(zip(list1, list2))
print(result)
# 输出：[([1, 2], [5, 6]), ([3, 4], [7, 8])]

它不会对嵌套列表内部元素逐一配对，若要实现内部元素配对，需进一步处理。

专家工具箱

1. 与enumerate结合

zip和enumerate搭配，可在遍历多个列表时获取索引。

colors = ['red', 'green', 'blue']
sizes = ['small', 'medium', 'large']
for index, (color, size) in enumerate(zip(colors, sizes), start=1):
  print(f"第 {index} 组：颜色 {color}，尺寸 {size}")

# 输出：
# 第 1 组：颜色 red，尺寸 small
# 第 2 组：颜色 green，尺寸 medium
# 第 3 组：颜色 blue，尺寸 large

2. 利用*解包

*运算符与zip配合，能实现数据的解压。

pairs = [(1, 'a'), (2, 'b'), (3, 'c')]
nums, letters = zip(*pairs)
print(nums)
# 输出：(1, 2, 3)
print(letters)
# 输出：('a', 'b', 'c')

3. 结合lambda函数

在zip的基础上，使用lambda函数可对配对后的数据进行处理。

nums1 = [1, 2, 3]
nums2 = [4, 5, 6]
result = list(map(lambda x: x[0] * x[1], zip(nums1, nums2)))
print(result)
# 输出：[4, 10, 18]

这里通过lambda函数将配对后的两个数字相乘。

小白：（恍然大悟）原来zip函数这么强大又好用！

专家：（微笑）记住：掌握zip函数，数据配对与处理将变得高效又轻松！

常用操作速查表