Due incarichi in lista unica pitone comprensione

Question

Ad esempio:

a = [1,2,3] 
x = [2*i for i in a] 
y = [3*i for i in a] 

sarebbe più efficace di combinare le list comprehension in uno (se possibile) se le dimensioni di un è grande? Se è così, come lo fai?

Qualcosa di simile,

x,y = [2*i, 3*i for i in a] 

che non funziona. Se utilizzare la comprensione delle liste non è più efficiente dal punto di vista computazionale rispetto all'utilizzo di un ciclo normale per ciclo, fammelo sapere. Grazie.

Answer 1

caso di dubbi sulla efficienza utilizzare il modulo timeit, è sempre facile da usare:

import timeit 

def f1(aRange): 
    x = [2*i for i in aRange] 
    y = [3*i for i in aRange] 
    return x,y 

def f2(aRange): 
    x, y = zip(*[(2*i, 3*i) for i in aRange]) 
    return x,y 

def f3(aRange): 
    x, y = zip(*((2*i, 3*i) for i in aRange)) 
    return x,y 

def f4(aRange): 
    x = [] 
    y = [] 
    for i in aRange: 
     x.append(i*2) 
     y.append(i*3) 
    return x,y 

print "f1: %f" %timeit.Timer("f1(range(100))", "from __main__ import f1").timeit(100000) 
print "f2: %f" %timeit.Timer("f2(range(100))", "from __main__ import f2").timeit(100000) 
print "f3: %f" %timeit.Timer("f3(range(100))", "from __main__ import f3").timeit(100000) 
print "f4: %f" %timeit.Timer("f4(range(100))", "from __main__ import f4").timeit(100000) 

I risultati sembrano essere coerenti nella punta alla prima opzione, come il più veloce.

f1: 2.127573 
f2: 3.551838 
f3: 3.859768 
f4: 4.282406 

Answer 2

Si desidera utilizzare the zip() builtin con l'operatore stella per fare ciò. zip() normalmente si trasforma in elenchi in un elenco di coppie, se usato in questo modo, scompatta: prende un elenco di coppie e lo divide in due elenchi.

>>> a = [1, 2, 3] 
>>> x, y = zip(*[(2*i, 3*i) for i in a]) 
>>> x 
(2, 4, 6) 
>>> y 
(3, 6, 9) 

Nota che non sono sicuro che questo sia davvero più efficiente in un modo che sta per avere importanza.