Python-Datenstrukturen: Listen, Tupel, Sets, Dicts und Comprehensions

Bisher haben Ihre Programme Werte einzeln in Variablen jongliert. Echte Daten kommen in Mengen: eine Schulklasse, ein Monat voller Temperaturen, ein Warenkorb mit Produkten. Diese Lektion stellt die vier eingebauten Sammlungen von Python vor: Listen, Tupel, Mengen und Wörterbücher: und danach das Merkmal, das Python-Code unverwechselbar pythonisch macht: Comprehensions. Viele Lernende beschreiben dies als die Lektion, in der die Sprache Klick macht, denn plötzlich sind die Programme, die Sie schreiben können, keine Übungen mehr, sondern nützlich.

Ein stilles Versprechen, bevor wir beginnen: Sie müssen nicht jede Methode jeder Sammlung auswendig lernen. Sie müssen wissen, wofür jede Struktur gedacht ist, die Handvoll Operationen, die Sie täglich verwenden, und wie Sie den Rest nachschlagen. Die Auswahltabelle in Abschnitt 5 ist die eigentliche Essenz dieser Lektion; Syntax kommt und geht im Gedächtnis, aber zu wissen, welcher Behälter zu einem Problem passt, ist eine bleibende Fertigkeit.

1. Listen: der Allzweckbehälter

Eine Liste ist eine geordnete, veränderbare Folge von Werten, geschrieben in eckigen Klammern. Elemente behalten die Reihenfolge, die Sie ihnen gegeben haben, können über die Position ab Null gelesen werden und lassen sich frei hinzufügen, entfernen und ersetzen. Listen enthalten alles Mögliche: Zahlen, Zeichenketten, andere Listen, eine Mischung -, obwohl guter Code in der Praxis einen Typ pro Liste beibehält. Negative Indizes zählen vom Ende, wobei -1 das letzte Element bedeutet, eine Idiomatik, die Sie ständig verwenden werden.

marks = [78, 91, 65, 84, 70]

print(marks[0])      # 78    first
print(marks[-1])     # 70    last
print(len(marks))    # 5

marks.append(88)         # add at the end
marks.insert(0, 50)      # add at a position
marks.remove(65)         # remove first matching value
top = max(marks)
marks.sort()             # in place, ascending
print(marks)             # [50, 70, 78, 84, 88, 91]
print(f"top mark: {top}")

Slicing liest eine Teilliste mit derselben Konvention „Anfang enthalten, Ende ausgeschlossen“ wie range: marks[1:4] liefert die Elemente an den Positionen 1, 2 und 3, marks[:3] die ersten drei, marks[-2:] die letzten beiden und marks[::-1] die gesamte Liste rückwärts. Slices erzeugen immer eine neue Liste und lassen das Original unberührt, was auch die übliche Methode ist, eine Liste zu kopieren: copy = original[:]. Dieser Unterschied zwischen Teilen und Kopieren ist wichtig, weil Listen veränderbar sind und zwei Namen auf dieselbe Liste zeigen können; wenn Sie über einen Namen etwas anhängen, sieht der andere es ebenfalls: dasselbe Aliasing, das veränderbare Standardwerte in Teil 4 gefährlich machte.

2. Tupel: Sequenzen, die versprechen, sich nicht zu ändern

Ein Tupel ist eine geordnete Sequenz wie eine Liste, aber unveränderlich: Einmal erstellt, kann es nicht wachsen, schrumpfen oder verändert werden. Tupel werden mit runden Klammern geschrieben: oder mit gar nichts, denn es sind tatsächlich die Kommas, die ein Tupel ausmachen, genau das, was Sie verwendet haben, als eine Funktion in Teil 4 zwei Werte zurückgab. Verwenden Sie Tupel für Daten mit fester Form: ein Koordinatenpaar, ein Datumstripel, einen Datensatz aus Name und Punktzahl: und Listen für offene Sammlungen ähnlicher Dinge.

point = (12.5, 7.8)
student = ("Amina", 87)        # the record shape from Part 4

name, score = student          # unpacking: one name per slot
print(f"{name} scored {score}")

x, y = point
y, x = x, y                    # the classic Python swap, no temp needed
print(x, y)                    # 7.8 12.5

Entpacken ist die Idiomatik, die Sie hier verinnerlichen sollten. Jede Sequenz kann in exakt passende Namen entpackt werden, Schleifen können beim Durchlaufen entpacken, und ein mit Stern markierter Name kann die Mitte aufsaugen: first, *rest = scores. Unveränderlichkeit ist keine Einschränkung, sondern eine Information. Wenn Sie ein Tupel sehen, wissen Sie, dass nichts es hinter Ihrem Rücken verändern wird, was auch der Grund ist, warum Tupel als Wörterbuchschlüssel dienen können, Listen hingegen nicht.

3. Wörterbücher: Dinge über Namen nachschlagen

Ein Wörterbuch bildet Schlüssel auf Werte ab, so wie ein Telefonbuch Namen auf Nummern abbildet. Es ist die mit Abstand am häufigsten verwendete Datenstruktur in echtem Python, denn die meisten realen Daten sind von Natur aus beschriftet: Ein Benutzer hat einen Namen, eine E-Mail, ein Alter; ein Produkt hat einen Preis und einen Lagerbestand. Geschweifte Klammern mit Schlüssel-Doppelpunkt-Wert-Paaren erzeugen eines, eckige Klammern lesen und schreiben über den Schlüssel, und der in-Operator prüft, ob ein Schlüssel existiert. Einen fehlenden Schlüssel mit eckigen Klammern zu lesen, löst KeyError aus; die get-Methode gibt stattdessen None oder einen von Ihnen gewählten Standardwert zurück, und die bewusste Wahl zwischen diesen beiden Verhaltensweisen ist ein Kennzeichen von durchdachtem Code.

student = {"name": "Amina", "score": 87, "city": "Colombo"}

print(student["name"])              # Amina
student["score"] = 91               # update
student["grade"] = "A"              # insert new key
print(student.get("email"))         # None, no crash
print(student.get("email", "n/a"))  # n/a, your default

for key, value in student.items():  # unpacking in the loop header
    print(f"{key}: {value}")

Dinge zählen ist das Wörterbuchmuster, das Sie am häufigsten verwenden werden: ein Akkumulator aus Teil 3, bei dem der Akkumulator ein Dict ist. Gehen Sie die Daten durch; für jedes Element erhöhen Sie seinen Eintrag um eins und legen den Eintrag beim ersten Auftauchen mit get an. Diese fünfzeilige Form treibt Worthäufigkeiten, Stimmenauszählungen, Bestandszählungen und die Datenarbeit an, die in Teil 11 kommt; der Playground am Ende dieser Lektion lässt Sie es selbst bauen.

4. Mengen: Zugehörigkeit und Eindeutigkeit

Ein Set ist eine ungeordnete Sammlung eindeutiger Werte. Fügt man dasselbe Element zweimal hinzu, wird es nur einmal gespeichert; fragt man, ob ein Element enthalten ist, kommt die Antwort praktisch sofort, egal wie groß das Set ist: dramatisch schneller als die Suche in einer langen Liste. Die beiden alltäglichen Anwendungen sind Deduplizierung: set(items) entfernt Duplikate in einem Aufruf: und schnelle Mitgliedschaftstests für Abfragen in einer Schleife. Sets unterstützen außerdem Mengenoperationen direkt aus dem Matheunterricht: Vereinigung, Schnittmenge und Differenz, die Fragen wie „Wer hat an beiden Sitzungen teilgenommen?“ in einen einzigen Operator verwandeln.

monday = {"amina", "zane", "ruwan", "kai"}
tuesday = {"zane", "kai", "neha"}

print(monday & tuesday)    # {'zane', 'kai'}        both days
print(monday | tuesday)    # everyone at least once
print(monday - tuesday)    # {'amina', 'ruwan'}     Monday only

emails = ["a@x.com", "b@x.com", "a@x.com", "c@x.com", "b@x.com"]
unique = set(emails)
print(f"{len(emails)} signups, {len(unique)} unique")   # 5 signups, 3 unique

5. Die richtige Datenstruktur wählen

Wenn zwei Strukturen gleichermaßen plausibel erscheinen, fragen Sie sich, was der umgebende Code tun wird. Wenn Sie der Reihe nach durchlaufen: list. Wenn Sie wiederholt fragen „Existiert X?“: set oder dict. Wenn die Form feststeht und die Bedeutung aus der Position kommt: tuple. Die richtige Wahl ist keine Pedanterie; die gewählte Struktur bestimmt, wie sich jede spätere Codezeile liest und oft auch, wie schnell sie läuft.

6. Comprehensions: Sammlungen in einer Zeile aufbauen

Hier kommt der charakteristische Schachzug von Python. Das Muster, eine leere Liste zu erstellen, zu durchlaufen und transformierte Elemente anzuhängen, ist so verbreitet, dass die Sprache dafür eine eigene Syntax bereitstellt. Eine List Comprehension setzt den Ausdruck an den Anfang, dann die Schleife, dann einen optionalen Filter, in eckige Klammern, und liest sich fast wie die Mengenschreibweise aus der Schule: die Quadrate von n für jedes n im Bereich, wobei nur die geraden behalten werden. Tauscht man die Klammern gegen geschweifte Klammern, erhält man eine Set Comprehension; fügt man Schlüssel:Wert hinzu, eine Dict Comprehension.

numbers = [3, 8, 12, 5, 20, 7]

# The loop way
doubled = []
for n in numbers:
    doubled.append(n * 2)

# The comprehension way: same result, one honest line
doubled = [n * 2 for n in numbers]
evens   = [n for n in numbers if n % 2 == 0]
squares = {n: n ** 2 for n in numbers}        # dict comprehension
lengths = {len(w) for w in ["hi", "hey", "yo"]}  # set: {2, 3}

print(doubled)   # [6, 16, 24, 10, 40, 14]
print(evens)     # [8, 12, 20]
print(squares[5])  # 25

Bei Comprehensions geht es nicht darum, Tastenanschläge zu sparen; es geht darum, das Was anstelle des Wie auszudrücken. Der Leser sieht den Ergebnisausdruck zuerst und kennt das Ziel vor der Reise. Die Disziplin, die sie lesbar hält: eine Schleife, höchstens ein if und keine Seiteneffekte. Sobald eine Comprehension zwei Bedingungen und eine verschachtelte Schleife benötigt, schreiben Sie stattdessen die normale for-Schleife; erfahrene Entwickler tun das ohne Verlegenheit.

7. enumerate und zip: Schleifen wie ein Einheimischer

Zwei Built-ins vervollständigen das Werkzeugset. enumerate paart jedes Element mit seinem Index und beseitigt das schwerfällige range(len(items))-Muster, und zip führt zwei oder mehr Sequenzen im Gleichschritt zusammen, paart Erstes mit Erstem, Zweites mit Zweitem und hört bei der kürzesten auf. Beide erzeugen Paare, die direkt im Schleifenkopf entpackt werden: die Tuple-Fertigkeit aus Abschnitt 2 zahlt sich bereits aus.

names  = ["Amina", "Zane", "Ruwan"]
scores = [87, 91, 78]

for i, name in enumerate(names, start=1):
    print(f"{i}. {name}")

for name, score in zip(names, scores):
    print(f"{name}: {score}")

ranking = dict(zip(names, scores))      # {'Amina': 87, 'Zane': 91, ...}

8. Praxis: ein Worthäufigkeitszähler

Der folgende Spielplatz baut den klassischen Worthäufigkeitszähler: einen Text in Wörter zerlegen, jedes mit einem Dictionary zählen und dann die häufigsten Ergebnisse sortiert mit einem Lambda-Schlüssel aus Teil 4 ausgeben. Jede Technik der letzten drei Lektionen erscheint in fünfzehn Zeilen, und genau das ist der Punkt: Lektionen hören auf, getrennt zu sein, sobald man etwas baut. Die Übungen erweitern es mit einem Set, einer Comprehension und einem Tuple-Unpacking.

Falls Ihre Zählschleife sich wortreich anfühlt, gutes Gespür: Teil 8 stellt collections.Counter vor, der das in einer Zeile erledigt, und Sie werden es genau deshalb schätzen, weil Sie die manuelle Version gebaut haben. Das ist ein Muster, das dieser Kurs bewusst wiederholt: zuerst das Prinzip von Hand, dann die Abkürzung aus der Standardbibliothek, damit die Abkürzung niemals Magie ist.

9. Zusammenfassung und Ausblick

Sie beherrschen jetzt die vier Container, aus denen jedes Python-Programm gebaut ist: Listen für geordnete veränderbare Daten, Tupel für feste Datensätze, dicts für benannte Zugriffe, Sets für Eindeutigkeit und Mitgliedschaft, dazu Comprehensions, enumerate, zip, Slicing und Entpacken. Mit Funktionen aus Teil 4 darum gewickelt können Sie bereits wirklich nützliche Programme schreiben, und der Rest des Kurses setzt diese Werkzeuge so selbstverständlich voraus wie die Grundrechenarten.

Als Nächstes verlagert sich der Kurs vom Organisieren von Daten zum Organisieren von Programmen: Teil 6, objektorientiertes Python führt Klassen ein, das Muster hinter nahezu jeder Bibliothek, die Sie jemals importieren werden. Arbeiten Sie zuerst die obigen Übungen im Playground durch und sammeln Sie dann zusätzliche Wiederholungen in den Lektionen zu Datenstrukturen und Comprehensions in der Learn-Python-App unten; die vollständige Serie finden Sie stets im Serien-Hub.

Üben für unterwegs

Learn Python, die kostenlose Android-App

Jedes Thema dieser Serie gibt es auch in der App: mundgerechte Lektionen, ausführbare Beispiele, Quizze, Miniprojekte und einen Offline-Python-Playground, der auf Ihrem Handy läuft.

Jetzt bei Google Play App-Seite ansehen