Listen und Tupel in Python

Eine Liste speichert Werte in einer gewählten Reihenfolge. Schreibe die Elemente zwischen eckige Klammern und setze Kommas dazwischen. Jedes Element hat eine Position, sodass wiederholte Werte dennoch getrennte Plätze belegen.

Eine Liste erstellen und ihre Länge bestimmen

scores = [88, 92, 75]
print(scores)
print(len(scores))

Ausgabe:

[88, 92, 75]
3

len() zählt Elemente, nicht den größten Wert oder die letzte Position. Listen können gemischte Datentypen enthalten, wie in [3, "three", 3.0, True], auch wenn es die Verarbeitung meist erleichtert, zusammengehörige Daten gemeinsam zu speichern. Sowohl [] als auch list() erstellen eine leere Liste. Ihre Länge ist 0, und sie kann wachsen, während das Programm Werte sammelt.

list() kann auch die Elemente eines iterierbaren Objekts sammeln, also eines Objekts, das eine for-Schleife durchlaufen kann. list(range(4)) ergibt [0, 1, 2, 3]. list("cat") ergibt ['c', 'a', 't']: Die Zeichenkette liefert jeweils ein Zeichen. Das Ergebnis ist eine neue Liste.

Positionen ab null zählen

Ein Index bezeichnet eine Position. Python beginnt bei 0, daher haben die drei Punktzahlen die Indizes 0, 1 und 2.

Negative Indizes zählen vom Ende aus rückwärts. Bei einer Liste der Länge n reichen die gültigen Indizes von -n bis n - 1. Das letzte Element ist scores[len(scores) - 1] oder einfacher scores[-1]. -0 ist weiterhin 0; es bezeichnet nicht die letzte Position.

Einen ungültigen Index erkennen

scores[3] löst IndexError aus, weil kein viertes Element existiert. scores[len(scores)] macht denselben Fehler: Die Anzahl ist um eins größer als der letzte nicht negative Index. Eine leere Liste hat keinen gültigen Elementindex, auch nicht -1.

Ein Listenindex muss eine ganze Zahl sein, keine Gleitkommazahl. scores[1.0] löst TypeError aus, obwohl 1,0 einen ganzzahligen Wert hat. / erzeugt eine Gleitkommazahl, daher schlägt auch scores[len(scores) / 2] fehl. Bei dieser Liste mit drei Elementen erzeugt len(scores) // 2 die ganze Zahl 1, und scores[1] ist 92.

Prüfen, ob ein Wert vorkommt

Die Zugehörigkeitsprüfung prüft Werte, keine Positionen:

colors = ["red", "green"]
print("green" in colors)
print("Green" in colors)
print("blue" not in colors)

Ausgabe:

True
False
True

in und not in geben boolesche Werte zurück und funktionieren auch bei leeren Listen. Zeichenkettenvergleiche beachten die Groß- und Kleinschreibung, daher stimmen "Green" und "green" nicht überein. Eine Zugehörigkeitsprüfung ist vor einer Operation nützlich, die einen vorhandenen Wert voraussetzt, etwa beim Entfernen oder beim Ermitteln seiner Position.

Ein Ausschnitt wählt eine Folge von Elementen aus und gibt eine neue Sequenz zurück. Bei einer Liste ist das Ergebnis eine weitere Liste, auch wenn sie nur ein Element oder keine Elemente enthält.

Den Startwert einschließen und die Endgrenze ausschließen

letters = ["a", "b", "c", "d", "e", "f"]
print(letters[1:4])

Ausgabe:

['b', 'c', 'd']

Ausgewählt werden die Positionen 1, 2 und 3. Position 4 ist die ausgeschlossene Endgrenze, daher bleibt 'e' außen vor. Bei Schrittweite 1 und Grenzen, die 0 <= start <= stop <= len(letters) erfüllen, ist die Anzahl der ausgewählten Elemente stop - start. Hier ist sie 3. letters[4:2] ergibt [], weil ein vorwärts gerichteter Ausschnitt eine frühere Endgrenze nicht erreichen kann.

Eine Grenze weglassen

Negative Grenzen zählen wie negative Indizes vom Ende aus. letters[:n] und letters[n:] teilen die Liste an einer Grenze. Das Zusammenfügen dieser beiden Ausschnitte stellt ihren Inhalt in der ursprünglichen Reihenfolge wieder her.

Die Schrittweite steuern

Die vollständige Form ist values[start:stop:step]. Bei Schrittweite 2 wird eine Position ausgewählt, eine übersprungen und die nächste ausgewählt. letters[::2] ergibt ['a', 'c', 'e'], während letters[1::2] gleich ['b', 'd', 'f'] ist.

Eine negative Schrittweite läuft rückwärts. letters[::-1] beginnt beim letzten Element und ergibt ['f', 'e', 'd', 'c', 'b', 'a']. Bei einem begrenzten rückwärts gerichteten Ausschnitt durchläuft letters[4:1:-1] die Indizes 4, 3 und 2 und ergibt ['e', 'd', 'c']; die Endgrenze bleibt ausgeschlossen. Eine Schrittweite von 0 löst ValueError aus, weil damit keine andere Position erreicht werden kann.

Eine Grenze von einer Position unterscheiden

Ausschnittsgrenzen dürfen über beide Enden hinausreichen. Python begrenzt sie auf die Enden: letters[4:100] ist ['e', 'f'] und letters[10:] ist []. Diese Ausschnitte lösen keinen IndexError aus. Das Lesen des einzelnen Elements letters[10] dagegen schon.

letters[2] ist die Zeichenkette 'c'. letters[2:3] ist die Liste ['c']. Der Doppelpunkt verändert die Art des Ergebnisses. Das ist wichtig, wenn späterer Code eine Zeichenkette oder eine Liste erwartet.

Mit dem Ergebnis arbeiten

Nach first_three = letters[:3] ändert die Zuweisung first_three[0] = "z" nur diese neue äußere Liste; letters[0] bleibt 'a'. Ein vollständiger Ausschnitt ist eine flache Kopie, sodass verschachtelte veränderliche Elemente weiterhin gemeinsam referenziert werden können.

Für Zeichenketten und Tupel gelten dieselben Regeln für Grenzen und Schrittweite. Das Ergebnis behält den Datentyp der ursprünglichen Sequenz: "python"[1:4] ergibt 'yth' und (10, 20, 30)[1:] ergibt (20, 30).

Listen unterstützen Operatoren zum Erstellen von Sequenzen und Funktionen zum Zusammenfassen ihrer Werte. Prüfe, ob eine Operation eine neue Liste erstellt, eine Zahl erzeugt oder Text zurückgibt: Diese Ergebnisse erfüllen unterschiedliche Aufgaben.

Listen verbinden oder wiederholen

+ verbindet zwei Listen und erstellt eine neue Liste. [1, 2] + [3] ergibt [1, 2, 3], ohne eine der beiden Eingaben zu verändern. Beide Operanden müssen Listen sein: [1, 2] + 3 löst TypeError aus. Setze bei der Verwendung von + einen einzelnen zusätzlichen Wert in eine Liste mit einem Element.

* wiederholt die Sequenz. [0] * 4 ergibt [0, 0, 0, 0] und ["ab", "cd"] * 2 ergibt ['ab', 'cd', 'ab', 'cd']. Der Operator wiederholt Elemente, nicht die Zeichen innerhalb jeder Zeichenkette. Eine Wiederholungsanzahl von null oder weniger ergibt []. counts = [0] * 7 stellt sieben Zähler für den Anfang bereit. Das Wiederholen einer inneren Liste führt dazu, dass sie an mehreren Positionen referenziert wird. Das ist wichtig, wenn diese Zeilen später verändert werden.

Summe, Extremwerte und arithmetisches Mittel

sum() addiert Zahlen. Die Funktion fügt keine Zeichenketten zusammen; sum(["a", "b"]) löst TypeError aus. min() und max() finden das kleinste und das größte Element. Die Elemente müssen daher miteinander vergleichbar sein. Listen, die nur Zeichenketten enthalten, funktionieren: max(["pear", "apple"]) ergibt aufgrund der Zeichen für Zeichen bestimmten Reihenfolge den Wert 'pear'. Eine leere Liste hat weder Minimum noch Maximum und löst bei beiden Aufrufen ValueError aus.

Das arithmetische Mittel ist die Summe geteilt durch die Anzahl der Elemente:

temps = [18.5, 21.0, 19.5, 23.0]
if temps:
    total = sum(temps)
    mean = total / len(temps)
    print(total, mean)

Ausgabe:

82.0 20.5

Die Bedingung funktioniert, weil leere Listen als falsch und nicht leere Listen als wahr ausgewertet werden. Ohne die Schutzbedingung würde die Berechnung des arithmetischen Mittels von [] durch null dividieren und ZeroDivisionError auslösen. Entscheide, was das Programm tun soll, wenn keine Messwerte vorliegen, etwa None zurückgeben.

Sequenzen in ihrer Reihenfolge vergleichen

== prüft, ob gleiche Elemente an gleichen Positionen stehen. [1, 2, 3] == [1, 2, 3] ist True; [1, 2, 3] == [3, 2, 1] ist False.

Vergleiche bei < und > von links und stoppe beim ersten ungleichen Paar. [2, 9] < [3, 0] ist True, weil 2 kleiner als 3 ist. Die 9 und die 0 entscheiden nichts. Wenn eine Liste den Anfang einer anderen bildet, kommt die kürzere zuerst: [2] < [2, 0] ist True.

Zwischen Text und Listen wechseln

colors = "red,green,blue".split(",")
print(colors)
print(", ".join(["red", "green"]))

Ausgabe:

['red', 'green', 'blue']
red, green

split() teilt eine Zeichenkette an ihrem Trennzeichen. join() wird auf dem Trennzeichen aufgerufen und setzt es zwischen die übergebenen Zeichenketten. Jedes Element muss eine Zeichenkette sein. Um Zahlen zusammenzufügen, erstelle zunächst eine Liste ihrer str()-Ergebnisse; die direkte Übergabe von [1, 2] an join() löst TypeError aus.

Listen sind veränderlich: Ein Programm kann ihren Inhalt nach der Erstellung ändern. Eine Methode gehört zu einem Objekt und wird mit einem Punkt aufgerufen, wie in cart.append("eggs"). Ihre Wirkung auf die Liste und ihr Rückgabewert sind zwei verschiedene Dinge.

Ein Element oder mehrere hinzufügen

cart = ["milk"]
cart.append("eggs")
cart.extend(["tea", "jam"])
print(cart)

Ausgabe:

['milk', 'eggs', 'tea', 'jam']

append(x) fügt genau ein Element am Ende hinzu. Ist x eine Liste, wird diese ganze Liste zu einem verschachtelten Element. Ausgehend von ['milk', 'eggs'] erzeugt cart.append(["tea", "jam"]) die Liste ['milk', 'eggs', ['tea', 'jam']] der Länge 3.

extend(iterable) fügt die vom iterierbaren Objekt gelieferten Elemente einzeln hinzu. Das Erweitern mit ["tea", "jam"] bringt den Einkaufswagen auf die Länge 4. Das Erweitern mit "ab" fügt 'a' und 'b' einzeln hinzu; hänge die Zeichenkette an, um 'ab' als ein Element zu behalten.

insert(i, x) fügt ein Element vor der aktuellen Position i ein. Nach nums = [10, 30] und nums.insert(1, 20) ist die Liste [10, 20, 30]. Spätere Elemente werden nach rechts verschoben. insert(0, x) fügt vorne ein; ein Index hinter dem Ende fügt am Ende ein, ohne einen Indexfehler auszulösen.

Nach Position oder Wert entfernen

Bei nums = [10, 20, 30] speichert last = nums.pop() den Wert 30 und lässt [10, 20] zurück. nums.pop(0) gibt danach 10 zurück und lässt [20] zurück. Bei einer leeren Liste oder ungültigen Position löst pop() IndexError aus.

remove() erhält einen Wert. Bei pets = ["cat", "dog", "cat"] lässt pets.remove("cat") die Liste ['dog', 'cat'] zurück. Nur der erste Treffer verschwindet. Fehlt der Wert, löst remove() ValueError aus. Verwende eine Zugehörigkeitsprüfung, wenn er fehlen könnte. Um jedes 'cat' zu entfernen, verwende:

while "cat" in pets:
    pets.remove("cat")

Bei [5, 0, 7] entfernt remove(0) den Wert 0 und lässt [5, 7] zurück; pop(0) entfernt den Wert an Position 0 und ergibt [0, 7]. Die Bedeutung des Arguments bestimmt die Methode.

del kann einen Bereich löschen: Aus [5, 6, 7, 8] lässt del nums[1] die Liste [5, 7, 8] zurück und del nums[0:2] danach [8]. clear() lässt die bestehende Liste leer zurück.

Den Rückgabewert richtig einordnen

append, extend, insert, remove und clear geben None zurück. Schreibe cart.append("tea") in eine eigene Zeile. Schreibst du cart = cart.append("tea"), referenziert cart den Wert None; ein späteres cart.append("jam") löst AttributeError aus. Speichere ein Methodenergebnis nur, wenn es einen Wert liefert, den das Programm benötigt, wie bei last = cart.pop().

Einen Wert zu finden, ihn zu zählen und ihn zu ersetzen sind unterschiedliche Operationen. Verwende eine Zugehörigkeitsprüfung, wenn du ein Ja-oder-Nein-Ergebnis brauchst, eine Suchmethode, wenn du eine Position brauchst, und eine Zuweisung, wenn du die Liste verändern möchtest.

Die erste passende Position finden

days = ["Mon", "Tue", "Wed", "Tue"]
print(days.index("Tue"))
print(days.index("Tue", 2))
print(days.count("Tue"))
print(days.count("Sun"))

Ausgabe:

1
3
2
0

index(x) gibt die erste Position zurück, die einen Wert gleich x enthält. Das optionale Startargument teilt Python mit, wo die Suche beginnen soll. days.index("Tue", 2) überspringt den Treffer an Position 1 und findet den an Position 3. Das Ergebnis bleibt ein Index in der ganzen Liste und zählt nicht ab dem neuen Startpunkt.

index() löst ValueError aus, wenn der Wert fehlt. Listen haben keine find()-Methode, die -1 zurückgibt. Wenn ein Wert fehlen könnte, prüfe zuerst die Zugehörigkeit:

if "Sun" in days:
    position = days.index("Sun")
    print(position)

Dieser Code gibt nichts aus, weil 'Sun' fehlt. count(x) kann ohne diese Schutzbedingung verwendet werden: Die Methode gibt 0 zurück, wenn es keine Treffer gibt. Diese Operationen prüfen auf Gleichheit, daher ist [1, 2.0].count(2) gleich 1. Bei Text wird weiterhin die Groß- und Kleinschreibung beachtet: 'tue' ist nicht gleich 'Tue'.

Ein vorhandenes Element ersetzen

prices = [4.5, 3.0, 7.25]
prices[1] = 3.5
print(prices)

Ausgabe:

[4.5, 3.5, 7.25]

Der alte zweite Wert wird überschrieben und die Länge bleibt 3. Der Index muss existieren: prices[3] = 1.0 löst IndexError aus. Um am Ende etwas hinzuzufügen, verwende append().

Das Ersetzen nutzt einen vorhandenen Platz. Das Einfügen erstellt einen zusätzlichen Platz vor der ausgewählten Position.

Einen Bereich durch Ausschnittszuweisung ersetzen

nums = [1, 2, 3, 4, 5]
nums[1:3] = [20, 30, 40]
print(nums)
nums[0:2] = []
print(nums)

Ausgabe:

[1, 20, 30, 40, 4, 5]
[30, 40, 4, 5]

Die erste Zuweisung ersetzt die zwei Elemente an den Indizes 1 und 2 durch drei neue Elemente und verlängert die Liste um eins. Ein gewöhnlicher zusammenhängender Ausschnitt kann durch eine kürzere oder längere Sequenz ersetzt werden. Die Zuweisung von [] löscht den ausgewählten Bereich. Dies verändert die ursprüngliche Liste; es ist etwas anderes, als einen Ausschnitt in eine neue Variable einzulesen.

Text durch Erstellen von neuem Text bearbeiten

Eine Zeichenkette ist unveränderlich, daher löst word = "cat" gefolgt von word[0] = "b" TypeError aus. Erstelle mit word = "b" + word[1:] eine neue Zeichenkette oder erstelle eine Liste von Zeichen, ändere sie und füge sie zusammen:

letters = list("cat")
letters[0] = "b"
word = "".join(letters)
print(word)

Ausgabe:

bat

Eine Schleife kann die Werte einer Liste, ihre Positionen oder beides nutzen. Wähle die Form, die liefert, was der Schleifenkörper benötigt. Prüfe bei einer Änderung der Liste auch, ob die Anweisung ein Element verändert oder nur einen lokalen Namen neu bindet.

Elemente direkt verwenden

for name in ["Ana", "Ben"]:
    print("Hi", name)

Ausgabe:

Hi Ana
Hi Ben

Die Schleife durchläuft jedes Element der Reihe nach. Bei jedem Durchlauf referenziert name das aktuelle Element. Weist du name einen anderen Wert zu, ersetzt das dieses Element in der Liste nicht. In for r in readings: r = 0 ändert sich nur der Name r.

Positionen zum Ersetzen von Elementen verwenden

readings = [3, -1, 4, -5]
for i in range(len(readings)):
    if readings[i] < 0:
        readings[i] = 0
print(readings)

Ausgabe:

[3, 0, 4, 0]

range(len(readings)) liefert 0, 1, 2 und 3. Bei Index 1 ist die Bedingung wahr, daher ersetzt die Elementzuweisung -1. Bei Index 3 ersetzt sie -5. Positive Messwerte behalten ihre Werte. Mit range(len(readings) + 1) würde auch der nicht vorhandene Index 4 erreicht.

Position und Element zusammen erhalten

enumerate() liefert Paare. Entpacke jedes Paar im Kopf der Schleife:

for i, name in enumerate(["Ana", "Ben"]):
    print(i, name)

Ausgabe:

0 Ana
1 Ben

enumerate(names, start=1) liefert für eine nummerierte Anzeige Beschriftungen ab 1. Diese Beschriftungen sind nicht mehr die bei null beginnenden Indizes der Liste. Um die Liste vom letzten bis zum ersten Element zu durchlaufen, ohne sie zu verändern, verwende for item in reversed(names):. Für rückwärts laufende Indizes verwende range(len(names) - 1, -1, -1); eine Liste mit drei Elementen ergibt 2, 1, 0.

Zwei Listen paarweise verknüpfen

names = ["Ana", "Ben"]
scores = [90, 85]
for name, score in zip(names, scores):
    print(name, score)

Ausgabe:

Ana 90
Ben 85

zip() bildet Paare aus Elementen an entsprechenden Positionen und stoppt bei der kürzeren Eingabe. Wenn jeder Datensatz wichtig ist, prüfe vorher die Längen, bevor du dich darauf verlässt; ein letzter Name ohne Gegenstück wird sonst übersprungen.

Einen Index mit while steuern

Eine while-Schleife braucht einen Startindex, eine Prüfung der Grenze und eine Schrittweite:

i = 0
while i < len(readings):
    print(readings[i])
    i += 1

Wird das Inkrement vergessen, endet diese Schleife nicht. Mit <= wird len(readings) erreicht und IndexError ausgelöst.

Das Verschieben von Elementen während einer for-Schleife vermeiden

Das Entfernen von Elementen verändert die Positionen der nachfolgenden Elemente. Entfernst du bei [1, 2, 2, 3] beim Durchlaufen derselben Liste jede angetroffene 2, bleibt [1, 2, 3] übrig: Die zweite 2 rückt an die gerade durchlaufene Position. Durchlaufe nums[:], wenn die ursprüngliche Liste durch das Entfernen verändert werden muss, oder erstelle eine neue Liste mit den Elementen, die bleiben sollen. Auch das Hinzufügen von Elementen zu der durchlaufenen Liste kann zu unerwartetem Verhalten der Schleife führen.

Viele Listenprobleme nutzen einige wiederverwendbare Schleifenmuster. Entscheide, welches Ergebnis das Programm braucht, richte es vor der Schleife ein und aktualisiere es, sobald jedes Element ankommt.

Eine Summe oder Anzahl aufsummieren

sales = [120, 75, 205, 50]
total = 0
for sale in sales:
    total += sale
print(total)

Ausgabe:

450

Die laufende Summe nimmt die Werte 120, 195, 400 und 450 an. Stünde total = 0 innerhalb der Schleife, würde bei jedem Durchlauf die vorherige Arbeit gelöscht. sum(sales) berechnet diese Summe direkt.

Ein Zähler addiert für jedes passende Element 1, nicht den Wert des Elements:

scores = [72, 45, 60, 88, 59]
passed = 0
for score in scores:
    if score >= 60:
        passed += 1
print(passed)

Die Ausgabe ist 3: 72, 60 und 88 erfüllen die Bedingung. > 60 würde 2 ergeben, weil genau 60 ausgeschlossen wird. Achte darauf, dass die Formulierung des Schwellenwerts und der Vergleich übereinstimmen.

Einen Extremwert finden

Initialisiere bei einer nicht leeren Liste ein bisheriges Maximum mit einem tatsächlichen Element:

temps = [-3, -8, -1, -5]
highest = temps[0]
for temp in temps[1:]:
    if temp > highest:
        highest = temp
print(highest)

Die Ausgabe ist -1. Ein Start bei 0 würde fälschlich 0 beibehalten, weil alle Messwerte kleiner sind. Verwende <, um das Minimum zu finden, oder nutze die eingebauten Funktionen min() und max(). Prüfe vor dem Zugriff auf das erste Element, ob die Liste leer ist.

Beim ersten Treffer stoppen

values = [4, 0, -2, 5, -7]
position = -1
for i, value in enumerate(values):
    if value < 0:
        position = i
        break
print(position)

Die Ausgabe ist 2. -1 ist ein gewähltes Signal für einen fehlenden Treffer. Verwende es nur dann als Index, wenn die Suche erfolgreich war, denn es ist auch ein gültiger Index für das letzte Element. break erhält die erste passende Position. Ohne diese Anweisung würden spätere Treffer das Ergebnis überschreiben.

x in values prüft auf einen bestimmten exakten Wert, und values.index(x) findet seine erste Position. Eine Bedingung wie „ist negativ“ braucht eine bedingungsbasierte Suche wie die Schleife oben.

Filtern oder transformieren

Ein Filter behält ausgewählte ursprüngliche Elemente:

passing = []
for score in scores:
    if score >= 60:
        passing.append(score)
print(passing)

Die Ausgabe ist [72, 60, 88]; scores behält alle fünf Elemente. Eine Transformation berechnet aus jedem ursprünglichen Element ein neues:

nums = []
for text in ["3", "14", "15"]:
    nums.append(int(text))
print(nums, sum(nums))

Die Ausgabe ist [3, 14, 15] 32. Die Umwandlung geschieht vor der Addition; das Summieren der ursprünglichen Zeichenketten schlägt fehl.

Ein wiederverwendbares Ergebnis zurückgeben

def average(values):
    if not values:
        return None
    return sum(values) / len(values)

average([18.5, 21.0, 19.5, 23.0]) gibt 20.5 zurück. Bei einer leeren Liste wird None zurückgegeben, ohne durch null zu dividieren, und die Funktion lässt die Eingabeliste unverändert.

Eine verschachtelte Liste ist eine Liste, die andere Listen enthält. Eine Tabelle verwendet häufig eine innere Liste pro Zeile. Jeder Zugriff wählt eine Ebene aus, daher braucht das Lesen einer Zelle zwei Indizes.

Erst die Zeile, dann die Zelle auswählen

grid = [[1, 2, 3], [4, 5, 6]]
print(grid[1])
print(grid[1][2])
print(len(grid), len(grid[0]))

Ausgabe:

[4, 5, 6]
6
2 3

grid[1] wählt die zweite Zeile aus; [2] wählt dann das dritte Element dieser Zeile. len(grid) zählt Zeilen, während len(grid[0]) die Zellen der ersten Zeile zählt. Diese rechteckige Tabelle hat sechs Zellen. grid[2][1] schlägt beim ersten Zugriff fehl, weil Zeile 2 nicht existiert. Das Vertauschen von Zeilen- und Spaltenposition kann die falsche Zelle auswählen oder IndexError auslösen.

Eine Zelle oder eine ganze Zeile ändern

grid[0][1] = 20 ändert die zweite Zelle in der ersten Zeile und ergibt [[1, 20, 3], [4, 5, 6]]. grid[0] = [0, 0, 0] ersetzt die gesamte erste Zeile. Die Anzahl der Zugriffe zeigt, welche Ebene ersetzt wird.

Jeden Wert durchlaufen

grid = [[1, 2, 3], [4, 5, 6]]
total = 0
for row in grid:
    for value in row:
        total += value
print(total)

Ausgabe:

21

Die innere Schleife durchläuft die erste Zeile vollständig, bevor die äußere Schleife die zweite Zeile liefert. Sie addiert 1, 2, 3 und dann 4, 5, 6. Für eine Spaltensumme wird aus jeder Zeile eine feste Position verwendet:

column_total = 0
for row in grid:
    column_total += row[1]
print(column_total)

Die Ausgabe ist 7, aus 2 und 5. Dieser Code setzt voraus, dass jede Zeile ein zweites Element hat.

Zeilen müssen nicht gleich lang sein. [[1], [2, 3]] ist eine gültige verschachtelte Liste. Direkte verschachtelte Schleifen durchlaufen dennoch jeden Wert, weil jede innere Schleife ihrer eigenen Zeile folgt. Nähme man an, dass alle Zeilen len(grid[0]) Elemente haben, würden hier Werte übersehen. Um Zellen in einer solchen Tabelle zu zählen, addiere len(row) für jede Zeile.

Unabhängige Zeilen erstellen

table = []
for r in range(3):
    table.append([0] * 4)
table[0][0] = 1
print(table)

Ausgabe:

[[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Jeder Durchlauf erstellt eine neue Liste mit vier Elementen. Die Kurzform [[0] * 4] * 3 wiederholt eine Referenz auf eine Zeile; eine Änderung ihrer ersten Zelle würde in allen drei Zeilen erscheinen.

Datensätze speichern

Eine Zeile kann statt einer Zahlenzeile einen Datensatz beschreiben. Bei students = [["Ana", 90], ["Ben", 85]] ist students[1][0] gleich 'Ben' und students[1][1] gleich 85. Wenn jeder Datensatz zwei Elemente hat, entpackt for name, score in students: sie in aussagekräftig benannte Variablen. Listen von Tupeln können dieselbe Art von Datensätzen darstellen.

Ein Tupel speichert wie eine Liste Elemente in einer Reihenfolge, aber seine Positionen können nicht ersetzt, hinzugefügt oder entfernt werden. Das ist Unveränderlichkeit. Tupel eignen sich für feste Gruppen wie Koordinaten, Datumsangaben und Datensätze; Listen eignen sich für Sammlungen, die wachsen oder sich ändern.

Ein Tupel erstellen und lesen

point = (3, 4)
date = (2024, 7, 15)
print(date[0])
print(date[1:])
print(len(date))

Ausgabe:

2024
(7, 15)
3

Für die Indizierung von Tupeln, negative Indizes, Ausschnitte und Zugehörigkeitsprüfungen gelten dieselben Regeln wie für Listen. Ein Tupelausschnitt gibt ein Tupel zurück. Du kannst ein Tupel durchlaufen oder +, *, min, max, sum, count und index verwenden, wenn seine Elemente für die Operation geeignet sind.

Das Komma erstellt ein nicht leeres Tupel. t = 3, 4 ergibt auch ohne Klammern (3, 4). Ein Tupel mit einem Element braucht ein abschließendes Komma:

list(t) wandelt die Elemente eines Tupels in eine veränderliche Liste um.

Verstehen, was sich nicht ändern lässt

point[0] = 5 löst TypeError aus, weil ein Tupel keine Elementzuweisung unterstützt. Tupel haben keine Methoden append, remove oder sort; point.append(5) löst AttributeError aus.

Ein Name kann dennoch an ein neues Tupel gebunden werden:

point = (3, 4)
point = (5,) + point[1:]
print(point)

Die Ausgabe ist (5, 4). Der Ausdruck erstellt ein neues Tupel; er verändert das alte nicht.

Ein Tupel kann ein veränderliches Element enthalten

t = ([1, 2], "x")
t[0].append(3)
print(t)

Ausgabe:

([1, 2, 3], 'x')

Die erste Position enthält weiterhin dieselbe Liste. Der Inhalt dieser Liste hat sich geändert. t[0] = [9] würde das Objekt an dieser Position ersetzen und ist verboten. Die Unveränderlichkeit des äußeren Tupels macht eine innere Liste nicht unveränderlich.

Die Struktur passend zur Aufgabe wählen

Verwende (x, y) für eine Koordinate, (255, 128, 0) für eine RGB-Farbe oder ("Ana", 90) für einen Datensatz mit zwei Feldern. Jede Position hat eine bestimmte Bedeutung. Verwende eine Liste für alle Punktzahlen einer Klasse oder die Artikel eines Einkaufswagens, deren Anzahl wachsen und deren Reihenfolge sich ändern kann. Eine Liste von Tupeln wie [("Ana", 90), ("Ben", 85)] kombiniert eine veränderliche Sammlung mit festen Positionen in den Datensätzen.

Ein Tupel aus Zahlen oder Zeichenketten kann als Wörterbuchschlüssel dienen, wie in {(0, 0): "origin"}. Schlüssel müssen hashbar sein, also Pythons Regeln für das beständige Nachschlagen von Schlüsseln unterstützen. Eine Liste ist nicht hashbar, ebenso wenig ein Tupel, das eine Liste enthält.

Tupel vergleichen

Der Vergleich beginnt links und stoppt beim ersten ungleichen Paar. (1, 2, 5) < (1, 3, 0) ist True: Die ersten Werte sind gleich, und 2 ist kleiner als 3. Nach derselben Regel wird eine Liste von Tupeldatensätzen geordnet, wenn keine Schlüsselfunktion angegeben ist.

Beim Packen werden Werte in einem Tupel gesammelt. Das Entpacken weist die Elemente eines iterierbaren Objekts der Reihe nach Namen zu. Zusammen ermöglichen sie es dem Code, den Feldern eines Datensatzes klare Namen zu geben und mehrere Ergebnisse aus einer Funktion zu erhalten.

Namen den Werten zuordnen

record = "Ana", 34, "Lima"
name, age, city = record
print(name, age, city)

Ausgabe:

Ana 34 Lima

Das erste Element wird zu name, das zweite zu age und das dritte zu city. Entpacken funktioniert auch bei Listen und Zeichenketten: first, second = [10, 20] und a, b, c = "xyz" weisen ihre Elemente der Reihe nach zu. user, domain = "ana@example.com".split("@") ergibt 'ana' und 'example.com', weil die Aufteilung zwei Teile erzeugt.

Ohne einen Namen mit Stern muss die Anzahl genau übereinstimmen. x, y = (1, 2, 3) löst wegen zu vieler Werte ValueError aus; x, y, z = (1, 2) löst wegen zu weniger Werte ValueError aus. Python verwirft zusätzliche Elemente nicht stillschweigend.

Werte sicher tauschen

a = 1
b = 2
a, b = b, a
print(a, b)

Die Ausgabe ist 2 1. Python wertet die gesamte rechte Seite mit den alten Werten aus, bevor es einen der beiden Namen links zuweist. Der Versuch mit zwei Anweisungen, a = b gefolgt von b = a, verliert den alten Wert von a und setzt beide Namen auf 2.

Die übrigen Elemente sammeln

Ein Name mit Stern erhält eine Liste der übrigen Werte:

first, *rest = [5, 6, 7, 8]
print(first, rest)
*init, last = [5, 6, 7, 8]
print(init, last)

Ausgabe:

5 [6, 7, 8]
[5, 6, 7] 8

Der Stern kann auch zwischen Namen ohne Stern stehen: first, *middle, last = (5, 6, 7, 8) weist middle die Liste [6, 7] zu. Das gesammelte Objekt ist immer eine Liste, auch beim Entpacken eines Tupels. Bei head, *rest = [5] ist rest gleich []. Für die Namen ohne Stern müssen genügend Elemente vorhanden sein, und im selben Entpackungsmuster ist nur ein Name mit Stern erlaubt.

Während einer Schleife entpacken

for name, score in [("Ana", 90), ("Ben", 85)]:
    print(name, score)

Ausgabe:

Ana 90
Ben 85

Der Schleifenkopf entpackt jeden Datensatz, sobald er ankommt. So funktionieren auch for i, item in enumerate(values): und for a, b in zip(left, right):: Jeder Schleifendurchlauf liefert ein Paar.

Mehrere Ergebnisse zurückgeben

def min_max(values):
    return min(values), max(values)

low, high = min_max([7, 2, 9])
result = min_max([7, 2, 9])
print(low, high)
print(result)

Ausgabe:

2 9
(2, 9)

Die Funktion gibt ein Tupel zurück. Der aufrufende Code kann es entpacken oder das ganze Objekt behalten. Ein Unterstrich bezeichnet üblicherweise einen Wert, den der Code nicht benötigt: _, month, day = (2024, 7, 15) behält Monat und Tag unter beschreibenden Namen. _ bleibt eine gewöhnliche Variable und ist keine besondere Operation zum Verwerfen.

Eine Variable ist ein Name, der ein Objekt referenziert. Eine Zuweisung ändert, worauf ein Name verweist; sie kopiert das Objekt nicht automatisch. Bei einer veränderlichen Liste können daher über zwei Namen dieselben Änderungen sichtbar sein.

Den Referenzen folgen

a = [1, 2, 3]
b = a
b.append(4)
print(a)
print(b)

Ausgabe:

[1, 2, 3, 4]
[1, 2, 3, 4]

Es gibt eine Liste und zwei Namen dafür. b ist ein Alias von a. Das Anhängen verändert das gemeinsam referenzierte Objekt, sodass beim Lesen über beide Namen das hinzugefügte Element erscheint. Zeichne beim Nachvollziehen dieses Codes zwei Pfeile, einen von jedem Namen, zur selben Liste.

Gleichheit und Identität unterscheiden

a = [1, 2]
b = a
c = [1, 2]
print(a == b, a == c)
print(a is b, a is c)

Ausgabe:

True True
True False

== vergleicht Inhalte; is prüft, ob es sich um dasselbe Objekt handelt. c hat den gleichen Inhalt, ist aber eine eigene Liste. id(x) gibt die Identitätsnummer eines Objekts zurück, daher stimmt id(a) == id(b) mit a is b überein. Identitätsnummern zeigen nicht, welche Elemente eine Liste enthält.

Verwende ==, wenn du prüfst, ob Inhalte übereinstimmen. Verwende is, wenn du auf gemeinsame Referenzen oder ein spezielles Objekt wie None prüfst. Ein neues Listenliteral erstellt eine eigene Liste, daher ist a is [1, 2] für eine bestehende Liste a falsch, selbst wenn die Inhalte übereinstimmen.

Veränderung und Neubindung wirken unterschiedlich weit

Nach der letzten Anweisung verweist b auf eine neue Liste. a referenziert weiterhin das ursprüngliche Objekt. Die Neubindung eines Namens lenkt nicht alle Namen um, die einmal dieses Objekt referenziert haben.

+= und + getrennt nachvollziehen

Bei Listen erweitert += die bestehende Liste:

a = [1]
b = a
a += [2]
print(a, b)

Die Ausgabe ist [1, 2] [1, 2]. Dagegen:

a = [1]
b = a
a = a + [2]
print(a, b)

Die Ausgabe ist [1, 2] [1]. + erstellt eine neue Liste, und die Zuweisung lässt a darauf verweisen. b referenziert weiterhin die ursprüngliche Liste mit einem Element.

Weniger sichtbare Aliase suchen

row = [0, 0] gefolgt von table = [row, row] speichert dieselbe Zeile zweimal. table[0][0] = 5 ergibt [[5, 0], [5, 0]], weil beide Positionen auf dieselbe innere Liste verweisen.

Zahlen und Zeichenketten können nicht direkt verändert werden. Nach x = 5, y = x, x += 1 bleibt y gleich 5; x wurde neu gebunden. Auch die Elementpositionen eines Tupels bleiben fest, aber eine innere Liste kann sich ändern. Nach t = ([1], 2), u = t und t[0].append(3) zeigt u den Wert ([1, 3], 2): Beide Namen verweisen weiterhin auf dasselbe Tupel und dieselbe darin enthaltene veränderliche Liste.

Kopieren erstellt ein neues Objekt, aber die Tiefe der Kopie ist entscheidend. Eine neue äußere Liste kann weiterhin Referenzen auf die ursprünglichen inneren Listen enthalten.

Eine neue äußere Liste erstellen

a = [1, 2, 3]
b = a.copy()
b.append(4)
print(a)
print(b)
print(a is b)

Ausgabe:

[1, 2, 3]
[1, 2, 3, 4]
False

a[:], list(a) und a.copy() erstellen jeweils eine flache Kopie einer Liste. Ihr äußerer Container ist neu, und ihre Referenzen auf Elemente werden kopiert. Bei unveränderlichen Zahlen oder Zeichenketten bleibt die andere äußere Liste unverändert, wenn in einer ein Element ersetzt oder hinzugefügt wird.

Erkennen, was eine flache Kopie gemeinsam referenziert

a = [[1, 2], [3, 4]]
b = a.copy()
b[0].append(99)
print(a)
print(b is a, b[0] is a[0])

Ausgabe:

[[1, 2, 99], [3, 4]]
False True

Die beiden äußeren Listen sind verschieden, aber ihre ersten Elemente referenzieren dieselbe innere Liste. append() verändert dieses innere Objekt.

Das Ersetzen einer Position in b ist etwas anderes. Nach b[1] = [0] hat b eine andere zweite Zeile, während a[1] gleich [3, 4] bleibt. Die Zuweisung ändert eine Referenz in der äußeren Liste von b; sie verändert nicht die alte zweite Zeile.

Auch verschachtelte Listen kopieren

import copy

a = [[1, 2], [3, 4]]
b = copy.deepcopy(a)
b[0].append(99)
print(a)
print(b)

Ausgabe:

[[1, 2], [3, 4]]
[[1, 2, 99], [3, 4]]

import copy stellt das Modul zum Kopieren bereit. copy.deepcopy() kopiert die verschachtelte Listenstruktur rekursiv, sodass Änderungen an kopierten inneren Listen das Original nicht erreichen. Verwende die Funktion, wenn Änderungen auf diesen inneren Ebenen unabhängig sein müssen. Eine flache Kopie reicht aus, wenn nur die Reihenfolge oder die Elementreferenzen der äußeren Liste geändert werden.

Wiederholte Referenzen beim Erstellen von Zeilen vermeiden

table = [[0] * 3] * 2
table[0][0] = 7
print(table)

Die Ausgabe ist [[7, 0, 0], [7, 0, 0]]. Die Multiplikation hat die Referenz auf eine Zeile wiederholt. Sie hat keine zwei Zeilen erstellt.

Erstelle jede Zeile innerhalb der Schleife:

table = []
for r in range(2):
    table.append([0] * 3)
table[0][0] = 7
print(table)

Die Ausgabe ist [[7, 0, 0], [0, 0, 0]]. [0] * 3 selbst ist für unabhängige Zähler unproblematisch: Ganze Zahlen können nicht verändert werden, und eine Elementzuweisung ersetzt nur eine Position.

Eine Kopie aus einem bestimmten Grund wählen

Um beim Sortieren die ursprüngliche Reihenfolge zu erhalten, brauchst du eine neue äußere Liste. Sollen ursprüngliche verschachtelte Messwerte erhalten bleiben, während kopierte Zellen geändert werden, brauchst du auch unabhängige innere Listen. Bei rein lesender Verarbeitung ist keine Kopie nötig, und für beabsichtigte gemeinsame Änderungen können Aliase verwendet werden. Um einen Fehler in einer verschachtelten Struktur zu untersuchen, prüfe sowohl b is a als auch b[0] is a[0]; ein Test nur der äußeren Listen übersieht gemeinsam referenzierte innere Listen.

Ein Funktionsparameter ist ein weiterer Name für das vom aufrufenden Code übergebene Objekt. Ein Listenargument wird nicht automatisch kopiert. Die Funktion kann dieses Objekt verändern, ihren lokalen Parameter neu binden oder ein neues Ergebnis zurückgeben; diese Handlungen wirken sich unterschiedlich auf den aufrufenden Code aus.

Eine Veränderung erreicht den aufrufenden Code

def add_bonus(scores):
    scores.append(5)

marks = [80]
result = add_bonus(marks)
print(marks)
print(result)

Ausgabe:

[80, 5]
None

scores und marks referenzieren zunächst dieselbe Liste. Das Anhängen über scores verändert sie. Da die Funktion keine ausdrückliche return-Anweisung hat, ist ihr Ergebnis None.

Dagegen bindet def reset(scores): scores = [] nur den lokalen Parameter neu. Das marks des aufrufenden Codes referenziert weiterhin seine alte Liste. Verwende scores.clear(), um diese gemeinsam referenzierte Liste tatsächlich zu leeren.

Eine zurückgegebene Liste bei Bedarf behalten

Zwei häufige Entwürfe bestehen darin, eine Liste direkt zu verändern und None zurückzugeben oder sie unverändert zu lassen und eine neue Liste zurückzugeben:

def drop_first(values):
    del values[0]

def tail(values):
    return values[1:]

Bei nums = [1, 2, 3] lässt der Aufruf drop_first(nums) den Wert von nums als [2, 3] zurück. nums = drop_first(nums) würde nums dagegen an None binden. Beginnst du erneut mit [1, 2, 3], weist shorter = tail(nums) der Variablen shorter die Liste [2, 3] zu, während nums unverändert bleibt. Ein Aufruf von tail(nums), ohne das Ergebnis zu behalten, verwirft die neue Liste.

Auch andere Entwürfe sind nützlich: sum() gibt einen zusammenfassenden Wert zurück, und pop() verändert eine Liste und gibt zugleich ein Element zurück. Mache die Wirkung und den Rückgabewert im Namen oder Docstring einer Funktion deutlich.

Ein Ergebnis erstellen, ohne die Eingabe zu verändern

def without_negatives(values):
    kept = []
    for value in values:
        if value >= 0:
            kept.append(value)
    return kept

original = [3, -2, 0, 7]
print(without_negatives(original))
print(original)

Ausgabe:

[3, 0, 7]
[3, -2, 0, 7]

Der aufrufende Code kann seine äußere Liste auch schützen, indem er eine flache Kopie übergibt, etwa mit drop_first(original[:]). Eine Operation, die innere Listen verändert, würde auch auf diesen Ebenen Kopien benötigen.

Einen gemeinsam referenzierten veränderlichen Standardwert vermeiden

def add_item(item, basket=[]):
    basket.append(item)
    return basket

Die Standardliste wird einmal erstellt, wenn die def-Anweisung ausgeführt wird. add_item("a") gibt ['a'] zurück, und der nächste Aufruf mit Standardwert add_item("b") gibt ['a', 'b'] zurück. Verwende None, um eine neue Liste anzufordern:

def add_item(item, basket=None):
    if basket is None:
        basket = []
    basket.append(item)
    return basket

Jeder Aufruf ohne Einkaufswagen erstellt nun eine eigene Liste. Durch Übergabe eines vorhandenen Einkaufswagens sind weiterhin beabsichtigte gemeinsame Änderungen möglich. Eine Funktion kann eine Zahl oder Zeichenkette nicht verändern und keine Positionen eines Tupels ersetzen, sie kann aber eine in einem Tupel gespeicherte Liste verändern, etwa durch den Aufruf pair[0].append(9).

Sortieren bringt Elemente in eine durch Vergleiche bestimmte Reihenfolge. Das Umkehren dreht ihre aktuelle Reihenfolge um. Entscheide auch, ob das Programm die bestehende Liste verändern oder sie behalten und eine neue Liste erhalten soll.

Direkt sortieren oder eine neue Liste behalten

nums = [3, 1, 2]
new = sorted(nums)
print(nums)
print(new)
nums.sort()
print(nums)

Ausgabe:

[3, 1, 2]
[1, 2, 3]
[1, 2, 3]

sorted() erstellt eine neue Liste. sort() ist eine Listenmethode, die die bestehende Liste umordnet und None zurückgibt. Bei nums = nums.sort() verliert der Name seine Referenz auf die Liste und wird an None gebunden. Schreibe nums.sort() in eine eigene Zeile oder verwende nums = sorted(nums). print(nums.sort()) gibt None aus, obwohl die Liste umgeordnet wurde.

sorted() akzeptiert jedes iterierbare Objekt und gibt immer eine Liste zurück. sorted((3, 1, 2)) ergibt [1, 2, 3] und sorted("cab") ergibt ['a', 'b', 'c']. Zeichenketten und Tupel haben keine sort()-Methode zur direkten Veränderung.

Absteigende und umgekehrte Reihenfolge

Jede Zeile geht von der ursprünglichen Liste aus. reverse=True fordert eine absteigende Vergleichsreihenfolge an und muss namentlich angegeben werden; sorted(nums, True) löst TypeError aus. Das Umkehren durchläuft lediglich die bestehenden Positionen rückwärts und erzeugt daher nicht unbedingt absteigende Werte.

Die verglichenen Werte prüfen

Zahlen werden nach ihrem Zahlenwert sortiert, auch wenn ganze Zahlen und Gleitkommazahlen gemischt sind: sorted([2.5, -1, 2]) ergibt [-1, 2, 2.5].

Text wird Zeichen für Zeichen verglichen. sorted(["10", "9", "100"]) ergibt ['10', '100', '9']. Das erste Zeichen '1' wird vor '9' einsortiert, und eine Zeichenkette, die den Anfang einer längeren bildet, steht vor dieser. Wandle numerische Zeichenketten mit int() oder float() um, wenn eine Sortierung nach Zahlenwert gewünscht ist.

Die Großbuchstaben A–Z werden vor den Kleinbuchstaben a–z einsortiert. sorted(["b", "B", "a"]) ergibt ['B', 'a', 'b']. Die Standardreihenfolge von Zeichenketten beruht auf Zeichencodes; sie ist keine Wörterbuchreihenfolge ohne Beachtung der Groß- und Kleinschreibung.

Alle verglichenen Elemente müssen untereinander < unterstützen. sorted([3, "two", 1]) löst TypeError aus. Bereinige oder wandle die Daten vor dem Sortieren um.

Sortierte Positionen verwenden

Bei einer ungeraden Anzahl von Punktzahlen lässt sich der Wert in der Mitte nach dem Sortieren leicht ablesen:

scores = [72, 95, 64, 88, 79]
ordered = sorted(scores)
median = ordered[len(ordered) // 2]
print(ordered)
print(median)

Die Ausgabe ist [64, 72, 79, 88, 95], gefolgt von 79. Die ursprüngliche Liste hält weiterhin die Reihenfolge fest, in der die Punktzahlen eingetroffen sind. Diese Berechnung anhand eines einzelnen Elements in der Mitte gilt für nicht leere Listen ungerader Länge.

Eine Schlüsselfunktion berechnet für jedes Element den Vergleichswert. Die ursprünglichen Elemente bleiben im sortierten Ergebnis unverändert. So kann ein Programm Text nach Länge oder Datensätze nach einem ausgewählten Feld sortieren.

Eine Funktion übergeben, keinen Funktionsaufruf

words = ["kiwi", "fig", "banana"]
print(sorted(words, key=len))

Ausgabe:

['fig', 'kiwi', 'banana']

Python ruft len einmal für jedes Element auf und vergleicht die resultierenden Längen 4, 3 und 6. Übergib key=len ohne Klammern. key=len() versucht, len sofort ohne Argument aufzurufen, und schlägt fehl.

Für den Vergleich in Kleinschreibung verwende key=str.lower. Bei ["banana", "apple", "Cherry"] ist die Standardreihenfolge ['Cherry', 'apple', 'banana']. Mit key=str.lower ist das Ergebnis ['apple', 'banana', 'Cherry']. Das ursprüngliche große C bleibt im Ergebnis erhalten; nur die Vergleichsschlüssel sind kleingeschrieben.

Ein Feld eines Datensatzes auswählen

results = [("Ana", 90), ("Ben", 72), ("Cy", 85)]

def by_score(record):
    return record[1]

print(sorted(results, key=by_score))

Ausgabe:

[('Ben', 72), ('Cy', 85), ('Ana', 90)]

Die Funktion erhält jeweils einen Datensatz. record[1] wählt dessen Punktzahl aus. Ergänze reverse=True, um die höchste Punktzahl an den Anfang zu setzen. results.sort(key=by_score, reverse=True) verwendet dieselbe Regel, verändert aber results selbst.

key=by_score(results) ist anders: Es ruft die Funktion für die ganze Liste auf und übergibt deren Ergebnis als Schlüsselargument. Hier ist dieses Ergebnis das Tupel ('Ben', 72), das nicht als Funktion aufgerufen werden kann, sodass das Sortieren TypeError auslöst.

Mehrere Felder verwenden

Ohne Schlüsselfunktion vergleichen Tupel ihre ersten Elemente und bei gleichen ersten Elementen ihre zweiten. Das Sortieren von [("Ben", 72), ("Ana", 90), ("Ana", 85)] ergibt [('Ana', 85), ('Ana', 90), ('Ben', 72)].

Eine Schlüsselfunktion kann ein Tupel zurückgeben, um eine andere Feldreihenfolge zu wählen:

def rank_key(record):
    return (-record[1], record[0])

results = [("Dee", 85), ("Ana", 90), ("Cy", 85)]
print(sorted(results, key=rank_key))

Ausgabe:

[('Ana', 90), ('Cy', 85), ('Dee', 85)]

Durch das Verneinen der Punktzahl erhalten größere Punktzahlen kleinere Schlüssel. Die Namen lösen dann Gleichstände bei der Punktzahl in aufsteigender Reihenfolge auf. reverse=True bei einem positiven Schlüssel (score, name) würde beide Felder umkehren, auch die Namen, und damit diese Regel mit unterschiedlichen Richtungen nicht erfüllen.

Elemente mit gleichen Schlüsseln in Reihenfolge halten

Python sortiert stabil: Elemente mit gleichen Schlüsseln behalten ihre Eingabereihenfolge. Das Sortieren von ["bb", "a", "cc", "d"] nach len ergibt ['a', 'd', 'bb', 'cc']. Beim Gleichstand zwischen den beiden Wörtern mit einem Buchstaben bleibt 'a' zuerst; beim Gleichstand der Wörter mit zwei Buchstaben bleibt 'bb' zuerst. Stabilität erlaubt auch, zuerst nach einem nachrangigen Feld und dann nach dem Hauptfeld zu sortieren.

min() und max() akzeptieren ebenfalls Schlüsselfunktionen. max(words, key=len) gibt 'banana' zurück, nicht dessen Länge. Bei gleichen Schlüsseln geben diese Funktionen das erste gefundene passende Element zurück.