Функция транспонирования / распаковки (обратная сторона zip)? - PullRequest
Новая
       66

Функция транспонирования / распаковки (обратная сторона zip)?

444 голосов
/ 21 августа 2008

У меня есть список кортежей из 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])

Есть ли встроенная функция, которая делает это?

Ответы [ 13 ]

697 голосов
/ 21 августа 2008

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 напрямую (после преобразования в кортеж), поэтому не нужно беспокоиться о том, что число аргументов становится слишком большим.

26 голосов
/ 24 августа 2008

Вы также можете сделать 

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

Генераторы не просматривают список, пока вы не запросите каждый элемент, но, с другой стороны, они сохраняют ссылки на исходный список.

19 голосов
/ 02 января 2011

Если у вас есть списки, которые не имеют одинаковую длину, вы можете не использовать 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')]

Вы можете использовать карту без функции, чтобы заполнить пустые результаты None: 

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

zip () немного быстрее.

15 голосов
/ 01 марта 2014

Мне нравится использовать zip(*iterable) (это фрагмент кода, который вы ищете) в моих программах так: 

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

Я считаю unzip более читабельным.

12 голосов
/ 05 марта 2016 
>>> 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)]

Распаковывает два списка.

4 голосов
/ 26 января 2016

Это еще один способ сделать это, но он мне очень помог, поэтому я пишу это здесь:

Имея такую ​​структуру данных: 

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

На мой взгляд, более питонный способ разархивировать его и вернуться к оригиналу: 

x,y=zip(*XY)

Но это возвращает кортеж, поэтому, если вам нужен список, вы можете использовать: 

x,y=(list(x),list(y))
3 голосов
/ 21 декабря 2018

Наивный подход 

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 соответствует j -ому элементу 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 == j, n == 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): 

>>> 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 function , есть рецепт 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 decorator like 

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)

, который можно рассматривать как собственный обратный (математики называют этот тип функций "инволюциями" ) в классе бинарных операторов над конечными непустыми итерациями.

В качестве бонуса singledispatch ing мы можем обрабатывать 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 возвращает итераторы, и если кто-то хочет иметь tuple из list s, как в OP - это можно сделать дополнительно с помощью встроенной функции map like 

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

приписка

Не существует решения (по крайней мере, очевидного) для обработки потенциально бесконечной итерируемой потенциально потенциально бесконечной итерации, но этот случай встречается реже.

1 голос
/ 12 апреля 2019 
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

результат = (['a', 'b', 'c', 'd'], [1, 2, 3, 4])

1 голос
/ 03 января 2019

Рассмотрите возможность использования 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]]
1 голос
/ 11 июня 2018

Поскольку он возвращает кортежи (и может использовать тонны памяти), уловка 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
Страница:
...