Extraer primer elemento de cada sublista.

Me pregunto cuál es la mejor manera de extraer el primer elemento de cada lista secundaria en una lista de listas y adjuntarlo a una nueva lista. Así que si tengo:

lst = [[a,b,c], [1,2,3], [x,y,z]] 

y quiero sacar a, 1 y x y crear una lista separada de ellos.

Lo intenté:

 lst2.append(x[0] for x in lst) 

Usando la lista de comprensión :

 >>> lst = [['a','b','c'], [1,2,3], ['x','y','z']] >>> lst2 = [item[0] for item in lst] >>> lst2 ['a', 1, 'x'] 

Podrías usar zip:

 >>> lst=[[1,2,3],[11,12,13],[21,22,23]] >>> zip(*lst)[0] (1, 11, 21) 

O, Python 3 donde zip no produce una lista:

 >>> list(zip(*lst))[0] (1, 11, 21) 

O,

 >>> next(zip(*lst)) (1, 11, 21) 

O, (mi favorito) use numpy:

 >>> import numpy as np >>> a=np.array([[1,2,3],[11,12,13],[21,22,23]]) >>> a array([[ 1, 2, 3], [11, 12, 13], [21, 22, 23]]) >>> a[:,0] array([ 1, 11, 21]) 

Python incluye una función llamada itemgetter para devolver el elemento a un índice específico en una lista:

 from operator import itemgetter 

Pase la función itemgetter () el índice del elemento que desea recuperar. Para recuperar el primer elemento, usaría itemgetter (0). Lo importante a entender es que el itemgetter (0) devuelve una función. Si pasa una lista a esa función, obtendrá el elemento específico:

 itemgetter(0)([10, 20, 30]) # Returns 10 

Esto es útil cuando lo combinas con map (), que toma una función como primer argumento y una lista (o cualquier otro iterable) como segundo argumento. Devuelve el resultado de llamar a la función en cada objeto en el iterable:

 my_list = [['a', 'b', 'c'], [1, 2, 3], ['x', 'y', 'z']] list(map(itemgetter(0), my_list)) # Returns ['a', 1, 'x'] 

Tenga en cuenta que map () devuelve un generador, por lo que el resultado se pasa a list () para obtener una lista real. En resumen, tu tarea se podría hacer así:

 lst2.append(list(map(itemgetter(0), lst))) 

Este es un método alternativo al uso de una lista de comprensión, y el método que elija depende en gran medida del contexto, la legibilidad y la preferencia.

Más información: https://docs.python.org/3/library/operator.html#operator.itemgetter

Tenía el mismo problema y sentía curiosidad por el rendimiento de cada solución.

Aquí está el %timeit :

 import numpy as np lst = [['a','b','c'], [1,2,3], ['x','y','z']] 

El primer camino numérico, transformando la matriz:

 %timeit list(np.array(lst).T[0]) 4.9 µs ± 163 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) 

Completamente nativo utilizando la comprensión de lista (como se explica por @alecxe):

 %timeit [item[0] for item in lst] 379 ns ± 23.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) 

Otra forma nativa usando zip (como se explica por @dawg):

 %timeit list(zip(*lst))[0] 585 ns ± 7.26 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) 

Segundo camino de numpy. También explicado por @dawg:

 %timeit list(np.array(lst)[:,0]) 4.95 µs ± 179 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) 

Sorprendentemente (bueno, al menos para mí) la forma nativa que usa la comprensión de lista es la más rápida y aproximadamente 10 veces más rápida que la forma numpy. La ejecución de los dos métodos numéricos sin la list final guarda alrededor de un µs, que aún se encuentra en la diferencia de 10x.

Tenga en cuenta que, cuando envolví cada fragmento de código con una llamada a len , para garantizar que los generadores funcionen hasta el final, el tiempo se mantuvo igual.

Su código es casi correcto. El único problema es el uso de la lista de comprensión.

Si usa como: (x [0] para x en lst), devuelve un objeto generador. Si usa como: [x [0] para x en lst], devuelve una lista.

Cuando agrega la salida de comprensión de lista a una lista, la salida de comprensión de lista es el único elemento de la lista.

 lst = [["a","b","c"], [1,2,3], ["x","y","z"]] lst2 = [] lst2.append([x[0] for x in lst]) print lst2[0] 

lst2 = [[‘a’, 1, ‘x’]]

lst2 [0] = [‘a’, 1, ‘x’]

Por favor, hágamelo saber si estoy incorrecto.

 lst = [['a','b','c'], [1,2,3], ['x','y','z']] outputlist = [] for values in lst: outputlist.append(values[0]) print(outputlist) 

Salida: ['a', 1, 'x']

Usted dijo que tiene una lista existente. Así que voy a ir con eso.

 >>> lst1 = [['a','b','c'], [1,2,3], ['x','y','z']] >>> lst2 = [1, 2, 3] 

En este momento está agregando el objeto generador a su segunda lista.

 >>> lst2.append(item[0] for item in lst) >>> lst2 [1, 2, 3,  at 0xb74b3554>] 

Pero probablemente quieras que sea una lista de los primeros artículos.

 >>> lst2.append([item[0] for item in lst]) >>> lst2 [1, 2, 3, ['a', 1, 'x']] 

Ahora agregamos la lista de los primeros artículos a la lista existente. Si desea agregar los elementos temaselves, no una lista de ellos, a los existentes, use list.extend. En ese caso, no tenemos que preocuparnos por agregar un generador, porque extendirá el uso de ese generador para agregar cada elemento que recibe de ahí, para extender la lista actual.

 >>> lst2.extend(item[0] for item in lst) >>> lst2 [1, 2, 3, 'a', 1, 'x'] 

o

 >>> lst2 + [x[0] for x in lst] [1, 2, 3, 'a', 1, 'x'] >>> lst2 [1, 2, 3] 

https://docs.python.org/3.4/tutorial/datastructures.html#more-on-lists https://docs.python.org/3.4/tutorial/datastructures.html#list-comprehensions