Zip列表在Python中


Zip lists in Python

我正在努力学习如何"压缩"列表。为此，我有一个程序，在特定的点上，我执行以下操作：

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

这给了我三张单子，分别是x1、x2和x3，每一张都是20号的。

现在，我知道了：

1
zipall = zip(x1, x2, x3)

号

但是，当我这样做时：

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

我得到20分，这不是我所期望的。我预料会有三个。我认为我做了一些根本错误的事情。

相关讨论

当你把包含20个元素的三个列表放在一起时，结果有20个元素。每个元素都是一个三元组。

自己看看：

1
2
3
4
5
6
7
8
9
10
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)]

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

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

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

号

当然，如果列表一开始是空的，这就行不通了。

相关讨论

zip接受了一系列类似的清单

1
2
3
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)。想象一下从左到右水平地画一个拉链。

相关讨论

在Python2.7中，这可能会很好地工作：

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

但是在python 3.4中应该是(否则，结果将类似于)：

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

。

相关讨论

zip创建了一个新列表，其中包含来自iterable参数的元素的元组：

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

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

基本上，zip函数用于python中的列表、元组和字典。如果你使用的是ipython，那么只需输入zip？然后检查zip()是关于什么的。

如果您不使用ipython，那么只需安装它："pip install ipython"。

对于列表

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

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

对于字典：

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

。

输出为：

1
2
3
4
[('gaurav', 'amit'),
 ('nilesh', 'swapnil'),
 ('ramesh', 'anish'),
 ('anu', 'raghu')]

。

相关讨论

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

例子

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

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

。输入

零个或多个iterables[1](例如list、string、tuple、dictionary)

输出(列表)

1st tuple = (element_1 of numbers, element_1 of letters)

2nd tuple = (e_2 numbers, e_2 letters)

…

n-th tuple = (e_n numbers, e_n letters)

号

  • n个元组的列表：n是最短参数的长度(input)
    • len(数字)==3
  • length each 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个元素

    1
    2
    3
    4
    5
    6
    zip()
    # []
    zip('')
    # []
    zip('hi')
    # [('h',), ('i',)]

    号行动起来！

    1。从两个列表中创建字典[2]

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    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)。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    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的反作用。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    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。每个zipped的tuple_2=e2

    脚注

  • 能够一次返回一个成员的对象(例如，list[1,2,3]、string'i like codin'、tuple(1,2,3)、dictionary'a'：1，'b'：2)
  • 键1:值1，键2:值2…
  • "开箱"(*)

    • *代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    # 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。

    为了完整。

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

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

    在python 3中，zip返回一个迭代器，需要传递给list函数以获取压缩元组：

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

    号

    然后回到unzip中，它们只是变形了zipped迭代器：

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

    号

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

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

    号

    相关讨论

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

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

    号

    相关讨论