我正在尝试学习如何“压缩”列表。为此，我有一个程序，在某个特定点上，我执行以下操作：
x1, x2, x3 = stuff.calculations(withdataa)
这为我提供了三个列表，x1，x2和x3，每个列表，例如，大小为20。
现在，我这样做：
zipall = zip(x1, x2, x3)
然而，当我这样做时：
print "len of zipall %s" % len(zipall)
我得到20，这不是我的预期。我预计三个。我认为我做的事情根本就是错误的。
答案 0 :(得分：196)
当你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
当然，如果列表开头是空的，这将不起作用。
答案 1 :(得分：54)
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...
并将它们“拉”成一个列表，其条目为3元组(ai, bi, ci)。想象一下从左到右水平拉伸拉链。
答案 2 :(得分：31)
在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))
答案 3 :(得分：25)
zip创建一个新列表，其中包含包含可迭代参数中元素的元组：
>>> zip ([1,2],[3,4])
[(1,3), (2,4)]
我希望你尝试的是创建一个元组，其中每个元素都是一个列表。
答案 4 :(得分：13)
基本上，zip函数适用于Python中的列表，元组和字典。 如果您使用的是IPython，那么只需输入zip？并查看zip（）的内容。
如果您不使用IPython，那么只需安装它：＆＃34; pip install ipython＆＃34;
列表
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')]
答案 5 :(得分：12)
来源：My Blog Post (better formatting)
示例
numbers = [1,2,3]
letters = 'abcd'
zip(numbers, letters)
# [(1, 'a'), (2, 'b'), (3, 'c')]
零个或多个iterables [1]（例如list，string，tuple，dictionary）
第1个元组=（element_1 of numbers，element_1 of letters）
第二元组=（e_2数字，e_2字母）
...
第n个元组=（e_n个数字，e_n个字母）
i tuple =（element_i arg1，element_i arg2 ...，element_i arg n）1）空字符串：len（str）= 0 =没有元组
2）单个字符串：len（str）== 2个元组与len（args）== 1个元素
zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]
<强> 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 *代码：
# 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个参数
答案 6 :(得分：8)
为了完整起见。
当压缩列表的长度不相等时。 结果列表的长度将变为最短的长度而不会发生任何错误
>>> a = [1]
>>> b = ["2", 3]
>>> zip(a,b)
[(1, '2')]
答案 7 :(得分：6)
在 Python 3 zip中返回一个迭代器，需要传递给list函数来获取压缩元组：
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']
答案 8 :(得分：2)
在这里值得添加，因为它是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))
答案 9 :(得分：1)
我认为zip不会返回列表。 zip返回一个生成器。您必须list(zip(a, b))才能获得元组列表。
x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
list(zipped)