Python 中的 Zip 列表

Posted 2023-02-23

【中文标题】Python 中的 Zip 列表

【英文标题】：Zip lists in Python

【发布时间】：2012-11-22 04:39:54

【问题描述】：

我正在尝试学习如何“压缩”列表。为此，我有一个程序，在某个特定点，我执行以下操作：

x1, x2, x3 = stuff.calculations(withdataa)

这给了我三个列表，x1、x2 和 x3，每个列表的大小为 20。

现在，我愿意：

zipall = zip(x1, x2, x3)

但是，当我这样做时：

print "len of zipall %s" % len(zipall)

我得到了 20，这不是我的预期。我预计三个。我认为我做的事情根本上是错误的。

【问题讨论】：

您究竟希望zip 做什么？为什么你应该有三个列表——它们会是什么样子？

zip 返回一个元组列表。

【参考方案1】：

当您zip() 将三个列表组合在一起时，每个列表包含 20 个元素，结果有 20 个元素。每个元素都是一个三元组。

自己看看：

In [1]: a = b = c = range(20)

In [2]: zip(a, b, c)
Out[2]: 
[(0, 0, 0),
 (1, 1, 1),
 ...
 (17, 17, 17),
 (18, 18, 18),
 (19, 19, 19)]

要找出每个元组包含多少个元素，您可以检查第一个元素的长度：

In [3]: result = zip(a, b, c)

In [4]: len(result[0])
Out[4]: 3

当然，如果列表一开始是空的，这将不起作用。

【讨论】：

len(result[0]) 不起作用。 “zip”对象不可下标

@GilbertS in Python 2 zip 返回了一个列表。在 Python 3 中它是一个迭代器

@GilbertS 在 Python 3 中使用 list(zip(a, b, c)) 来获得 Python 2 的行为。

【参考方案2】：

zip 获取一堆点赞列表

a: a1 a2 a3 a4 a5 a6 a7...
b: b1 b2 b3 b4 b5 b6 b7...
c: c1 c2 c3 c4 c5 c6 c7...

并将它们“压缩”到一个列表中，其条目是三元组(ai, bi, ci)。想象一下从左到右水平画一条拉链。

【讨论】：

@Sigur: "Convert tuple to list and back "

【参考方案3】：

在 Python 2.7 中这可能运行良好：

>>> a = b = c = range(20)
>>> zip(a, b, c)

但在 Python 3.4 中应该是这样（否则，结果将类似于 <zip object at 0x00000256124E7DC8>）：

>>> a = b = c = range(20)
>>> list(zip(a, b, c))

【参考方案4】：

zip 创建一个新列表，其中填充包含来自可迭代参数的元素的元组：

>>> zip ([1,2],[3,4])
[(1,3), (2,4)]

我希望您尝试创建一个元组，其中每个元素都是一个列表。

【参考方案5】：

在 Python 3 中，zip 返回一个迭代器，需要传递给一个列表函数来获取压缩元组：

x = [1, 2, 3]; y = ['a','b','c']
z = zip(x, y)
z = list(z)
print(z)
>>> [(1, 'a'), (2, 'b'), (3, 'c')]

然后到unzip 他们回来只是共轭压缩迭代器：

x_back, y_back = zip(*z)
print(x_back); print(y_back)
>>> (1, 2, 3)
>>> ('a', 'b', 'c')

如果需要原始形式的列表而不是元组：

x_back, y_back = zip(*z)
print(list(x_back)); print(list(y_back))
>>> [1,2,3]
>>> ['a','b','c']

【讨论】：

问题标签说明 Python 2.7；这是针对 Python 3 的。此外，this answer 已经提到了这一点。

@9769953 这个答案很有用我是 python 上的 google zip 列表，而不是 python 2.7。

【参考方案6】：

来源：My Blog Post (better formatting)

示例

numbers = [1,2,3]
letters = 'abcd'

zip(numbers, letters)
# [(1, 'a'), (2, 'b'), (3, 'c')]

输入

零个或多个可迭代对象 [1]（例如列表、字符串、元组、字典）

输出（列表）

第一个元组=（数字元素_1，字母元素_1）

第二个元组 =（e_2 个数字，e_2 个字母）

…

第n个元组=（e_n个数字，e_n个字母）

n 个元组的列表：n 是最短参数（输入）的长度 len(numbers) == 3 每个元组的长度 = # of args（元组从每个 arg 中获取一个元素） args = (数字、字母); len(args) == 2 → 包含 2 个元素的元组 ith tuple = (element_i arg1, element_i arg2…, element_i argn)

边缘案例

1) 空字符串：len(str)= 0 = 无元组

2) 单个字符串：len(str) == 2 个元组，其中 len(args) == 1 个元素

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

---

Zip 在行动！

1.从两个列表中构建字典 [2]

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

zip 是一个优雅、清晰、简洁的解决方案

2。打印表格中的列

“*”[3] 称为“解包”：f(*[arg1,arg2,arg3]) == f(arg1, arg2, arg3)

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

---

额外功劳：解压

zip(*args)被称为“解压”，因为它具有zip的反作用

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

unzipped: tuple_1 = 每个压缩元组的 e1。 tuple_2 = 每个zipped 的 e2

---

脚注

一个能够一次返回一个成员的对象（例如列表 [1,2,3]、字符串“我喜欢编码”、元组 (1,2,3)、字典 'a':1、 'b':2) key1:value1, key2:value2... “拆包”(*)

*代码：

# foo - function, returns sum of two arguments
def foo(x,y):
    return x + y
print foo(3,4)
# 7

numbers = [1,2]
print foo(numbers)
# TypeError: foo() takes exactly 2 arguments (1 given)

print foo(*numbers)
# 3

* 采用 numbers (1 arg) 并将其 2 个元素“解包”为 2 个 args

【参考方案7】：

基本上，zip 函数适用于 Python 中的列表、元组和字典。 如果您使用的是 IPython，那么只需输入 zip？并检查 zip() 是关于什么的。

如果您不使用 IPython，则只需安装它：“pip install ipython”

对于列表

a = ['a', 'b', 'c']
b = ['p', 'q', 'r']
zip(a, b)

输出为[('a', 'p'), ('b', 'q'), ('c', 'r')

对于字典：

c = 'gaurav':'waghs', 'nilesh':'kashid', 'ramesh':'sawant', 'anu':'raje'
d = 'amit':'wagh', 'swapnil':'dalavi', 'anish':'mane', 'raghu':'rokda'
zip(c, d)

输出是：

[('gaurav', 'amit'),
 ('nilesh', 'swapnil'),
 ('ramesh', 'anish'),
 ('anu', 'raghu')]

【讨论】：

zip(c,d) 正在执行 zip(list(c), list(d))

【参考方案8】：

为了完整性。

当压缩列表的长度不相等时。 结果列表的长度将成为最短的，没有任何错误发生

>>> a = [1]
>>> b = ["2", 3]
>>> zip(a,b)
[(1, '2')]

【参考方案9】：

值得在这里添加，因为它是一个关于 zip 的排名很高的问题。 zip 是很棒的、惯用的 Python - 但对于大型列表来说，它根本不能很好地扩展。

代替：

books = ['AAAAAAA', 'BAAAAAAA', ... , 'ZZZZZZZ']
words = [345, 567, ... , 672]

for book, word in zip(books, words):
   print(': '.format(book, word))

使用izip。对于现代处理，它将其存储在 L1 高速缓存内存中，并且对于更大的列表而言性能要高得多。使用它就像添加一个i：

for book, word in izip(books, words):
   print(': '.format(book, word))

【参考方案10】：

我认为zip 不会返回列表。 zip 返回一个生成器。您必须执行list(zip(a, b)) 才能获得元组列表。

x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
list(zipped)

【讨论】：

问题标签说明 Python 2.7；这是针对 Python 3 的。此外，this answer 已经提到了这一点。