Wie zu Sortieren (Liste, Tupel) von Listen/Tupel, indem das element an einem bestimmten index?

Habe ich einige Daten entweder in einer Liste von Listen oder eine Liste von Tupeln, wie diese:

data = [[1,2,3], [4,5,6], [7,8,9]]
data = [(1,2,3), (4,5,6), (7,8,9)]

Und ich möchte sozusagen das 2. element in der Teilmenge. Bedeutung, die Sortierung nach 2,5,8, wo 2 ist aus (1,2,3), 5 ist aus (4,5,6). Was ist der gemeinsame Weg, dies zu tun? Sollte ich speichern Tupel oder Listen in meiner Liste?

In Bezug auf den "Soll ich speichern Tupel oder Listen in meiner Liste?", eine Faustregel ist, die Dinge so unveränderlich wie möglich. Wenn Sie müssen Sie nicht ändern die Teillisten, machen Sie Sie Tupel.

InformationsquelleAutor Stan | 2010-06-25

943
```
sorted_by_second = sorted(data, key=lambda tup: tup[1])
```
oder:
```
data.sort(key=lambda tup: tup[1])  # sorts in place
```
- Irgendeine Idee, wie man es größer, kleiner?
- Hilfe(sortiert). reverse=True.
- mit itemgetter ist schneller und einfacher: key=itemgetter(1) und am Anfang der Datei: from operator import itemgetter
- als für das zweite Beispiel sort hier ist eine Methode List - Objekt in der Python, der erhält eine lambda-Funktion, wie seine key parameter. Sie können es nennen wie tup oder t oder was auch immer Sie mögen und es wird immer noch funktionieren. tup hier gibt index der Liste der Tupel, so 1 bedeutet, dass die Sortierung wird durchgeführt, indem die zweiten Werte der Tupel aus der ursprünglichen Liste (2, 5, 8).
- Ich war leicht skeptisch von der unbegründeten Behauptung, dass "mit itemgetter ist schneller und einfacher." Während ich subjektiv hinsichtlich der intuitiven lambda Ansatz, um einfacher zu sein als die unintuitive itemgetter Klasse itemgetter nicht in der Tat angezeigt werden, schneller zu sein. Ich bin neugierig, warum das so ist. Meinem groben Verdacht, dass ein lambda hat die versteckten Kosten der Erfassung aller lokalen Variablen in einer closure-Kontext, während ein itemgetter Instanz nicht. tl;dr: verwenden Sie Immer itemgetter, denn Schnelligkeit gewinnt.
- Ich habe eine Gründliche benchmark zwischen lambda und itemgetter verwendet in der Art hier. itemgetter ist immer schneller als lambda.
InformationsquelleAutor Stephen
189
```
from operator import itemgetter
data.sort(key=itemgetter(1))
```
- Dies sollte die akzeptierte Antwort. Siehe auch Charlie'N posted Taktungen, demonstrieren die itemgetter - Klasse zum Sortieren 126% schneller im Durchschnitt als die entsprechende lambda Funktion.
- Sie können Sie auch Sortieren, indem Sie eine Vielzahl von Indizes, die hierarchisch, z.B. data.sort(key=itemgetter(3,1))
InformationsquelleAutor manova
44

Ich möchte nur hinzufügen zu Stephen ' s Antwort wenn Sie möchten, zu Sortieren das array von hoch zu niedrig, anderen Weg als in den vorstehenden Ausführungen ist nur hinzuzufügen das sich auf die Zeile:
```
reverse = True
```
und das Ergebnis wird wie folgt sein:
```
data.sort(key=lambda tup: tup[1], reverse=True)
```
InformationsquelleAutor sifoo
33

Für die Sortierung nach mehreren Kriterien, nämlich zum Beispiel durch die zweiten und Dritten Elemente in einem Tupel, lassen
```
data = [(1,2,3),(1,2,1),(1,1,4)]
```
und so definieren Sie eine lambda, liefert ein Tupel, das beschreibt, Priorität, zum Beispiel
```
sorted(data, key=lambda tup: (tup[1],tup[2]) )
[(1, 1, 4), (1, 2, 1), (1, 2, 3)]
```
InformationsquelleAutor elm
27

Stephen ' s Antwort ist der, den ich verwenden würde. Der Vollständigkeit halber, hier ist die DSU (dekorieren-sort-undecorate) Muster-Liste Verstehens:
```
decorated = [(tup[1], tup) for tup in data]
decorated.sort()
undecorated = [tup for second, tup in decorated]
```
Oder, lapidar:
```
[b for a,b in sorted((tup[1], tup) for tup in data)]
```
Wie bereits in der Python-Sortierung HowTo, wurde dies überflüssig, da Python 2.4, wenn die wichtigsten Funktionen verfügbar wurde.
- Also diese Antwort ist hilfreich für Python 2.3-? Gibt es gültige verwendet in mehr-aktuelle Python-Versionen um, die Sie vielleicht näher etwas? Wenn nicht, kein Problem...war gerade vorbei, sah es und die alte Birne bekam zu Buttern einfach nur ein kleines bisschen. Trotzdem, cheers und vielen Dank für diesen Spaziergang wieder in den früheren Tagen von Python.
InformationsquelleAutor tcarobruce

In der Sortierung für eine Liste von Tupeln (<word>, <count>) für count in absteigender Reihenfolge word in alphabetischer Reihenfolge:

data = [
('betty', 1),
('bought', 1),
('a', 1),
('bit', 1),
('of', 1),
('butter', 2),
('but', 1),
('the', 1),
('was', 1),
('bitter', 1)]

Ich benutze diese Methode:

sorted(data, key=lambda tup:(-tup[1], tup[0]))

und es gibt mir das Ergebnis:

[('butter', 2),
('a', 1),
('betty', 1),
('bit', 1),
('bitter', 1),
('bought', 1),
('but', 1),
('of', 1),
('the', 1),
('was', 1)]

InformationsquelleAutor l mingzhi

Ohne lambda:

def sec_elem(s): 
return s[1]

sortiert(data, key=sec_elem)

InformationsquelleAutor Mesco

6

@Stephen 's Antwort ist auf den Punkt! Hier ist ein Beispiel zur besseren Visualisierung

Shout out für die Ready Player One fans! =)
```
>>> gunters = [('2044-04-05', 'parzival'), ('2044-04-07', 'aech'), ('2044-04-06', 'art3mis')]
>>> gunters.sort(key=lambda tup: tup[0])
>>> print gunters
[('2044-04-05', 'parzival'), ('2044-04-06', 'art3mis'), ('2044-04-07', 'aech')]
```
key ist eine Funktion, die aufgerufen wird, verwandeln sich die Sammlung der Gegenstände zum Vergleich.. wie compareTo - Methode in Java.

Den übergebenen parameter-Taste muss etwas sein, dass ist aufrufbar. Hier ist die Verwendung von lambda erstellt eine anonyme Funktion (die ein callable).

Die syntax von lambda-Ausdruck ist das Wort lambda, gefolgt von einer wiederholenden Namen eine einheitliche code-block.

Unten Beispiel, wir Sortieren eine Liste von Tupel, das hält die info-abt-Zeit, bestimmte Ereignis-und Schauspieler-Namen.

Wir Sortieren diese Liste nach Zeitpunkt des Ereignis - das ist das 0. element eines Tupels.

Hinweis - s.sort([cmp[, key[, reverse]]]) sortiert die Elemente von s an Ort

InformationsquelleAutor Rishi

itemgetter() ist etwas schneller als die lambda tup: tup[1], aber der Anstieg ist vergleichsweise Moderat (um 10 bis 25 Prozent).

(IPython Sitzung)

>>> from operator import itemgetter
>>> from numpy.random import randint
>>> values = randint(0, 9, 30000).reshape((10000,3))
>>> tpls = [tuple(values[i,:]) for i in range(len(values))]

>>> tpls[:5]    # display sample from list
[(1, 0, 0), 
 (8, 5, 5), 
 (5, 4, 0), 
 (5, 7, 7), 
 (4, 2, 1)]

>>> sorted(tpls[:5], key=itemgetter(1))    # example sort
[(1, 0, 0), 
 (4, 2, 1), 
 (5, 4, 0), 
 (8, 5, 5), 
 (5, 7, 7)]

>>> %timeit sorted(tpls, key=itemgetter(1))
100 loops, best of 3: 4.89 ms per loop

>>> %timeit sorted(tpls, key=lambda tup: tup[1])
100 loops, best of 3: 6.39 ms per loop

>>> %timeit sorted(tpls, key=(itemgetter(1,0)))
100 loops, best of 3: 16.1 ms per loop

>>> %timeit sorted(tpls, key=lambda tup: (tup[1], tup[0]))
100 loops, best of 3: 17.1 ms per loop

InformationsquelleAutor Walter

-5

Sortieren eines Tupels ist ganz einfach:
```
tuple(sorted(t))
```
InformationsquelleAutor Jayr

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.