Кортежи в списке массивов в python [duplicate]

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

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

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

Если у вас есть списки, которые не имеют одинаковой длины, вы можете не захотеть использовать zip в соответствии с ответом Patricks. Это работает:

>>> 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 () немного быстрее, хотя.

Это только другой способ сделать это, но это очень помогло мне написать здесь:

Наличие этой структуры данных:

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)

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

xy=(list(x),list(y))

Так вы можете транспонировать кортеж 2x4 в кортеж 4x2.

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

Еще один способ подумать о unzip или transpose - преобразовать список строк в список столбцов.

pitchers = [('Nolan', 'Ryan'), ('Roger', 'Clements'), ('Schilling','Curt')]
first_names, last_names = zip(*pitchers)
In [45]: first_names
Out[45]: ('Nolan', 'Roger', 'Schilling')
In [46]: last_names
Out[46]: ('Ryan', 'Clements', 'Curt')

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

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

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

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

Я нахожу unzip более читаемым.

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