So durchsuchen Sie eine Liste von Tupeln in Python

Also ich habe eine Liste von Tupeln wie diese:

[(1,"juca"),(22,"james"),(53,"xuxa"),(44,"delicia")]

Möchte ich diese Liste für ein Tupel, dessen Zahlenwert ist gleich etwas.

So, dass wenn ich search(53) wird es wieder der index-Wert von 2

Gibt es eine einfache Möglichkeit, dies zu tun?

InformationsquelleAutor der Frage hdx | 2010-05-26

76
```
[i for i, v in enumerate(L) if v[0] == 53]
```
InformationsquelleAutor der Antwort Ignacio Vazquez-Abrams

Können Sie eine list comprehension:

>>> a = [(1,"juca"),(22,"james"),(53,"xuxa"),(44,"delicia")]
>>> [x[0] for x in a]
[1, 22, 53, 44]
>>> [x[0] for x in a].index(53)
2

InformationsquelleAutor der Antwort Greg Hewgill

34

tl;dr

Einen generator-Ausdruck ist wahrscheinlich die performante und einfache Lösung für Ihr problem:
```
l = [(1,"juca"),(22,"james"),(53,"xuxa"),(44,"delicia")]

result = next((i for i, v in enumerate(l) if v[0] == 53), None)
# 2
```
Erklärung

Gibt es mehrere Antworten, die eine einfache Lösung auf diese Frage mit Liste Verstehens.
Während diese Antworten sind vollkommen richtig, Sie sind nicht optimal.
Je nach Anwendungsfall kann es erhebliche Vorteile machen ein paar einfache änderungen.

Das Hauptproblem sehe ich mit mit Hilfe einer list comprehension für diesen Anwendungsfall ist, dass die gesamte Liste verarbeitet werden, obwohl Sie nur finden wollen 1 element.

Python bietet eine einfache Konstruktion ist ideal hier. Es heißt generator-Ausdruck. Hier ist ein Beispiel:
```
# Our input list, same as before
l = [(1,"juca"),(22,"james"),(53,"xuxa"),(44,"delicia")]

# Call next on our generator expression.
next((i for i, v in enumerate(l) if v[0] == 53), None)
```
Können wir erwarten, dass diese Methode zum ausführen der im Grunde das gleiche wie Liste Verstehens in unserem trivialen Beispiel, aber was ist, wenn wir arbeiten gerade an einem größeren Datensatz?
Das ist, wo der Vorteil bei der Verwendung der generator-Methode ins Spiel kommt.
Eher als das konstruieren einer neuen Liste, verwenden wir Ihre bestehende Liste als unsere durchsuchbar, und verwenden Sie next() um das erste Element aus unserem generator.

Betrachten können, wie diese Methoden durchführen, die unterschiedlich auf einigen größeren Daten-sets.
Es sind umfangreiche Listen, aus 10000000 + 1 Elemente, mit unserem Ziel am Anfang (am besten) oder am Ende (am schlechtesten).
Wir können bestätigen, dass diese beiden Listen führt gleichermaßen anhand der folgenden Liste Verständnis:

Liste Verstehens

"Worst case"
```
worst_case = ([(False, 'F')] * 10000000) + [(True, 'T')]
print [i for i, v in enumerate(worst_case) if v[0] is True]

# [10000000]
#          2 function calls in 3.885 seconds
#
#    Ordered by: standard name
#
#    ncalls  tottime  percall  cumtime  percall filename:lineno(function)
#         1    3.885    3.885    3.885    3.885 so_lc.py:1(<module>)
#         1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
```
"Im besten Fall"
```
best_case = [(True, 'T')] + ([(False, 'F')] * 10000000)
print [i for i, v in enumerate(best_case) if v[0] is True]

# [0]
#          2 function calls in 3.864 seconds
#
#    Ordered by: standard name
#
#    ncalls  tottime  percall  cumtime  percall filename:lineno(function)
#         1    3.864    3.864    3.864    3.864 so_lc.py:1(<module>)
#         1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
```
Generator-Ausdrücke

Hier ist meine Hypothese für Generatoren: wir werden sehen, dass Generatoren deutlich besser, im besten Fall, aber auch im schlimmsten Fall.
Dieser performance-Gewinn ist vor allem aufgrund der Tatsache, dass der generator ausgewertet wird träge, D. H. es wird nur berechnen, was erforderlich ist, um die Ausbeute einen Wert.

Schlimmsten Fall
```
# 10000000
#          5 function calls in 1.733 seconds
#
#    Ordered by: standard name
#
#    ncalls  tottime  percall  cumtime  percall filename:lineno(function)
#         2    1.455    0.727    1.455    0.727 so_lc.py:10(<genexpr>)
#         1    0.278    0.278    1.733    1.733 so_lc.py:9(<module>)
#         1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
#         1    0.000    0.000    1.455    1.455 {next}
```
Besten Fall
```
best_case  = [(True, 'T')] + ([(False, 'F')] * 10000000)
print next((i for i, v in enumerate(best_case) if v[0] == True), None)

# 0
#          5 function calls in 0.316 seconds
#
#    Ordered by: standard name
#
#    ncalls  tottime  percall  cumtime  percall filename:lineno(function)
#         1    0.316    0.316    0.316    0.316 so_lc.py:6(<module>)
#         2    0.000    0.000    0.000    0.000 so_lc.py:7(<genexpr>)
#         1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
#         1    0.000    0.000    0.000    0.000 {next}
```
WAS?! Im besten Fall weggeblasen der Liste Verstehens, aber ich hatte nicht erwartet, das unsere schlimmsten Fall übertreffen die Liste Verstehens so weit.
Wie ist das? Ehrlich gesagt, ich könnte nur spekulieren, ohne weitere Forschung.

Nehmen alles mit einem Körnchen Salz, ich nicht ausgeführt haben robuste Profilierung hier, nur einige sehr grundlegende Tests. Dies sollte ausreichend sein, um zu schätzen, dass ein generator-Ausdruck ist performant für diese Art von Liste suchen.

Beachten Sie, dass dies alle grundlegenden, eingebauten python. Wir brauchen nicht zu importieren, alles, oder verwenden Sie keine Bibliotheken.

Sah ich erstmals diese Technik für die Suche in der Udacity cs212 natürlich mit Peter Norvig.

InformationsquelleAutor der Antwort Jon Surrell
25

Ihre Tupel sind im Grunde der Schlüssel-Wert-Paaren--ein python - dict - so:
```
l = [(1,"juca"),(22,"james"),(53,"xuxa"),(44,"delicia")]
val = dict(l)[53]
```
Bearbeiten -- aha, Sie sagen, Sie wollen, dass der index-Wert (53, "xuxa"). Wenn dies wirklichwas Sie wollen, Sie haben zu Durchlaufen, die auf der ursprünglichen Liste, oder vielleicht eine kompliziertere Wörterbuch:
```
d = dict((n,i) for (i,n) in enumerate(e[0] for e in l))
idx = d[53]
```
InformationsquelleAutor der Antwort Andrew Jaffe
10

Hmm... naja, die einfache Möglichkeit, die mir einfällt, ist, es zu konvertieren, um ein dict
```
d = dict(thelist)
```
und Zugang d[53].

BEARBEITEN: Oops, falsch gelesen deine Frage das erste mal. Es klingt wie Sie wirklich wollen, um den index, wo eine bestimmte Anzahl gespeichert ist. In diesem Fall versuchen
```
dict((t[0], i) for i, t in enumerate(thelist))
```
statt ein einfaches, altes dict Konvertierung. Dann d[53] 2.

InformationsquelleAutor der Antwort David Z
6

Angenommen, die Liste kann lang sein, und die zahlen wiederholen können, sollten Sie die SortedList Typ aus der Python-Modul sortedcontainers. Die SortedList-Typ wird automatisch beibehalten der Tupel in der Reihenfolge von Zahl und ermöglichen die schnelle Suche.

Beispiel:
```
from sortedcontainers import SortedList
sl = SortedList([(1,"juca"),(22,"james"),(53,"xuxa"),(44,"delicia")])

# Get the index of 53:

index = sl.bisect((53,))

# With the index, get the tuple:

tup = sl[index]
```
Diese arbeiten viel schneller als die Liste Verständnis Vorschlag durch eine binäre Suche. Wörterbuch Vorschlag wird noch schneller aber wird nicht funktionieren, wenn es doppelte zahlen mit verschiedenen Saiten.

Wenn es doppelte zahlen mit verschiedenen Saiten dann brauchen Sie, um einen Schritt mehr:
```
end = sl.bisect((53 + 1,))

results = sl[index:end]
```
Durch winkelhalbierenden 54, finden wir die end-index für unsere Scheibe. Diese werden deutlich schneller auf langen Listen, wie Sie im Vergleich mit den akzeptierten Antworten.

InformationsquelleAutor der Antwort GrantJ
1

Nur ein weiterer Weg.
```
zip(*a)[0].index(53)
```
InformationsquelleAutor der Antwort RussW
-1

[k for k,v in l, wenn v =='delicia']

hier ist l die Liste der Tupel-[(1,"juca"),(22,"james"),(53,"xuxa"),(44,"delicia")]

Und statt der Umwandlung in ein dict, sind wir mit llist Verständnis.

*Key* in Key,Value in list, where value = **delicia**

InformationsquelleAutor der Antwort Mantej Singh

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

tl;dr

Erklärung

Liste Verstehens

"Worst case"

"Im besten Fall"

Generator-Ausdrücke

Schlimmsten Fall

Besten Fall