Como extrair os n-ésimos elementos de uma lista de tuplas?

Estou tentando obter os n-ésimos elementos de uma lista de tuplas.

Eu tenho algo como:

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

Desejo extrair apenas os segundos elementos de cada tupla em uma lista:

seconds = [1, 3, 5]

Eu sei que isso poderia ser feito com um forloop, mas queria saber se existe outra maneira, já que tenho milhares de tuplas.

n = 1 # N. . .
[x[n] for x in elements]

Isso também funciona:

zip(*elements)[1]

(Estou postando isso principalmente, para provar a mim mesmo que groquei zip...)

Veja em ação:

>>> help(zip)

Ajuda na função integrada zip no módulo integrado :

fecho eclair(...)

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

Retorne uma lista de tuplas, onde cada tupla contém o i-ésimo elemento de cada uma das sequências de argumento. A lista retornada é truncada em comprimento para o comprimento da menor seqüência de argumentos.

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

Uma coisa legal que aprendi hoje: use *listem argumentos para criar uma lista de parâmetros para uma função ...

Nota : Em Python3, zipretorna um iterador, então use list(zip(*elements))para retornar uma lista de tuplas.

Eu sei que isso poderia ser feito com um FOR, mas queria saber se há outra maneira

Existe outra maneira. Você também pode fazer isso com map e itemgetter :

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

Isso ainda executa um loop internamente e é um pouco mais lento do que a compreensão da lista:

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

Resultados:

Método 1: 1.25699996948
Método 2: 1,46600008011

Se você precisar iterar em uma lista, não há problema em usar um for.

Encontrei isso enquanto procurava a maneira mais rápida de extrair o segundo elemento de uma lista de 2 tuplas. Não é o que eu queria, mas executei o mesmo teste mostrado com um terceiro método mais teste o método 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

Portanto, duas vezes mais rápido se você tiver um par de 2 tuplas apenas para converter para um dicionário e obter os valores.

Tempo para Python 3.6 para extrair o segundo elemento de uma lista de 2 tuplas.

Além disso, adicionou o numpymétodo de array, que é mais simples de ler (mas sem dúvida mais simples do que a compreensão de 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 os horários:

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

Observe que map()e zip()não retorna mais uma lista, daí a conversão explícita.

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

Usando islicee chain.from_iterable:

>>> from itertools import chain, islice
>>> elements = [(1,1,1),(2,3,7),(3,5,10)]
>>> list(chain.from_iterable(islice(item, 1, 2) for item in elements))
[1, 3, 5]

Isso pode ser útil quando você precisa de mais de um elemento:

>>> elements = [(0, 1, 2, 3, 4, 5), 
                (10, 11, 12, 13, 14, 15), 
                (20, 21, 22, 23, 24, 25)]
>>> list(chain.from_iterable(islice(tuple_, 2, 5) for tuple_ in elements))
[2, 3, 4, 12, 13, 14, 22, 23, 24]