Extrahiere das erste Element jeder Unterliste in Python

Frage ich mich, was ist der beste Weg, zu extrahieren, eine erste Element jeder Teilliste in eine Liste von Listen und hängen Sie es an eine neue Liste. Also wenn ich habe:

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

und ich wollen, ziehen Sie a, 1 und x, und erstellen Sie eine separate Liste von denen.

Habe ich versucht:

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

InformationsquelleAutor der Frage konrad | 2014-07-31

list python

110

Mithilfe list comprehension:

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

InformationsquelleAutor der Antwort alecxe

Könnten Sie zip:

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

Oder Python 3, wo zip nicht produzieren eine Liste:

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

Oder,

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

Oder (mein Favorit) verwenden, 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])

InformationsquelleAutor der Antwort dawg

9

Python enthält eine Funktion namens itemgetter Rückkehr das Element an einem bestimmten index in einer Liste:
```
from operator import itemgetter
```
Pass die itemgetter () - Funktion den index des Elements, das Sie abrufen möchten. , Um das erste Element, die Sie verwenden würden, itemgetter(0). Die wichtige Sache zu verstehen ist, dass itemgetter(0) sich selbst gibt, eine Funktion. Wenn Sie übergeben eine Liste mit dieser Funktion bekommen Sie den bestimmten Artikel:
```
itemgetter(0)([10, 20, 30]) # Returns 10
```
Dies ist nützlich, wenn Sie es kombinieren mit map(), die eine Funktion als erstes argument und eine Liste (oder andere durchsuchbar) als zweites argument. Er gibt das Ergebnis des Aufrufs der Funktion auf jedes Objekt in der iterierbar:
```
my_list = [['a', 'b', 'c'], [1, 2, 3], ['x', 'y', 'z']]
list(map(itemgetter(0), my_list)) # Returns ['a', 1, 'x']
```
Beachten Sie, dass anzeigen() liefert ein generator, so das Ergebnis übergeben wird, Liste (), um eine aktuelle Liste. In der Zusammenfassung, Ihre Aufgabe könnte wie folgt vorgenommen:
```
lst2.append(list(map(itemgetter(0), lst)))
```
Dies ist eine alternative Methode, um mit Hilfe einer Liste Verständnis, und welche Methode Sie wählen, hängt stark davon ab, Kontext, Lesbarkeit und Vorlieben.

Mehr info:
https://docs.python.org/3/library/operator.html#operator.itemgetter

InformationsquelleAutor der Antwort Christian Abbott
2

Hatte das gleiche Problem und habe neugierig die Leistungsfähigkeit der jeweiligen Lösung.

Hier ist der %timeit:
```
import numpy as np
lst = [['a','b','c'], [1,2,3], ['x','y','z']]
```
Den ersten numpy-Weg, die Umwandlung der array:
```
%timeit list(np.array(lst).T[0])
4.9 µs ± 163 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
```
Nativ mit list comprehension (wie bereits von @alecxe):
```
%timeit [item[0] for item in lst]
379 ns ± 23.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
```
Anderen einheimischen Art mit zip (wie bereits von @dawg):
```
%timeit list(zip(*lst))[0]
585 ns ± 7.26 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
```
Zweiten numpy-Weg. Auch erklärt @dawg:
```
%timeit list(np.array(lst)[:,0])
4.95 µs ± 179 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
```
Überraschend (zumindest für mich) den nativen Weg mit list comprehension ist die Schnellste und etwa 10x schneller als die numpy-Weg. Laufen die beiden numpy-Möglichkeiten ohne die Letzte list spart etwa einer ľs, die noch in 10x Unterschied.

Beachten Sie, dass, wenn ich umgeben jedes Codefragment durch einen Aufruf lenum sicherzustellen, dass Generatoren laufen bis zum Ende, das timing ist gleich geblieben.

InformationsquelleAutor der Antwort jboi
1

Dein code ist fast richtig. Das einzige Problem ist die Verwendung von list comprehension.

Wenn Sie verwenden wie: (x[0] for x in lst), es gibt ein generator-Objekt.
Wenn Sie verwenden möchten: [x[0] for x in lst], es gibt eine Liste.

Wenn Sie fügen Sie die list-comprehension-Ausgabe einer Liste, die Ausgabe der list-comprehension ist das einzige element der Liste.
```
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']

Bitte lassen Sie mich wissen, wenn ich bin falsch.

InformationsquelleAutor der Antwort Abhishek Mittal

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

print(outputlist)

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

InformationsquelleAutor der Antwort PrabhuPrakash

0

Sagte Sie, dass Sie eine vorhandene Liste. Also ich gehe mit, dass.
```
>>> lst1 = [['a','b','c'], [1,2,3], ['x','y','z']]
>>> lst2 = [1, 2, 3]
```
Jetzt sind Sie, indem der generator-Objekt zu deiner zweiten Liste.
```
>>> lst2.append(item[0] for item in lst)
>>> lst2
[1, 2, 3, <generator object <genexpr> at 0xb74b3554>]
```
Aber Sie wahrscheinlich wollen, dass es eine Liste der ersten Elemente
```
>>> lst2.append([item[0] for item in lst])
>>> lst2
[1, 2, 3, ['a', 1, 'x']]
```
Wir nun angefügt die Liste der ersten Elemente der vorhandenen Liste. Wenn Sie möchten, fügen Sie die Elemente, die themeselves, nicht eine Liste von Ihnen, um die bisherigen, die Sie verwenden würden, Liste.verlängern. In diesem Fall werden wir nicht haben, um sorgen über das hinzufügen von ein generator, denn verlängern, wird dieser generator für jedes Element hinzuzufügen, wird es von dort aus zu erweitern die aktuelle Liste.
```
>>> lst2.extend(item[0] for item in lst)
>>> lst2
[1, 2, 3, 'a', 1, 'x']
```
oder
```
>>> 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

InformationsquelleAutor der Antwort Hendrik

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.