压缩浮动数列表

zip 函数也适用于浮点数。
浮点数包含小数点，如 10.3、14.44 等。

在本节中，我们将创建一个示例，其中 zip 函数遍历浮点数列表：

>>> float_list1 = [12.3, 10.99, 3.33, 2.97]
>>> float_list2 = [78.13, 0.89, 4.6, 0.7]
>>> float_zip = zip(float_list1, float_list2)
>>> print(tuple(float_zip))

输出：

((12.3, 78.13), (10.99, 0.89), (3.33, 4.6), (2.97, 0.7))

zip 函数如何工作？

zip 函数将每个迭代器的第一个元素配对在一起，然后将第二个元素配对在一起，依此类推。

如果 zip 函数中的 iterable 长度不同，那么最小长度的 iterable 决定生成输出的长度。

语法：

zip(iterable0, iterable1, interable2, …)

可迭代对象可以是 Python 列表、字典、字符串或者任何可迭代对象。

在上面的语法中，iterable0、iterable1 等是我们需要使用 zip 函数连接的迭代器对象。

例子：

考虑以下代码片段，其中我们有三个可迭代对象，并且 zip 函数将它们连接在一起。

x = ("oiry", "Monica", "Ross")
y = (".comler", "Pheobe")
z = ("David", "Rachel", "Courtney")
result = zip(x, y, z)
print(result)
print(tuple(result))

输出：

(('oiry', '.comler', 'David'), ('Monica', 'Pheobe', 'Rachel'))

在上面的例子中，我们定义了三个不同长度的迭代器。
它们的第一个元素连接在一起。
同样，所有这些的第二个元素连接在一起。

但是迭代器 y 中没有第三个元素；因此，剩余迭代器的第三个元素不包含在输出对象中。

这就是为什么我们之前说输出的长度等于最小迭代器的长度，在这种情况下是 2.

tuple() 函数将 zip 对象转换为元组。

如果不向函数传递参数，它将生成一个空的可迭代对象。
例如，print(tuple(zip())) 的结果将是 ()：

将两个列表转换为字典

要使用 zip 函数将两个列表转换为字典，我们将像我们一样使用 zip 函数连接列表，然后我们可以将它们转换为字典。

假设我们有两个列表如下：

coin = ('Bitcoin', 'Ether', 'Ripple', 'Litecoin')
code = ('BTC', 'ETH', 'XRP', 'LTC')

因此，我们将压缩列表，然后使用 dict() 函数将其转换为字典：

dict(zip(coin, code))

输出将是：

{'Bitcoin': 'BTC', 'Ether': 'ETH', 'Ripple': 'XRP', 'Litecoin': 'LTC'}

三个/多个列表上的 Zip 函数

我们可以将多个可迭代对象传递给相同或者不同类型的 zip 函数。
在下面的例子中，我们定义了三个列表（都是相同的长度），但是每个列表中项目的数据类型是不同的。

例子：

list_a = ['Bitcoin', 'Ethereum', 'Ripple', 'Litecoin', 'Bitcoin-cash']
list_b = ['BTC', 'ETH', 'XRP', 'LTC', 'BCH']
list_c = ['11605', '271', '0.335', '102', '347']
result = zip(list_a, list_b, list_c)
print(tuple(result))

输出：

(('Bitcoin', 'BTC', '11605'), ('Ethereum', 'ETH', '271'), ('Ripple', 'XRP', '0.335'), ('Litecoin', 'LTC', '102'), ('Bitcoin-cash', 'BCH', '347'))

类似地，我们可以以同样的方式使用 zip() 函数连接三个以上的可迭代对象。

zip函数星号（unzip）

zip() 函数中的星号将迭代的元素转换为单独的元素。
例如：如果 a = [a1, a2, a3] 那么 zip(*a) 相当于 (('a', 'a', 'a'), ('1', '2', '3')) .

换句话说，我们可以说 zip 函数中的星号解压缩给定的可迭代对象。

考虑以下示例：

例子：

a = ['a1', 'a2', 'a3']
r = zip(*a)
print(tuple(r))

输出：

(('a', 'a', 'a'), ('1', '2', '3'))

Python 编程中的 zip() 函数是一个内置的标准函数，它以多个可迭代对象或者容器为参数。

Python 中的可迭代对象是一个可以像集合一样迭代或者单步执行的对象。

我们可以使用 zip() 函数来映射多个可迭代对象的相同索引。
映射这些索引将生成一个 zip 对象。

压缩不同长度的列表

当 zip() 函数中的参数长度不同时，输出对象长度将等于最短输入列表的长度。

考虑以下示例以获得更清晰的视图：

例子：

list_a = [1, 2, 3, 4, 5]
list_b = ['one', 'two', 'three']
result = zip(list_a, list_b)
print(tuple(result))

输出：

((1, 'one'), (2, 'two'), (3, 'three'))

在这个例子中，list_a 有五个元素，list_b 有三个元素。
迭代器将在到达第三个元素时停止。
因此，我们在输出元组中有三个元组。

压缩矩阵

矩阵是一个 m*n 的多维数组，其中 m 表示行数，n 表示列数。

在 Python 中，我们可以使用 zip 函数来查找矩阵的转置。
第一步是使用 * 运算符解压缩矩阵，最后再次压缩它，如下例所示：

mat = [[1,2,3], [4,5,6]]
trans_mat = zip(*mat)
print(tuple(trans_mat))

输出：

((1, 4), (2, 5), (3, 6))

在这个例子中，矩阵是一个 2*3 的矩阵，这意味着它有两行三列。
在对矩阵进行转置时，将有三行和两列。

类似地，如果我们在矩阵中有 1 行和 3 列：

[[1, 2, 3]]

在进行转置时，我们应该有 3 行 1 列。
考虑以下片段：

例子：

mat = [[1,2,3]]
trans_mat = zip(*mat)
print(tuple(trans_mat))

输出：

((1,), (2,), (3,))

并行遍历两个列表

我们还可以使用 zip 函数同时迭代两个列表。
检查以下示例：

list_1 = ['Numpy', 'asyncio', 'cmath', 'enum', 'ftplib']
list_2 = ['C', 'C++', 'Java', 'Python']
for i, j in zip(list_1, list_2):
    print(i, j)

输出：

Numpy C
asyncio C++
cmath Java
enum Python

在上面的例子中，我们有两个不同的列表。
for 循环使用两个迭代变量来遍历压缩在一起以并行工作的列表。

传递一个可迭代对象

如果我们将一个可迭代对象传递给 zip() 函数的参数，则每个元组中都会有一个项目。
检查以下代码：

list_1 = ['C', 'C++', 'Python', 'Java']
list_zip = zip(list_1)
print(tuple(list_zip))

输出

(('C',), ('C++',), ('Python',), ('Java',))

输出到文件

将 zip 函数的输出保存到文件中。
考虑以下示例：

第一步是打开一个文件（我们将使用添加模式，因此不会删除任何现有内容）。
使用以下行：

f = open("zipOutput.txt", "a+")

如果文件不存在，它将被创建。

现在让我们创建两个列表以压缩在一起。

list_1 = ['C', 'C++', 'Python', 'Java']
list_2 = ['Solidity', 'Android', 'Php', 'Kotlin']

最后，使用 for 循环遍历 zip 函数中的列表并将结果写入文件（将元组转换为字符串后）：

for i in zip(list_1, list_2):
    f.write(str(i))

现在关闭文件并检查保存的数据。

f.close()

以下将是文件的内容：

此外，还有一个较短的代码，而不是使用 for 循环。
我们可以将 zip 对象转换为元组，然后转换为字符串并将字符串写入文件：

f.write(str(tuple(zip(list_1,list_2))))

这将导致相同的结果。