转置/解压缩功能(zip的反转)?

python list matrix transpose

138529 观看

13回复

23796 作者的声誉

我有一个2项元组的列表,我想将它们转换为2个列表,其中第一个包含每个元组中的第一个项目,第二个列表包含第二个项目。

例如:

original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
# and I want to become...
result = (['a', 'b', 'c', 'd'], [1, 2, 3, 4])

是否有内置函数可以做到这一点?

作者: Cristian 的来源 发布者: 2008 年 8 月 21 日

回应 13


710

63678 作者的声誉

决定

zip是它自己的逆!如果您使用特殊*运算符。

>>> zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)])
[('a', 'b', 'c', 'd'), (1, 2, 3, 4)]

这种方式的工作方式是zip使用参数调用:

zip(('a', 1), ('b', 2), ('c', 3), ('d', 4))

...除了参数zip直接传递给(在转换为元组之后),所以不必担心参数的数量太大。

作者: Patrick 发布者: 2008 年 8 月 21 日

26

3945 作者的声誉

你也可以这样做

result = ([ a for a,b in original ], [ b for a,b in original ])

应该更好地扩展。特别是如果Python不擅长扩展列表推导,除非需要。

(顺便提一下,它产生一个2元组(对)列表,而不是像元组列表一样zip。)

如果生成器而不是实际列表都可以,那么这样做:

result = (( a for a,b in original ), ( b for a,b in original ))

在您询问每个元素之前,生成器不会遍历列表,但另一方面,它们会保留对原始列表的引用。

作者: Anders Eurenius 发布者: 2008 年 8 月 24 日

20

687 作者的声誉

如果您的列表长度不同,则可能不希望按照Patricks的说法使用zip。这有效:

>>> zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)])
[('a', 'b', 'c', 'd'), (1, 2, 3, 4)]

但是使用不同的长度列表,zip会将每个项目截断为最短列表的长度:

>>> zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', )])
[('a', 'b', 'c', 'd', 'e')]

您可以使用没有函数的map来填充空结果,而不是:

>>> map(None, *[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', )])
[('a', 'b', 'c', 'd', 'e'), (1, 2, 3, 4, None)]

zip()虽然略快。

作者: Chris 发布者: 2011 年 1 月 2 日

15

3391 作者的声誉

我喜欢zip(*iterable)在我的程序中使用(这是你正在寻找的代码段),如下所示:

def unzip(iterable):
    return zip(*iterable)

我发现unzip更具可读性。

作者: wassimans 发布者: 2014 年 3 月 1 日

4

7276 作者的声誉

这只是另一种方式,但它帮了我很多,所以我在这里写:

拥有这种数据结构:

X=[1,2,3,4]
Y=['a','b','c','d']
XY=zip(X,Y)

导致:

In: XY
Out: [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

在我看来,解压缩并回到原始版本的更加pythonic方式是:

x,y=zip(*XY)

但这会返回一个元组,所以如果你需要一个列表,你可以使用:

x,y=(list(x),list(y))
作者: G M 发布者: 2016 年 1 月 26 日

12

554 作者的声誉

>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> tuple([list(tup) for tup in zip(*original)])
(['a', 'b', 'c', 'd'], [1, 2, 3, 4])

在问题中给出一个列表元组。

list1, list2 = [list(tup) for tup in zip(*original)]

解压缩两个列表。

作者: Noyer282 发布者: 2016 年 3 月 5 日

1

15556 作者的声誉

因为它返回元组(并且可以使用大量的内存)zip(*zipped),对我来说,这个技巧似乎更有用而且更有用。

这是一个实际上会给你反转zip的函数。

def unzip(zipped):
    """Inverse of built-in zip function.
    Args:
        zipped: a list of tuples

    Returns:
        a tuple of lists

    Example:
        a = [1, 2, 3]
        b = [4, 5, 6]
        zipped = list(zip(a, b))

        assert zipped == [(1, 4), (2, 5), (3, 6)]

        unzipped = unzip(zipped)

        assert unzipped == ([1, 2, 3], [4, 5, 6])

    """

    unzipped = ()
    if len(zipped) == 0:
        return unzipped

    dim = len(zipped[0])

    for i in range(dim):
        unzipped = unzipped + ([tup[i] for tup in zipped], )

    return unzipped
作者: Waylon Flinn 发布者: 2018 年 6 月 11 日

-1

815 作者的声誉

这就是你如何将2x4元组转换为4x2元组的方法。

 >>> tuple(zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)])) 

结果

[('a', 'b', 'c', 'd'), (1, 2, 3, 4)]
作者: helcode 发布者: 2018 年 6 月 30 日

0

105846 作者的声誉

以前的答案都不有效地提供所需的输出,这是一个列表的元组,而不是一个元组的列表。对于前者,你可以使用tuplemap。这是区别:

res1 = list(zip(*original))              # [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]
res2 = tuple(map(list, zip(*original)))  # (['a', 'b', 'c', 'd'], [1, 2, 3, 4])

此外,以前的大多数解决方案都假设使用Python 2.7,它zip返回一个列表而不是迭代器。

对于Python 3.x,您需要将结果传递给函数,例如listtuple耗尽迭代器。对于内存高效的迭代器,您可以省略外部listtuple调用相应的解决方案。

作者: jpp 发布者: 2018 年 8 月 23 日

0

11044 作者的声誉

虽然zip(*seq)非常有用,但它可能不适合非常长的序列,因为它会创建一个值元组来传入。例如,我一直在使用一个包含超过一百万个条目的坐标系,并且发现创建它的速度要快得多序列直接。

一般的方法是这样的:

from collections import deque
seq = ((a1, b1, …), (a2, b2, …), …)
width = len(seq[0])
output = [deque(len(seq))] * width # preallocate memory
for element in seq:
    for s, item in zip(output, element):
        s.append(item)

但是,根据您想要对结果做什么,选择集合可以产生很大的不同。在我的实际使用案例中,使用集合而没有内部循环,明显快于所有其他方法。

并且,正如其他人所指出的,如果您使用数据集执行此操作,则可能需要使用Numpy或Pandas集合。

作者: Charlie Clark 发布者: 2018 年 9 月 26 日

3

4637 作者的声誉

天真的方法

def transpose_finite_iterable(iterable):
    return zip(*iterable)  # `itertools.izip` for Python 2 users

对于(可能是无限的)可迭代的有限可迭代(例如,list/ tuple/的序列str)可以很好地工作,这可以被说明为

| |a_00| |a_10| ... |a_n0| |
| |a_01| |a_11| ... |a_n1| |
| |... | |... | ... |... | |
| |a_0i| |a_1i| ... |a_ni| |
| |... | |... | ... |... | |

哪里

  • n in ℕ
  • a_ij对应-th iterable的j-th元素i

申请后transpose_finite_iterable我们得到

| |a_00| |a_01| ... |a_0i| ... |
| |a_10| |a_11| ... |a_1i| ... |
| |... | |... | ... |... | ... |
| |a_n0| |a_n1| ... |a_ni| ... |

这种情况的Python例子在哪里a_ij == jn == 2

>>> from itertools import count
>>> iterable = [count(), count()]
>>> result = transpose_finite_iterable(iterable)
>>> next(result)
(0, 0)
>>> next(result)
(1, 1)

但是我们不能transpose_finite_iterable再次使用它来返回原始结构,iterable因为它result是有限迭代的无限可迭代(tuple在我们的例子中是s):

>>> transpose_finite_iterable(result)
... hangs ...
Traceback (most recent call last):
  File "...", line 1, in ...
  File "...", line 2, in transpose_finite_iterable
MemoryError

那么我们如何处理这个案子呢?

......来了 deque

在我们看一下itertools.tee函数的文档后,有一些Python配方,经过一些修改可以帮助我们的情况

def transpose_finite_iterables(iterable):
    iterator = iter(iterable)
    try:
        first_elements = next(iterator)
    except StopIteration:
        return ()
    queues = [deque([element])
              for element in first_elements]

    def coordinate(queue):
        while True:
            if not queue:
                try:
                    elements = next(iterator)
                except StopIteration:
                    return
                for sub_queue, element in zip(queues, elements):
                    sub_queue.append(element)
            yield queue.popleft()

    return tuple(map(coordinate, queues))

让我们检查

>>> from itertools import count
>>> iterable = [count(), count()]
>>> result = transpose_finite_iterables(transpose_finite_iterable(iterable))
>>> result
(<generator object transpose_finite_iterables.<locals>.coordinate at ...>, <generator object transpose_finite_iterables.<locals>.coordinate at ...>)
>>> next(result[0])
0
>>> next(result[0])
1

合成

现在我们可以定义一般函数来处理迭代的迭代,其中一些是有限的,而另一些可能是无限的,使用functools.singledispatch装饰器就像

from collections import (abc,
                         deque)
from functools import singledispatch


@singledispatch
def transpose(object_):
    """
    Transposes given object.
    """
    raise TypeError('Unsupported object type: {type}.'
                    .format(type=type))


@transpose.register(abc.Iterable)
def transpose_finite_iterables(object_):
    """
    Transposes given iterable of finite iterables.
    """
    iterator = iter(object_)
    try:
        first_elements = next(iterator)
    except StopIteration:
        return ()
    queues = [deque([element])
              for element in first_elements]

    def coordinate(queue):
        while True:
            if not queue:
                try:
                    elements = next(iterator)
                except StopIteration:
                    return
                for sub_queue, element in zip(queues, elements):
                    sub_queue.append(element)
            yield queue.popleft()

    return tuple(map(coordinate, queues))


def transpose_finite_iterable(object_):
    """
    Transposes given finite iterable of iterables.
    """
    yield from zip(*object_)

try:
    transpose.register(abc.Collection, transpose_finite_iterable)
except AttributeError:
    # Python3.5-
    transpose.register(abc.Mapping, transpose_finite_iterable)
    transpose.register(abc.Sequence, transpose_finite_iterable)
    transpose.register(abc.Set, transpose_finite_iterable)

在有限的非空迭代中,二元算子类可以被认为是它自己的逆(数学家称这种函数为“involutions”)。


作为奖励singledispatch我们可以处理numpy类似的数组

import numpy as np
...
transpose.register(np.ndarray, np.transpose)

然后像使用它一样

>>> array = np.arange(4).reshape((2,2))
>>> array
array([[0, 1],
       [2, 3]])
>>> transpose(array)
array([[0, 2],
       [1, 3]])

注意

由于transpose返回迭代器和如果有人想拥有tuplelist就像在OP -这可以另外用做map内置函数一样

>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> tuple(map(list, transpose(original)))
(['a', 'b', 'c', 'd'], [1, 2, 3, 4])

广告

我已经添加了广义的解决方案,以lz打包0.5.0版本,它可以像使用

>>> from lz.transposition import transpose
>>> list(map(tuple, transpose(zip(range(10), range(10, 20)))))
[(0, 1, 2, 3, 4, 5, 6, 7, 8, 9), (10, 11, 12, 13, 14, 15, 16, 17, 18, 19)]

PS

没有解决方案(至少是显而易见的)来处理可能无限可迭代的潜在无限可迭代,但是这种情况不太常见。

作者: Azat Ibrakov 发布者: 2018 年 12 月 21 日

1

15241 作者的声誉

考虑使用more_itertools.unzip

>>> from more_itertools import unzip
>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> [list(x) for x in unzip(original)]
[['a', 'b', 'c', 'd'], [1, 2, 3, 4]]     
作者: Neil G 发布者: 2019 年 1 月 2 日

1

54 作者的声誉

original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

#unzip 
a1 , a2 = zip(*original)
#make tuple with two list
result=(list(a1),list(a2))
result

result =(['a','b','c','d'],[1,2,3,4])

作者: Aditya kumar 发布者: 2019 年 4 月 12 日
32x32