Zip列表在Python中

Question

我正在尝试学习如何"压缩"列表.为此,我有一个程序,在某个特定点上,我执行以下操作:

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

这给了我三个列表,x1,x2,和x3,每一个,比方说,大小为20.

现在,我这样做:

zipall = zip(x1, x2, x3)

但是,当我这样做时:

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

我得到20,这不是我的预期.我预计三个.我认为我做的事情从根本上说是错误的.

Answer 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

当然,如果列表开头是空的,这将不起作用.

Answer 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...

并将它们"压缩"成一个列表,其条目为3元组(ai, bi, ci).想象一下从左到右水平拉伸拉链.

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

Answer 4

zip 创建一个新列表,填充包含可迭代参数中元素的元组:

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

我希望你尝试的是创建一个元组,其中每个元素都是一个列表.

Answer 5

基本上,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')]

Answer 6

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

例

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个字母)

1. n个元组列表:n是最短参数的长度(输入)
   • len(数字)== 3 <len(字母)== 4→short = 3→返回3个元组
2. 每个元组的长度= args的数量(元组从每个arg中获取一个元素)
   • args =(数字,字母); len(args)== 2→具有2个元素的元组
3. ith 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 =每个的e2zipped

脚注

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

* 码:

# 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

Answer 7

为了完整性的缘故.

当压缩列表的长度不相等时.结果列表的长度将变为最短的长度而不会发生任何错误

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

Answer 8

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

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