目录

一、zip函数的常见应用场景

二、zip函数使用注意事项

三、如何用好zip函数？

1、zip函数：

1-1、Python：

1-2、VBA：

 2、推荐阅读：

个人主页：https://myelsa1024.blog.csdn.net/

一、zip函数的常见应用场景

        zip函数在Python中有许多实用的应用场景，尤其是在处理多个列表或可迭代对象时，它提供了一种简洁而强大的方式来组合这些对象的元素，其常见的应用场景有：

1、并行迭代：当你有两个或多个列表，并且你想同时迭代它们时，zip()函数非常有用。例如，你可能有两个列表，一个包含名字，另一个包含对应的年龄，你想同时处理这两个列表中的元素。

2、字典键值对解包：在Python 3中，zip()函数经常与`*`操作符一起使用，用于字典的键值对解包，这在你需要交换字典的键和值时特别有用。

3、处理不等长的迭代器：当使用zip()函数迭代多个不等长的迭代器时，输出将仅在最短的迭代器耗尽时结束，这可以用于处理具有缺失数据的情况。

4、创建字典：你可以使用zip()函数和dict()函数来创建一个字典，其中一个列表包含键，另一个列表包含值。

5、与其他函数结合使用：zip()函数可以与Python中的其他函数(如map()、filter()、sorted()等)结合使用，以执行更复杂的操作。

6、数据预处理和转换：在数据分析和机器学习项目中，zip()函数可以用于同时处理多个特征列(例如，缩放或归一化多个特征)。

7、文件操作：在处理多个相关文件(如具有相同索引的数据和标签文件)时，zip()函数可以帮助你将它们的内容配对起来。

8、生成器表达式：你可以将zip()函数与生成器表达式结合使用，以创建更复杂的迭代器，而无需在内存中存储所有结果。

9、代码简化：在需要同时迭代多个可迭代对象的情况下，使用zip()函数可以使代码更简洁、更易读。

二、zip函数使用注意事项

        在Python中使用zip()函数时，请注意以下事项：

1、返回迭代器：zip()函数返回的是一个迭代器，而不是一个列表，这意味着你只能遍历一次它的结果，除非你将其转换为列表、元组或其他可迭代对象。

2、不等长迭代器的处理：如果zip()函数中的可迭代对象长度不等，那么zip()函数将在最短的可迭代对象耗尽时停止，这可能会导致一些意料之外的行为，特别是当你期望所有迭代器的元素都被处理时。

3、与`*`运算符的结合使用：虽然zip()函数可以与`*`运算符结合使用来解包参数，但这通常不是zip()函数的常见用法，更常见的用法是使用`*`运算符与zip()函数的结果一起，将多个可迭代对象的元素作为单独的位置参数传递给函数。

4、修改元组内的值：由于zip()函数返回的是包含元组的迭代器或列表(如果你将其转换为列表)，而元组是不可变的，因此你不能直接修改元组内的值，如果你需要修改元素，可以考虑将元组转换为列表。

5、内存使用：虽然zip()函数本身不会消耗大量内存(因为它是一个迭代器)，但如果你将zip()函数的结果转换为列表，并且处理的数据集非常大，那么可能会消耗大量内存，在这种情况下，考虑使用其他方法来处理数据，如逐元素处理或使用生成器表达式。

6、Python版本差异：在Python 2中，zip()函数返回的是一个列表；但在Python 3中，它返回的是一个迭代器，这是Python 2和Python 3之间的一个重要区别，需要注意。

三、如何用好zip函数？

        zip()函数在Python中是一个非常有用的内置函数，它允许你将多个可迭代对象(如列表、元组、字符串等)的元素打包成一个个元组，然后返回由这些元组组成的对象。为了用好zip()函数，请遵循以下建议：

1、并行迭代：当你需要同时迭代多个可迭代对象时，zip()函数非常有用，它允许你同时处理这些对象的元素。

2、处理不等长可迭代对象：默认情况下，zip()函数会在最短的可迭代对象耗尽时停止，如果你想要处理不等长的迭代器，并且希望保持较长的迭代器中剩余的元素，可以使用itertools.zip_longest()(在Python 2中是itertools.izip_longest())。

3、解压(Unzip)：你可以使用zip(*...)来解压一个由元组组成的列表，或者任何形式的可迭代对象，只要它包含相同数量的元素。

4、与列表推导式结合使用：你可以将zip()与列表推导式结合使用，以创建新的数据结构或过滤数据。

5、作为字典的键和值：你可以使用zip()函数来创建一个字典，其中可迭代对象的元素作为键，另一个可迭代对象的元素作为值。

6、注意内存使用：当你处理大型数据集时，将zip()函数的结果转换为列表可能会消耗大量内存，在这种情况下，考虑使用迭代器直接处理数据，或者使用生成器表达式。

7、保持代码清晰：使用zip()函数时，确保你的代码易于阅读和理解，如果可能的话，为变量使用有意义的名称，并在必要时添加注释。

8、检查输入：在使用zip()函数之前，确保你的输入是可迭代的，并且长度是预期的，这有助于避免在运行时出现错误。

9、与map()函数结合使用：虽然zip()和map()在功能上有所不同，但你可以将它们结合使用来处理多个可迭代对象的元素。例如，你可以使用map()函数对每个元组应用一个函数。

1、zip函数：

1-1、Python：

# 1.函数：zip# 2.功能：# 2-1、无实参：用于创建空的迭代器# 2-2、有实参：用于将可迭代对象打包成元组# 3.语法：zip([*iterables, strict=False])# 4.参数：# 4-1、*iterables(可选)：一个位置参数，表示任意数量的可迭代对象，如列表、字典、元组、字符串等，zip()函数允许多个可迭代对象作为参数# 4-2、strict(可选)：迭代停止条件，默认为False,即作为迭代器对象的长度可以不一样；若设置为True，则要求所有的迭代器对象必须等长# 5.返回值：# 5-1、无实参：返回空的迭代器# 5-2、有实参：返回一个可迭代的zip对象，其内部元素为元组# 6.说明：# 6-1、如果未指定strict=True参数，所有导致可迭代对象长度不同的错误都会被抑制，这可能会在程序的其他地方表现为难以发现的错误# 7.示例：# 用dir()函数获取该函数内置的属性和方法print(dir(zip))# ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__',# '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__',# '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__']# 用help()函数获取该函数的文档信息help(zip)# 应用一：并行迭代# 示例1: 迭代两个列表list1 = [1, 2, 3]list2 = ['a', 'b', 'c']for item1, item2 in zip(list1, list2): print(f'{item1}, {item2}')# 1, a# 2, b# 3, c# 示例2: 迭代多个列表list1 = [1, 2, 3]list2 = ['a', 'b', 'c']list3 = ['one', 'two', 'three']for item1, item2, item3 in zip(list1, list2, list3): print(f'{item1}, {item2}, {item3}')# 1, a, one# 2, b, two# 3, c, three# 示例3: 列表长度不同时的处理from itertools import zip_longestlist1 = [1, 2, 3]list2 = ['a', 'b']for item1, item2 in zip_longest(list1, list2, fillvalue='-'): print(f'{item1}, {item2}')# 1, a# 2, b# 3, -# 示例4: 使用字典解压来并行迭代names = ['Myelsa', 'Bruce', 'Jimmy']ages = [18, 6, 15]for name, age in zip(names, ages): print(f'{name} is {age} years old.')# 或者使用字典解压for name, age in zip(names, ages): person = {'name': name, 'age': age} print(f'{person["name"]} is {person["age"]} years old.')# Myelsa is 18 years old.# Bruce is 6 years old.# Jimmy is 15 years old.# Myelsa is 18 years old.# Bruce is 6 years old.# Jimmy is 15 years old.# 应用二：字典键值对解包# 示例1: 迭代字典的键和值# 假设我们有一个字典d = {'a': 1, 'b': 2, 'c': 3}# 使用items()方法直接迭代键和值for key, value in d.items(): print(f'Key: {key}, Value: {value}')# 如果非要使用zip()，可以这样做(但通常不推荐)keys, values = zip(*d.items())for key, value in zip(keys, values): print(f'Key: {key}, Value: {value}')# 注意：上述zip()用法是不必要的，因为它没有提供任何额外的好处# 并且如果字典很大，它还会消耗额外的内存来存储keys和values元组# Key: a, Value: 1# Key: b, Value: 2# Key: c, Value: 3# Key: a, Value: 1# Key: b, Value: 2# Key: c, Value: 3# 示例2: 使用zip()将字典的键和值与其他可迭代对象组合# 原始字典的键keys = ['a', 'b', 'c']# 另一个列表的值values = [1, 2, 3]# 使用zip()将键和值组合成一个元组的迭代器key_value_pairs = zip(keys, values)# 将元组迭代器转换为字典new_dict = dict(key_value_pairs)print(new_dict)# {'a': 1, 'b': 2, 'c': 3}# 示例3: 解包字典的键和值到函数参数中def process_key_value(key, value): print(f'Processing key: {key}, value: {value}')# 字典d = {'a': 1, 'b': 2, 'c': 3}# 迭代字典的项并将它们作为参数传递给函数for key, value in d.items(): process_key_value(key, value)# Processing key: a, value: 1# Processing key: b, value: 2# Processing key: c, value: 3# 应用三：处理不等长的迭代器# 使用zip迭代这些列表（注意：不会处理不等长）from itertools import zip_longest# 定义不等长的迭代器list1 = [1, 2, 3]list2 = ['a', 'b']list3 = ['x', 'y', 'z', 'w']# 使用zip_longest迭代这些列表，并为较短的列表填充默认值(例如None)for item1, item2, item3 in zip_longest(list1, list2, list3, fillvalue='-'): print(f'{item1}, {item2}, {item3}')# 1, a, x# 2, b, y# 3, -, z# -, -, wfor item1, item2, item3 in zip(list1, list2, list3): print(f'{item1}, {item2}, {item3}')# 1, a, x# 2, b, y# 注意：'z'和'w'没有被打印出来，因为zip在最短的列表耗尽时停止了# 应用四：创建字典# 定义两个列表，一个作为键，一个作为值keys = ['a', 'b', 'c']values = [1, 2, 3]# 使用zip()将键和值组合成元组的迭代器key_value_pairs = zip(keys, values)# 将元组迭代器转换为字典dictionary = dict(key_value_pairs)# 打印创建的字典print(dictionary)# {'a': 1, 'b': 2, 'c': 3}# 应用五：与其他函数结合使用# 示例1: 与sorted()结合进行排序keys = ['c', 'a', 'b']values = [3, 1, 2]# 使用zip()将键和值组合成一个元组的列表，然后根据键进行排序sorted_items = sorted(zip(keys, values), key=lambda item: item[0])# 解包排序后的元组列表回两个单独的列表sorted_keys, sorted_values = zip(*sorted_items)# 如果需要列表而不是元组迭代器，可以转换为列表sorted_keys = list(sorted_keys)sorted_values = list(sorted_values)print(sorted_keys)print(sorted_values)# ['a', 'b', 'c']# [1, 2, 3]# 示例2: 与filter()结合进行过滤keys = ['a', 'b', 'a', 'c']values = [1, 2, 3, 4]# 使用filter()和lambda表达式过滤出键为'a'的元素对filtered_items = filter(lambda item: item[0] == 'a', zip(keys, values))# 将过滤后的迭代器转换为列表(如果需要)filtered_items_list = list(filtered_items)print(filtered_items_list)# [('a', 1), ('a', 3)]# 示例3: 与map()结合进行映射keys = ['a', 'b', 'c']values = [1, 2, 3]# 使用map()和lambda表达式将键和值相加(这里只是一个示例，通常键和值类型不同不会相加)# 但在实际应用中，你可以执行任何你需要的操作result = map(lambda item: item[0] + str(item[1]), zip(keys, values))# 将map对象转换为列表（如果需要）result_list = list(result)print(result_list)# ['a1', 'b2', 'c3']# 示例4: 与列表推导式结合使用keys = ['a', 'b', 'c']values = [1, 2, 3]# 使用列表推导式将键和值组合成字符串，并创建一个新列表combined = [f"{key}:{value}" for key, value in zip(keys, values)]print(combined)# ['a:1', 'b:2', 'c:3']# 应用六：数据预处理和转换# 示例1: 将两个列表中的元素合并成字典列表names = ['Myelsa', 'Bruce', 'Jimmy']ages = [18, 6, 15]# 使用 zip() 和列表推导式合并两个列表为字典列表people = [{'name': name, 'age': age} for name, age in zip(names, ages)]print(people)# [{'name': 'Myelsa', 'age': 18}, {'name': 'Bruce', 'age': 6}, {'name': 'Jimmy', 'age': 15}]# 示例2: 对两个列表中的元素进行数值转换prices = [100, 200, 300]discount_rates = [0.1, 0.15, 0.2]# 使用zip()和列表推导式计算折扣价格discounted_prices = [price * (1 - discount_rate) for price, discount_rate in zip(prices, discount_rates)]print(discounted_prices)# [90.0, 170.0, 240.0]# 示例3: 将两个列表中的字符串连接成新的字符串列表first_names = ['Myelsa', 'Bruce', 'Jimmy']last_names = ['Smith', 'Johnson', 'Brown']# 使用zip()和列表推导式连接字符串full_names = [first + ' ' + last for first, last in zip(first_names, last_names)]print(full_names)# ['Myelsa Smith', 'Bruce Johnson', 'Jimmy Brown']# 示例4: 合并多个列表为元组列表names = ['Myelsa', 'Bruce', 'Jimmy']ages = [18, 6, 15]cities = ['Guangzhou', 'Foshan', 'Los Angeles']# 使用zip()和列表推导式合并多个列表为元组列表person_info = [(name, age, city) for name, age, city in zip(names, ages, cities)]print(person_info)# [('Myelsa', 18, 'Guangzhou'), ('Bruce', 6, 'Foshan'), ('Jimmy', 15, 'Los Angeles')]# 应用七：文件操作# 文件名列表filenames = ['file.txt', 'test.txt']# 使用with open语句来确保文件在使用后正确关闭# 使用zip函数来同时读取每个文件的行with open(filenames[0], 'r') as file1, open(filenames[1], 'r') as file2: # 使用zip函数将两个文件对象(它们是可迭代的行)组合在一起 for line1, line2 in zip(file1, file2): # 去除行尾的换行符(如果需要的话) line1 = line1.strip() line2 = line2.strip() # 打印或处理每对行 print(f"从 file.txt 读取: {line1}") print(f"从 test.txt 读取: {line2}") print() # 打印一个空行以便区分不同的行对# 当 with 语句块结束时，文件将自动关闭# 从 file.txt 读取: 11# 从 test.txt 读取: 24## 从 file.txt 读取: 22# 从 test.txt 读取: 32## 从 file.txt 读取: 33# 从 test.txt 读取: 46import itertoolsfilenames = ['file.txt', 'test.txt']with open(filenames[0], 'r') as file1, open(filenames[1], 'r') as file2: for line1, line2 in itertools.zip_longest(file1, file2, fillvalue=''): line1 = line1.strip() if line1 else '（无内容）' line2 = line2.strip() if line2 else '（无内容）' print(f"从 file1.txt 读取: {line1}") print(f"从 file2.txt 读取: {line2}") print()# 从 file1.txt 读取: 11# 从 file2.txt 读取: 24## 从 file1.txt 读取: 22# 从 file2.txt 读取: 32## 从 file1.txt 读取: 33# 从 file2.txt 读取: 46## 从 file1.txt 读取: （无内容）# 从 file2.txt 读取: 58# 应用八：生成器表达式# 示例1: 合并两个迭代器并生成元组# 定义两个迭代器iter1 = range(1, 4)iter2 = range(10, 13)# 使用zip()和生成器表达式(这里实际上不需要，因为zip()已经是一个迭代器)zipped = zip(iter1, iter2)# 遍历结果for item in zipped: print(item)# (1, 10)# (2, 11)# (3, 12)# 示例2: 使用生成器表达式扩展zip()的结果# 定义两个迭代器iter1 = ['a', 'b', 'c']iter2 = [1, 2, 3]# 使用zip()和生成器表达式来转换结果formatted_items = (f"({item1}, {item2})" for item1, item2 in zip(iter1, iter2))# 遍历结果for item in formatted_items: print(item)# (a, 1)# (b, 2)# (c, 3)# 示例3: 处理不同长度的迭代器并填充缺失值import itertools# 定义两个不同长度的迭代器iter1 = ['a', 'b', 'c', 'd']iter2 = [1, 2, 3]# 使用itertools.zip_longest()和生成器表达式来处理不同长度的迭代器filled_items = (f"({item1 or 'None'}, {item2 or 'None'})" for item1, item2 in itertools.zip_longest(iter1, iter2, fillvalue='None'))# 遍历结果for item in filled_items: print(item)# (a, 1)# (b, 2)# (c, 3)# (d, None)# 应用九：代码简化# 示例1: 合并两个列表并解压为变量# 不使用zip()list1 = ['a', 'b', 'c']list2 = [1, 2, 3]for i in range(len(list1)): print(f"list1: {list1[i]}, list2: {list2[i]}")# 使用zip()简化for item1, item2 in zip(list1, list2): print(f"list1: {item1}, list2: {item2}")# list1: a, list2: 1# list1: b, list2: 2# list1: c, list2: 3# list1: a, list2: 1# list1: b, list2: 2# list1: c, list2: 3# 示例2: 合并多个列表为字典# 不使用zip()keys = ['a', 'b', 'c']values = [1, 2, 3]dictionary = {}for i in range(len(keys)): dictionary[keys[i]] = values[i]# 使用zip()简化dictionary = dict(zip(keys, values))print(dictionary)# {'a': 1, 'b': 2, 'c': 3}# 示例3: 交换列表中的元素位置# 原始列表list1 = ['a', 'b', 'c']list2 = [1, 2, 3]# 使用zip()交换元素位置(这里只是打印结果，实际并未交换列表)for item1, item2 in zip(list1, list2): print(f"Original: ({item1}, {item2}), Swapped: ({item2}, {item1})")# 如果真的想要交换两个列表的元素并存储到新的列表中swapped_list1, swapped_list2 = zip(*zip(list2, list1))swapped_list1, swapped_list2 = list(swapped_list1), list(swapped_list2)print(swapped_list1)print(swapped_list2)# Original: (a, 1), Swapped: (1, a)# Original: (b, 2), Swapped: (2, b)# Original: (c, 3), Swapped: (3, c)# [1, 2, 3]# ['a', 'b', 'c']# 示例4: 遍历多个列表并找出最长的字符串# 多个列表lists = [['apple', 'banana'], ['cat', 'dog', 'elephant'], ['fish']]# 使用zip()和max()找出每个列表中的最长字符串(但zip()在这里并不直接有用，因为它会截断到最短列表的长度)longest_strings = [max(lst, key=len) for lst in lists]print(longest_strings)# 如果我们确实想要用zip()来处理(尽管不推荐，因为会截断)，可以这样做：# 注意：这只会给出最短列表中的最长字符串，因为zip()会停止在最短的迭代器结束处longest_in_zip = [max(tup, key=len) for tup in zip(*lists)]print(longest_in_zip)# ['banana', 'elephant', 'fish']# ['apple']

1-2、VBA：

略，待后补。

 2、推荐阅读：

2-1、Python-VBA函数之旅-enumerate()函数

Python算法之旅：Algorithms

Python函数之旅：Functions

个人主页：神奇夜光杯-CSDN博客