【python基础】python内置函数 zip用法介绍

zip() 是 Python 中非常有用的内建函数，能够将多个可迭代对象（如列表、元组、字符串等）打包成一个迭代器，它将对应位置的元素组合成元组，并返回一个由这些元组组成的迭代器。通常用于并行处理多个可迭代对象。

1. 基本用法

zip() 可以将两个或多个可迭代对象的元素“打包”成一个个元组，返回一个新的迭代器。

# 示例1：将两个列表打包成元组
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
zipped = zip(list1, list2)

# 转换为列表查看结果
print(list(zipped))  # 输出: [(1, 'a'), (2, 'b'), (3, 'c')]

2. 多个可迭代对象

zip() 可以接受多个可迭代对象，它会按位置依次打包这些可迭代对象中的元素。

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
list3 = ['A', 'B', 'C']
zipped = zip(list1, list2, list3)

print(list(zipped))  # 输出: [(1, 'a', 'A'), (2, 'b', 'B'), (3, 'c', 'C')]

3. 处理不同长度的可迭代对象

如果传递给 zip() 的可迭代对象长度不同，zip() 会使用最短的可迭代对象的长度来进行配对，忽略多余的元素。

list1 = [1, 2, 3, 4]
list2 = ['a', 'b']
zipped = zip(list1, list2)

print(list(zipped))  # 输出: [(1, 'a'), (2, 'b')]

4. 解压（unzip）操作

zip() 不仅可以用于打包，还可以通过使用 * 操作符将打包的数据解压为原始的可迭代对象。这是通过 zip(*iterable) 完成的。

# 使用 zip 打包
zipped = [(1, 'a'), (2, 'b'), (3, 'c')]

# 使用 * 进行解压
unzipped = zip(*zipped)

# 转换为列表查看结果
unzipped_list = list(unzipped)
print(unzipped_list)  # 输出: [(1, 2, 3), ('a', 'b', 'c')]

解压后的结果是两个元组：一个包含所有第一个元素，另一个包含所有第二个元素。

5. 结合 zip() 和 dict() 创建字典

zip() 可以用来将两个列表（一个作为键，另一个作为值）结合成一个字典。

keys = ['name', 'age', 'city']
values = ['Alice', 25, 'New York']

# 使用 zip 和 dict 创建字典
result = dict(zip(keys, values))
print(result)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}

6. zip() 与 for 循环

zip() 在 for 循环中非常有用，可以让你同时遍历多个可迭代对象。

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']

for number, letter in zip(list1, list2):
    print(f"Number: {number}, Letter: {letter}")
# 输出:
# Number: 1, Letter: a
# Number: 2, Letter: b
# Number: 3, Letter: c

7. zip() 与 enumerate() 结合使用

zip() 和 enumerate() 可以结合使用，enumerate() 会为每个元素提供一个索引。

list1 = ['apple', 'banana', 'cherry']
list2 = ['red', 'yellow', 'pink']

for index, (fruit, color) in enumerate(zip(list1, list2)):
    print(f"Index: {index}, Fruit: {fruit}, Color: {color}")
# 输出:
# Index: 0, Fruit: apple, Color: red
# Index: 1, Fruit: banana, Color: yellow
# Index: 2, Fruit: cherry, Color: pink

8. zip() 用于矩阵转置

zip() 很适合用来转置矩阵，它可以把行转换为列，列转换为行。

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 转置矩阵
transposed = list(zip(*matrix))
print(transposed)
# 输出:
# [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

9. zip_longest 处理不等长的可迭代对象

zip() 默认会按最短的可迭代对象来配对元素。如果需要填充空缺，可以使用 itertools.zip_longest()，它会为较短的可迭代对象使用指定的填充值。

from itertools import zip_longest

list1 = [1, 2, 3, 4]
list2 = ['a', 'b']

# 使用 zip_longest 填充空缺
zipped = zip_longest(list1, list2, fillvalue='N/A')
print(list(zipped))  # 输出: [(1, 'a'), (2, 'b'), (3, 'N/A'), (4, 'N/A')]

10. 总结

• zip() 可以将多个可迭代对象按元素位置打包成元组，返回一个新的迭代器。
• 当可迭代对象长度不一致时，zip() 只会遍历最短的可迭代对象。
• 可以使用 * 解压 zip 打包的数据。
• zip() 常用于创建字典、并行迭代、矩阵转置等场景。

如果你在实际编程中遇到其他关于 zip() 的问题，或者有其他的 Python 相关问题，随时可以继续询问！