Come convertire un elenco di tuple in più elenchi?

Supponiamo di avere un elenco di tuple e voglio convertirlo in più elenchi.

Ad esempio, l'elenco delle tuple è

[(1,2),(3,4),(5,6),]

Esiste una funzione incorporata in Python che lo converte in:

[1,3,5],[2,4,6]

Questo può essere un semplice programma. Ma sono solo curioso dell'esistenza di tale funzione incorporata in Python.

La funzione integrata zip()farà quasi quello che vuoi:

>>> zip(*[(1, 2), (3, 4), (5, 6)])
[(1, 3, 5), (2, 4, 6)]

L'unica differenza è che ottieni tuple invece di liste. Puoi convertirli in elenchi usando

map(list, zip(*[(1, 2), (3, 4), (5, 6)]))

Dai documenti di Python :

zip () in combinazione con l'operatore * può essere utilizzato per decomprimere un elenco:

Esempio specifico:

>>> zip((1,3,5),(2,4,6))
[(1, 2), (3, 4), (5, 6)]
>>> zip(*[(1, 2), (3, 4), (5, 6)])
[(1, 3, 5), (2, 4, 6)]

Oppure, se vuoi davvero gli elenchi:

>>> map(list, zip(*[(1, 2), (3, 4), (5, 6)]))
[[1, 3, 5], [2, 4, 6]]

Uso:

a = [(1,2),(3,4),(5,6),]    
b = zip(*a)
>>> [(1, 3, 5), (2, 4, 6)]

franklsf95 va per le prestazioni nella sua risposta e sceglie list.append(), ma non sono ottimali.

Aggiungendo le liste di comprensione, ho finito con quanto segue:

def t1(zs):
    xs, ys = zip(*zs)
    return xs, ys

def t2(zs):
    xs, ys = [], []
    for x, y in zs:
        xs.append(x)
        ys.append(y)
    return xs, ys

def t3(zs):
    xs, ys = [x for x, y in zs], [y for x, y in zs]
    return xs, ys

if __name__ == '__main__':
    from timeit import timeit
    setup_string='''\
N = 2000000
xs = list(range(1, N))
ys = list(range(N+1, N*2))
zs = list(zip(xs, ys))
from __main__ import t1, t2, t3
'''
    print(f'zip:\t\t{timeit('t1(zs)', setup=setup_string, number=1000)}')
    print(f'append:\t\t{timeit('t2(zs)', setup=setup_string, number=1000)}')
    print(f'list comp:\t{timeit('t3(zs)', setup=setup_string, number=1000)}')

Questo ha dato il risultato:

zip:            122.11585397789766
append:         356.44876132614047
list comp:      144.637765085659

Quindi, se stai cercando la performance, dovresti probabilmente usare zip()anche se le comprensioni degli elenchi non sono troppo indietro. Le prestazioni di appendsono in realtà piuttosto scadenti in confronto.

Nonostante *zipsia più Pythonic, il codice seguente ha prestazioni molto migliori:

xs, ys = [], []
for x, y in zs:
    xs.append(x)
    ys.append(y)

Inoltre, quando l'elenco originale zsè vuoto, *zipverrà generato, ma questo codice può essere gestito correttamente.

Ho appena eseguito un rapido esperimento ed ecco il risultato:

Using *zip:     1.54701614s
Using append:   0.52687597s

Eseguendolo più volte, appendè 3 volte - 4 volte più veloce di zip! Lo script di test è qui:

#!/usr/bin/env python3
import time

N = 2000000
xs = list(range(1, N))
ys = list(range(N+1, N*2))
zs = list(zip(xs, ys))

t1 = time.time()

xs_, ys_ = zip(*zs)
print(len(xs_), len(ys_))

t2 = time.time()

xs_, ys_ = [], []
for x, y in zs:
    xs_.append(x)
    ys_.append(y)
print(len(xs_), len(ys_))

t3 = time.time()

print('Using *zip:\t{:.8f}s'.format(t2 - t1))
print('Using append:\t{:.8f}s'.format(t3 - t2))

La mia versione di Python:

Python 3.6.3 (default, Oct 24 2017, 12:18:40)
[GCC 4.2.1 Compatible Apple LLVM 8.1.0 (clang-802.0.42)] on darwin
Type "help", "copyright", "credits" or "license" for more information.

Oltre alla risposta di Claudiu, puoi usare:

>>>a, b = map(list, zip(*[(1, 2), (3, 4), (5, 6)]))
>>>a
[1,3,5]
>>>b
[2,4,6]

Modificato secondo @Peyman mohseni kiasari

Aggiungendo alla risposta di Claudiu e Claudiu e poiché la mappa deve essere importata da itertools in python 3, si utilizza anche una comprensione dell'elenco come:

[[*x] for x in zip(*[(1,2),(3,4),(5,6)])]
>>> [[1, 3, 5], [2, 4, 6]]