Python 中的 Zip 列表

小开

最佳答案

当 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

当然，如果列表一开始就是空的，那么这种方法就不起作用。

小开

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

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

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

小开

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)的列表中。

小开

基本上，zip 函数用于 Python 中的列表、元组和字典。如果您使用 IPython，那么只需键入 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')]

小开

在 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))

小开

为了完整起见。

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

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

小开

资料来源: 我的博客文章(更好的格式)

例子

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


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

输入

零个或多个迭代器[1](例如列表、字符串、元组、字典)

输出 (列表)

第一个 tuple = (数字的 element _ 1，字母的 element _ 1)

第二个元组 = (e _ 2个数字，e _ 2个字母)

...

N-th tuple = (e _ n 个数字，e _ n 个字母)

N 元组列表: n 是最短参数(输入)的长度
- Len (数字) = = 3 < len (字母) = = 4→ short = 3→返回3个元组
每个 tuple = # of args 的长度(tuple 从每个 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',)]

拉上拉链！

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')]

Tuple _ 1 = 每个压缩的 tuple 的 e1. tuple _ 2 = 每个 zipped的 e2

脚注

能够一次返回一个成员的对象(例如。List [1,2,3] ，string‘ I like codin’，tuple (1,2,3) ，dictionary {‘ 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 arg

小开

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

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

小开

在 巨蟒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')

如果需要的是原始形式的 list 而不是 tuple:

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

小开

值得在这里添加，因为这是一个排名非常靠前的问题。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))