Python sorted sortieren: So sortierst du Objekte mit __lt__

Stell dir vor, du schreibst in deiner Ausbildung ein kleines Notenverwaltungsprogramm. Du hast eine Liste mit Studenten-Objekten und willst sie nach Note sortieren - `sorted(studenten)` - und dann knallt dir Python einen `TypeError` um die Ohren: `'<' not supported between instances of 'Student' and 'Student'`. Genau an diesem Punkt stehen viele Azubis, Studenten und Berufseinsteiger zum ersten Mal. Warum? Weil Python bei eigenen Klassen nicht raten kann, wonach sortiert werden soll. Die Lösung heißt `key`-Parameter oder die Dunder-Methode `__lt__` - so klappt das Sortieren mit Python sorted auch bei eigenen Objekten.

Was macht sorted() in Python?

`sorted()` ist eine eingebaute Funktion, die aus jedem Iterablen (z. B. einer Liste) eine neue, sortierte Liste zurückgibt. Das Original bleibt unverändert - anders als bei `listen.sort()`, welches die Liste direkt verändert und `None` zurückgibt.

zahlen = [3, 1, 2]
sortiert = sorted(zahlen)  # [1, 2, 3]
print(zahlen)  # [3, 1, 2] - unveraendert!

Wichtige Parameter:

Python nutzt intern Timsort - einen stabilen Sortieralgorithmus. Stabil bedeutet: Haben zwei Elemente denselben Sortierwert, behalten sie ihre ursprüngliche Reihenfolge. Die Details dazu findest du in der offiziellen Python-Dokumentation zu sorted().

Warum funktioniert sorted() bei eigenen Objekten nicht?

Beim Sortieren vergleicht Python Elemente paarweise mit dem `<`-Operator - und dieser Vergleich muss erst definiert werden. Bei Zahlen und Strings macht Python das automatisch. Bei eigenen Klassen nicht, denn Python weiß schlicht nicht, was "kleiner" für dein Objekt bedeuten soll. Ist ein Student "kleiner", wenn die Note besser ist? Wenn der Name alphabetisch früher kommt? Das musst du entscheiden.

class Student:
    def __init__(self, name, note):
        self.name = name
        self.note = note


studenten = [Student("Anna", 2.3), Student("Ben", 1.7), Student("Clara", 3.0)]

sorted(studenten)  # TypeError: '<' not supported

Wie sortierst du Objekte mit dem key-Parameter?

Mit dem `key`-Parameter sagst du `sorted()`, welches Attribut oder welcher berechnete Wert als Sortierkriterium dient. Python ruft die Funktion für jedes Element auf und sortiert nach den Rückgabewerten. Das ist der schnellste Weg - und meistens auch der beste.

# Sortierung nach Note
nach_note = sorted(studenten, key=lambda s: s.note)

# Sortierung nach Name (alphabetisch)
nach_name = sorted(studenten, key=lambda s: s.name)

# Absteigend nach Note
schlechteste_zuerst = sorted(studenten, key=lambda s: s.note, reverse=True)

Falls dir Lambdas noch nicht geläufig sind: Das ist eine kleine Funktion ohne Namen. `lambda s: s.note` bedeutet nichts anderes als "nimm das Objekt s und gib mir s.note zurück". Mehr dazu in unserem Beitrag zur Python Lambda Funktion.

Merke: Der `key`-Parameter sortiert nicht nach dem Objekt selbst, sondern nach dem Wert, den die Funktion für jedes Objekt zurückgibt.

Du kannst auch nach mehreren Kriterien sortieren, indem der Key ein Tupel zurückgibt - Tupel werden von links nach rechts verglichen:

# Erst nach Note, bei gleicher Note nach Name
ergebnis = sorted(studenten, key=lambda s: (s.note, s.name))

Wie implementierst du __lt__ in der Klasse?

`__lt__` (lt = less than) ist die Dunder-Methode, die Python aufruft, wenn der `<`-Operator auf dein Objekt trifft. Implementierst du sie in deiner Klasse, versteht Python von selbst, wie zwei Objekte zu vergleichen sind - und `sorted()` funktioniert ohne `key`. Der Ausdruck `objekt1 < objekt2` wird intern also zu einem Aufruf von `objekt1.__lt__(objekt2)`, wie die Python-Dokumentation zum Datenmodell beschreibt.

class Student:
    def __init__(self, name, note):
        self.name = name
        self.note = note

    def __lt__(self, other):
        # Ein Student ist "kleiner", wenn seine Note besser ist
        return self.note < other.note

    def __repr__(self):
        return f"Student({self.name}, {self.note})"


studenten = [Student("Anna", 2.3), Student("Ben", 1.7), Student("Clara", 3.0)]

for s in sorted(studenten):
    print(s)
# Student(Ben, 1.7)
# Student(Anna, 2.3)
# Student(Clara, 3.0)

`__lt__` muss `True` oder `False` zurückgeben: `True`, wenn `self` vor `other` einsortiert werden soll. Und Achtung: `sortiert = studenten.sort()` wäre falsch, denn `sort()` gibt `None` zurück. Nimm `sorted()` oder `sort()` ohne Zuweisung.

Merke: `__lt__` implementieren bedeutet, deinem Objekt beizubringen, was "kleiner als" heißt. Danach funktionieren `<` und `sorted()` ohne weiteren Aufwand.

Übrigens: `__lt__` ist nur eine von vielen Dunder-Methoden. Für vollständige Vergleiche gibt es auch `__le__` (`<=`), `__gt__` (`>`), `__ge__` (`>=`) und `__eq__` (`==`). Mehr dazu in unserem Artikel zu Python Dunder Methoden.

Wann nutzt du key, wann __lt__?

Die kurze Antwort: `key` für einmalige oder situationsabhängige Sortierungen, `__lt__` wenn die Klasse eine natürliche Sortierung hat.

Faustregel: Ein `Datum`-Objekt hat eine natürliche Ordnung (früher oder später) - hier passt `__lt__`. Eine `Student`-Klasse könnte nach Name, Note oder Matrikelnummer sortiert werden - hier ist `key` die bessere Wahl.

Praxisbeispiel: Aufgabenliste mit Priorität

Hier ein vollständiges Beispiel, wie es im Job aussehen könnte - eine To-do-Verwaltung, sortiert nach Priorität und Fälligkeit:

class Aufgabe:
    def __init__(self, titel, prioritaet, faellig_in_tagen):
        self.titel = titel
        self.prioritaet = prioritaet  # 1 = hoechste Prioritaet
        self.faellig_in_tagen = faellig_in_tagen

    def __lt__(self, other):
        # Erst nach Prioritaet, dann nach Faelligkeit
        return (self.prioritaet, self.faellig_in_tagen) < (
            other.prioritaet,
            other.faellig_in_tagen,
        )

    def __repr__(self):
        return f"[P{self.prioritaet}] {self.titel} (in {self.faellig_in_tagen} Tagen)"


aufgaben = [
    Aufgabe("Deploy vorbereiten", 1, 3),
    Aufgabe("Doku schreiben", 2, 10),
    Aufgabe("Bugfix Login", 1, 1),
    Aufgabe("Meeting", 3, 1),
]

print("Arbeitsplan:")
for aufgabe in sorted(aufgaben):
    print(aufgabe)
# [P1] Bugfix Login (in 1 Tagen)
# [P1] Deploy vorbereiten (in 3 Tagen)
# [P2] Doku schreiben (in 10 Tagen)
# [P3] Meeting (in 1 Tagen)

Cool daran: Weil `__lt__` hier Tupel vergleicht, bekommst du die Mehrfach-Sortierung gratis. Und weil Python mit `<` jetzt umgehen kann, funktionieren auch `min(aufgaben)` und `max(aufgaben)` automatisch.

Häufige Fehler bei sorted() und __lt__

Fehler 1: `sortiert = liste.sort()`. `sort()` verändert die Liste direkt und gibt `None` zurück - deine Variable ist danach `None`, und der Crash kommt beim nächsten Zugriff. Richtig: `sortiert = sorted(liste)` oder `liste.sort()` ohne Zuweisung.

Fehler 2: `__lt__` gibt nichts oder einen falschen Typ zurück. Vergiss das `return` oder gib z. B. einen String zurück, wirft `sorted()` einen `TypeError`. `__lt__` muss zwingend `True` oder `False` liefern.

Fehler 3: Vergleiche mit `None`. Ist ein Attribut `None` (z. B. eine noch nicht gesetzte Note), wirft `self.note < other.note` einen `TypeError`. Wie du solche Fälle sauber behandelst, zeigen wir im Beitrag zu Python None Optional.

Fehler 4: Nur `__eq__` implementieren und Sortierung erwarten. `__eq__` sagt Python nur, wann zwei Objekte gleich sind - nicht, welches kleiner ist. Für `sorted()` brauchst du zwingend `__lt__`.

Übungstipp

Bau dir eine kleine `Song`-Klasse mit `titel`, `laenge_in_sekunden` und `bewertung`. Sortiere die Liste dreimal: mit `key` nach Länge, mit `key` nach Bewertung (absteigend) und über `__lt__` nach Titel. Nach 15 Minuten spürst du, welcher Ansatz sich wann richtig anfühlt. Bonus: Gib den längsten Song mit `max()` aus - funktioniert nur, wenn du verstanden hast, wo Python Vergleiche braucht.

FAQ: Python sorted sortieren

Was macht sorted() in Python?

`sorted()` nimmt ein Iterable und gibt eine neue, aufsteigend sortierte Liste zurück. Das Original bleibt unverändert. Mit `reverse=True` sortierst du absteigend, mit `key` legst du das Sortierkriterium fest.

Wie sortiere ich Objekte in Python?

Entweder mit dem `key`-Parameter: `sorted(objekte, key=lambda o: o.attribut)` - oder du implementierst `__lt__` in deiner Klasse, sodass Python weiß, wie zwei Objekte zu vergleichen sind. Danach reicht `sorted(objekte)`.

Was ist __lt__ in Python?

`__lt__` ist eine Dunder-Methode ("less than"), die Python beim `<`-Operator aufruft. Sie gibt `True` zurück, wenn `self` kleiner als das Vergleichsobjekt ist. Implementierst du sie, funktionieren `<`, `sorted()`, `min()` und `max()` direkt mit deinen Objekten.

Was ist der Unterschied zwischen sorted() und sort()?

`sorted()` gibt eine neue Liste zurück und lässt das Original unverändert. `sort()` gibt es nur bei Listen, verändert diese direkt und gibt `None` zurück.

Kann ich in Python nach mehreren Kriterien sortieren?

Ja - lass die `key`-Funktion ein Tupel zurückgeben: `key=lambda s: (s.note, s.name)` sortiert erst nach Note, bei Gleichheit nach Name.

Fazit

Objekte in Python mit `sorted()` zu sortieren ist kein Hexenwerk: Der `key`-Parameter deckt 90 % aller Fälle ab, und `__lt__` macht deine Klasse vergleichbar, wenn sie eine natürliche Reihenfolge hat. Der TypeError am Anfang war kein Bug, sondern Python, das dir eine Frage stellt: "Was heißt kleiner für deine Objekte?" - Jetzt kannst du die Antwort geben.

Wenn du bei OOP-Konzepten wie Dunder-Methoden, Listen-Operationen oder generell beim Programmieren-Lernen festhängst: Genau dafür gibt es study-it.education. Wir unterstützen Azubis, Studenten und Berufseinsteiger mit individueller IT-Nachhilfe - auch kurz vor der Prüfung. Schau vorbei und lass uns deine offenen Fragen klären.