【python】zip()函数介绍

一、说明

zip 是 Python 中一个非常实用的内置函数，用于将可迭代的对象（如列表、元组、字典等）作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象（注意，返回的其实是一个迭代器）。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

二、zip 函数的基本用法

示例 1：两个列表

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

# 输出：这是一个迭代器，所以直接打印看到的是它的内存地址
# 要查看其内容，可以将其转换为列表
print(list(zipped))  # 输出：[(1, 'a'), (2, 'b'), (3, 'c')]

示例 2：三个列表

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
list3 = [True, False, True]
zipped = zip(list1, list2, list3)

print(list(zipped))  # 输出：[(1, 'a', True), (2, 'b', False), (3, 'c', True)]

示例 3：长度不等的列表

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

print(list(zipped))  # 输出：[(1, 'a'), (2, 'b'), (3, 'c')]
# 注意，只有最短的列表的长度个元素被打包

示例 4：解压缩（使用 *）

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

# 注意：zip(*) 返回的是元组的迭代器，需要再次使用 list() 转换
print(list(list1))  # 输出：[1, 2, 3]
print(list(list2))  # 输出：['a', 'b', 'c']

示例 5：与字典一起使用（注意，字典会被视为键的列表）

dict1 = {'a': 1, 'b': 2, 'c': 3}
list2 = [10, 20, 30]
zipped = zip(dict1, list2)

# 注意，这里 zip 会将字典的键作为可迭代对象
print(list(zipped))  # 输出：[('a', 10), ('b', 20), ('c', 30)]

如果使用字典的值进行 zip，需要先获取字典的值，如 zip(dict1.values(), list2)。

敲黑板
在 Python 中，zip 函数返回的其实是一个迭代器（iterator），而不是一个列表（list）。迭代器是一个可以记住遍历的位置的对象，它允许一次访问一个元素，直到所有的元素被访问完结束。迭代器不会一次性在内存中生成所有元素，而是按需生成，这对于处理大数据集或者无限数据流时非常有用，因为它能节省内存空间。

然而，有时候我们需要查看 zip函数产生的所有结果，或者需要多次遍历这些结果。为了能够在需要时多次访问 zip的结果，或者为了将结果以更直观的方式（如列表）展示出来，我们通常会将迭代器转换为列表。通过将迭代器传递给 list()函数，我们可以立即获取并存储迭代器中的所有元素。

三、实际场景中的应用示例

1. 同时遍历两个或多个列表

需要同时遍历两个或多个列表（或其他可迭代对象），并对它们中的元素执行操作时，zip 函数非常有用。例如，有两个列表，一个包含学生的名字，另一个包含他们的分数，想要将它们配对并打印出来。

names = ['Alice', 'Bob', 'Charlie']
scores = [85, 92, 78]

for name, score in zip(names, scores):
    print(f'{name} scored {score}')

2. 合并字典

虽然直接合并字典时不会使用 zip（因为字典是无序的），但如果有两个字典的键是对应的，并且想要将它们合并成一个新的字典，其中键是相同的，值是一个元组，那么 zip 就可以派上用场。

dict1 = {'a': 1, 'b': 2}
dict2 = {'a': 'A', 'b': 'B'}

combined = {k: (v1, v2) for k, (v1, v2) in zip(dict1, dict2.values())}
# 注意：这里假设两个字典的键是相同的，并且顺序也是相同的
# 在实际应用中，你可能需要先检查这一点

print(combined)  # 输出：{'a': (1, 'A'), 'b': (2, 'B')}

3. 处理来自不同来源的数据

在数据处理和分析中，经常需要从不同的来源获取数据，并将它们组合在一起。zip 可以轻松地将这些数据配对。
假设有一个 CSV 文件，其中包含用户 ID 和用户名，而另一个 JSON 文件包含用户 ID 和电子邮件。你想将这两个数据集结合起来以获取每个用户的完整信息。

# 假设这是从 CSV 文件中读取的用户 ID 和用户名  
user_ids_csv = [1, 2, 3]  
usernames_csv = ['Alice', 'Bob', 'Charlie']  
  
# 假设这是从 JSON 文件中读取的用户 ID 和电子邮件  
user_ids_json = [1, 2, 4]  # 注意这里 ID 4 没有在 CSV 中  
emails_json = ['alice@example.com', 'bob@example.com', 'dave@example.com']  
  
# 使用 zip 结合两个列表（但需要注意长度可能不同）  
combined = [(id_csv, username_csv, email_json)   
            for id_csv, username_csv, email_json in zip(user_ids_csv, usernames_csv, emails_json)   
            if id_csv in user_ids_json]  # 确保 ID 在两个列表中都有  
  
# 打印结果  
for item in combined:  
    print(f'ID: {item[0]}, Username: {item[1]}, Email: {item[2]}')  
  
# 注意：ID 4 没有在 CSV 中，所以不会出现在结果中

4. 创建字典

当有两个列表，一个包含键，另一个包含值时，你可以使用 zip 和字典推导式来快速创建一个字典。

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

dict_from_lists = dict(zip(keys, values))
print(dict_from_lists)  # 输出：{'name': 'Alice', 'age': 30, 'city': 'New York'}

5. 排序和比较

在某些情况下，可能需要基于一个列表的排序顺序来对另一个列表进行排序。虽然 zip 本身不直接用于排序，但可以通过将它与排序函数（如 sorted）结合使用来实现这一目的。
假设有两个列表，一个包含名字，另一个包含分数，想根据分数对名字进行排序。

names = ['Alice', 'Bob', 'Charlie']  
scores = [85, 92, 78]  
  
# 使用 zip 将名字和分数组合成一个元组的列表  
name_score_pairs = list(zip(names, scores))  
  
# 根据分数（元组的第二个元素）进行排序  
sorted_pairs = sorted(name_score_pairs, key=lambda x: x[1], reverse=True)  
  
# 解包排序后的列表以获取排序后的名字和分数  
sorted_names, sorted_scores = zip(*sorted_pairs)  
  
# 打印结果  
for name, score in zip(sorted_names, sorted_scores):  
    print(f'{name} scored {score}')

6. 填充缺失值或创建平行数据结构

在处理数据时，有时某些数据可能缺失。可以使用 zip 和其他工具（如列表推导式和默认值）来创建平行数据结构，其中缺失的值被填充为默认值。
假设有两个列表，一个包含名字，另一个包含分数，但分数列表可能缺少某些值。想用默认值（比如 0）来填充缺失的分数。

names = ['Alice', 'Bob', 'Charlie', 'Dave']  
scores = [85, 92, None]  # Charlie 的分数缺失  
  
# 使用 zip_longest（来自 itertools 模块）和 fillvalue 参数来填充缺失值  
from itertools import zip_longest  
  
filled_scores = [score if score is not None else 0 for score in zip_longest(scores, [], fillvalue=0)]  
  
# 将名字和填充后的分数组合在一起  
combined = list(zip(names, filled_scores))  
  
# 打印结果  
for name, score in combined:  
    print(f'{name} scored {score}')

请注意，在第六个示例中，使用了 itertools.zip_longest 而不是 zip，因为 zip 在输入迭代器长度不同时会截断到最短的长度。而 zip_longest 会填充缺失值以匹配最长的输入迭代器。