Transponer / Descomprimir Función (inversa de zip)?

También podrías hacer

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

debería escalar mejor. Especialmente si Python hace bien en no expandir las comprensiones de la lista a menos que sea necesario.

(Por cierto, hace una 2-tupla (par) de listas, en lugar de una lista de tuplas, como hace zip.)

Si los generadores en lugar de las listas reales están bien, esto haría eso:

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

Los generadores no mastican la lista hasta que pides cada elemento, pero por otro lado, mantienen referencias a la lista original.

Si tiene listas que no tienen la misma longitud, es posible que no desee usar zip según la respuesta de Patricks. Esto funciona:

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

Pero con diferentes listas de longitud, zip trunca cada elemento a la longitud de la lista más corta:

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

Puede usar map with no function para rellenar los resultados vacíos con None:

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

Zip() es ligeramente más rápido.

Me gusta usar zip(*iterable) (que es la pieza de código que estás buscando) en mis programas así:

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

Encuentro unzip más legible.

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

Da una tupla de listas como en la pregunta.

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

Desempaqueta las dos listas.

Es solo otra forma de hacerlo, pero me ayudó mucho, así que lo escribo aquí:

Teniendo esta estructura de datos:

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

Resultando en:

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

La forma más pitónica de descomprimirlo y volver al original es esta en mi opinión:

x,y=zip(*XY)

Pero esto devuelve una tupla, por lo que si necesita una matriz puede usar:

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

Dado que devuelve tuplas (y puede usar toneladas de memoria), el truco zip(*zipped) me parece más inteligente que útil.

Aquí hay una función que realmente le dará el inverso de 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

Ninguna de las respuestas anteriores eficientemente proporciona la salida requerida, que es una tupla de listas, en lugar de una lista de tuplas. Para el primero, puede usar tuple con map. Aquí está la diferencia:

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

Además, la mayoría de las soluciones anteriores asumen Python 2.7, donde zip devuelve una lista en lugar de un iterador.

Para Python 3.x, tendrá que pasar el resultado a una función como list o tuple para agotar el iterador. Para iteradores eficientes en memoria, puede omitir las llamadas externas list y tuple para las soluciones respectivas.

Aunque zip(*seq) es muy útil, puede no ser adecuado para secuencias muy largas, ya que creará una tupla de valores que se pasarán. Por ejemplo, he estado trabajando con un sistema de coordenadas con más de un millón de entradas y me parece significativamente más rápido para crear las secuencias directamente.

Un enfoque genérico sería algo como esto:

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)

Pero, dependiendo de lo que quieras hacer con el resultado, la elección de la colección puede marcar una gran diferencia. En mi caso de uso real, usando conjuntos y sin bucle interno, es notablemente más rápido que todos los demás enfoques.

Y, como otros han señalado, si está haciendo esto con conjuntos de datos, podría tener sentido usar colecciones Numpy o Pandas en su lugar.

Otra forma de pensar en unzip o transpose es convertir una lista de filas en una lista de columnas.

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

Así es como puedes transponer una tupla de 2x4 a una tupla de 4x2.

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

Resultado

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