Come estrarre gli elementi n-esima da un elenco di tuple in python?

Question

Sto cercando di ottenere gli elementi n-esima da un elenco di tuple.

ho qualcosa di simile:

elements = [(1,1,1),(2,3,7),(3,5,10)] 

vorrei estrarre solo il secondo elemento di ogni tupla in un elenco:

seconds = [1, 3, 5] 

So che potrebbe essere fatto con un ciclo for ma Volevo sapere se c'è un altro modo perché ho migliaia di tuple.

Answer 1

[x[1] for x in elements] 

Answer 2

So che potrebbe essere fatto con un FOR ma volevo sapere se c'è un altro modo

C'è un altro modo. È anche possibile farlo con map e itemgetter:

>>> from operator import itemgetter 
>>> map(itemgetter(1), elements) 

Esegue ancora un anello interno e anche se è leggermente più lento rispetto alla lista di comprensione:

setup = 'elements = [(1,1,1) for _ in range(100000)];from operator import itemgetter' 
method1 = '[x[1] for x in elements]' 
method2 = 'map(itemgetter(1), elements)' 

import timeit 
t = timeit.Timer(method1, setup) 
print('Method 1: ' + str(t.timeit(100))) 
t = timeit.Timer(method2, setup) 
print('Method 2: ' + str(t.timeit(100))) 

Risultati:

 
Method 1: 1.25699996948 
Method 2: 1.46600008011 

Se è necessario scorrere su un elenco, utilizzare for va bene.

Answer 3

Questo funziona anche:

zip(*elements)[1] 

(sto principalmente questo distacco, per dimostrare a me stesso che ho groked zip ...)

vederlo in azione:

>>> help(zip) 

Guida per funzione integrata nel modulo zip incorporato:

zip (...)

zip (SEQ1 [, seq2 [...]]) -> [(SEQ1 [0], seq2 [0] ...), (...) ]

Restituisce un elenco di tuple, in cui ogni tupla contiene l'elemento i-esimo da ciascuna sequenza di argomenti. L'elenco restituito viene troncato in lunghezza rispetto alla lunghezza della sequenza di argomenti più breve.

>>> elements = [(1,1,1),(2,3,7),(3,5,10)] 
>>> zip(*elements) 
[(1, 2, 3), (1, 3, 5), (1, 7, 10)] 
>>> zip(*elements)[1] 
(1, 3, 5) 
>>> 

cosa pulita che ho imparato oggi: Usa *list in argomenti per creare una lista di parametri per una funzione ...

Answer 4

Abbiamo trovato questo come stavo cercando da che parte è il più veloce per tirare il secondo elemento di una lista di 2 tuple.Non quello che volevo, ma sono imbattuto stesso test come mostrato con un terzo metodo più testare il metodo zip

setup = 'elements = [(1,1) for _ in range(100000)];from operator import itemgetter' 
method1 = '[x[1] for x in elements]' 
method2 = 'map(itemgetter(1), elements)' 
method3 = 'dict(elements).values()' 
method4 = 'zip(*elements)[1]' 

import timeit 
t = timeit.Timer(method1, setup) 
print('Method 1: ' + str(t.timeit(100))) 
t = timeit.Timer(method2, setup) 
print('Method 2: ' + str(t.timeit(100))) 
t = timeit.Timer(method3, setup) 
print('Method 3: ' + str(t.timeit(100))) 
t = timeit.Timer(method4, setup) 
print('Method 4: ' + str(t.timeit(100))) 

Method 1: 0.618785858154 
Method 2: 0.711684942245 
Method 3: 0.298138141632 
Method 4: 1.32586884499 

Così oltre due volte più veloce se si dispone di una coppia di 2 tuple per convertire solo per un dict e prendere i valori.

Answer 5

map (lambda x:(x[1]),elements) 

Answer 6

tempi per Python 3.6 per estrarre il secondo elemento di una 2-tupla.

Inoltre, aggiunto il metodo di matrice numpy, che è più semplice da leggere (ma probabilmente più semplice della comprensione della lista).

from operator import itemgetter 
elements = [(1,1) for _ in range(100000)] 

%timeit second = [x[1] for x in elements] 
%timeit second = list(map(itemgetter(1), elements)) 
%timeit second = dict(elements).values() 
%timeit second = list(zip(*elements))[1] 
%timeit second = np.array(elements)[:,1] 

e gli orari:

list comprehension: 4.73 ms ± 206 µs per loop 
list(map):   5.3 ms ± 167 µs per loop 
dict:    2.25 ms ± 103 µs per loop 
list(zip)   5.2 ms ± 252 µs per loop 
numpy array:  28.7 ms ± 1.88 ms per loop 

noti che map() e zip() non restituiscono un elenco più, da qui la conversione esplicita.