Python-Wörterbücher und Mengen

Ein Wörterbuch speichert Paare: Ein Schlüssel bezeichnet einen Eintrag, und sein Wert enthält die gesuchte Information. Eine Kontaktliste ist ein hilfreiches Modell: Ein Name führt zu einer Telefonnummer. Beim Nachschlagen in einem Wörterbuch wird ein Schlüssel verwendet, auch wenn dieser zufällig eine Zahl ist.

Paare schreiben

ages = {"Ana": 31, "Ben": 27, "Cara": 35}
print(ages["Ben"])
print(len(ages))

Dies gibt 27 und danach 3 aus. Der Doppelpunkt verbindet jeden Schlüssel mit seinem Wert; Kommas trennen die Paare. len zählt die Paare. Sowohl {} als auch dict() erzeugen ein leeres Wörterbuch.

Jeder Schlüssel kommt nur einmal vor. In {"a": 1, "b": 2, "a": 3} ersetzt der spätere Wert für "a" den früheren, sodass {'a': 3, 'b': 2} übrig bleibt. Zwei verschiedene Schlüssel dürfen denselben Wert haben: {"Ana": "blue", "Ben": "blue"} hat weiterhin zwei Einträge.

Aus anderen Daten erstellen

Wähle die Form, die zur Eingabe passt:

colors = dict(red=1, blue=2)
coordinates = dict([("x", 10), ("y", 20)])
labels = dict(zip(["a", "b", "c"], [1, 2, 3]))

Die erste Form macht aus den Argumentnamen Zeichenketten als Schlüssel. Die zweite liest eine Sequenz von Paaren mit je zwei Elementen. Die dritte verbindet entsprechende Elemente zweier Listen zu Paaren und erzeugt {'a': 1, 'b': 2, 'c': 3}. Die Zeichenketten in der ersten Form sind 'red' und 'blue'; es werden keine Variablen nachgeschlagen.

Verwendbare Schlüssel wählen

Wörterbuchschlüssel müssen hashbar sein. Zeichenketten und Zahlen funktionieren ebenso wie Tupel, die vollständig aus hashbaren Elementen bestehen. Listen, Wörterbücher und gewöhnliche Mengen funktionieren nicht als Schlüssel. Verwende für einen Ort das Tupel (2, 3) statt der Liste [2, 3]:

board = {(0, 0): "start", (2, 3): "treasure"}
print(board[(2, 3)])

Dies gibt treasure aus. Die runden Klammern machen das Koordinatenpaar zu einem Schlüssel. Ein Tupel, das eine Liste enthält, erfüllt die Hashbarkeitsregel dennoch nicht. Für Wörterbuchwerte gilt diese Einschränkung nicht: Ein Wert kann eine Liste, ein anderes Wörterbuch oder ein beliebiger anderer Datentyp sein.

Gleiche numerische Schlüssel beziehen sich auf denselben Eintrag. Da 1, 1.0 und True beim Vergleich gleich sind, enthält {1: "one", 1.0: "float one"} ein Paar mit dem Wert 'float one'. Die Zeichenkette "1" ist ein anderer Schlüssel als die Zahl 1.

Reihenfolge und Identität unterscheiden

Seit Python 3.7 bewahren Wörterbücher die Einfügereihenfolge. Die Altersangaben oben erscheinen bei der Ausgabe oder beim Durchlaufen in der Reihenfolge Ana, Ben, Cara. Sie haben weiterhin Schlüssel und keine Listenpositionen: ages[0] fragt den Schlüssel 0 ab und löst KeyError: 0 aus.

Wörterbücher sind veränderlich. Nach backup = ages verweisen beide Namen auf dasselbe Wörterbuch. Die Zuweisung backup["Ana"] = 32 ändert auch den Wert, auf den über ages zugegriffen wird. Um das äußere Wörterbuch zu kopieren, schreibe backup = ages.copy() oder backup = dict(ages). Separate äußere Wörterbücher können weiterhin verschachtelte Listen und Wörterbücher gemeinsam referenzieren.

Wie du einen Wert nachschlägst, sollte dazu passen, was ein fehlender Schlüssel in deinem Programm bedeutet. Manchmal weist er auf einen Fehler hin. Manchmal ist er normal, etwa bei einem Produkt, das noch nicht gezählt wurde. Python bietet dir verschiedene Möglichkeiten, diese Fälle zu behandeln.

Einen vorhandenen Wert lesen

stock = {"apples": 12, "pears": 0, "plums": 7}
print(stock["plums"])

Der Zugriff mit eckigen Klammern gibt 7 zurück. Schlüssel müssen genau übereinstimmen: "Plums" unterscheidet sich von "plums". Das Lesen von stock["kiwis"] löst KeyError: 'kiwis' aus, weil dieser Schlüssel fehlt. Es liefert weder einen leeren Wert noch den Zählwert null.

Verwende diesen direkten Zugriff, wenn ein Schlüssel erforderlich ist. Ein Fehler macht dann an der Stelle seines Auftretens auf unvollständige Daten oder einen Schreibfehler aufmerksam.

Auf einen Schlüssel prüfen

Der Ausdruck key in stock prüft, ob ein Schlüssel existiert. "pears" in stock ist True, obwohl der gespeicherte Wert null ist. "kiwis" not in stock ist ebenfalls True.

item = "kiwis"
if item in stock:
    print(stock[item])
else:
    print("No stock record for", item)

Hier führt der fehlende Schlüssel zu einer Meldung. Der Zugriff findet nur in dem Zweig statt, in dem der Schlüssel existiert.

Eine Zugehörigkeitsprüfung in einem Wörterbuch durchsucht die Schlüssel. 12 in stock ist False; um zu fragen, ob ein Eintrag den gespeicherten Wert 12 hat, schreibe 12 in stock.values(). Die Sammlung nach in bestimmt, was durchsucht wird.

Mit einem Standardwert lesen

stock.get("kiwis") gibt None zurück, ohne KeyError auszulösen. Gib ein zweites Argument an, um einen anderen Standardwert zu wählen: stock.get("kiwis", 0) ergibt 0. Keiner der beiden Aufrufe fügt einen neuen Eintrag ein. Nach beiden Aufrufen enthält das Wörterbuch weiterhin nur Äpfel, Birnen und Pflaumen.

Der Standardwert ersetzt einen fehlenden Zugriff, keinen gespeicherten Wert. stock.get("pears", 99) gibt 0 zurück, weil für Birnen bereits ein Wert vorliegt.

Null nicht mit fehlend verwechseln

if stock.get("pears"): prüft den Wahrheitswert des zurückgegebenen Werts. Null gilt als falsch, daher wird dieser Zweig übersprungen. Derselbe Test überspringt auch einen fehlenden Schlüssel, dessen Zugriff None zurückgibt. Um diese Fälle zu unterscheiden, prüfe direkt, ob der Schlüssel enthalten ist.

Eine ganze Bestellung verarbeiten

prices = {"coffee": 3.5, "tea": 2.75}
order = ["tea", "coffee", "tea", "soda"]
total = 0
for item in order:
    if item in prices:
        total += prices[item]
    else:
        print("No price for", item)
print(total)

Der erste Tee erhöht die Summe auf 2,75, der Kaffee auf 6,25 und der zweite Tee auf 9,0. Für das Erfrischungsgetränk erscheint die Meldung No price for soda; es wird nichts addiert. Ein direkter Zugriff bei jedem Durchlauf würde beim Erfrischungsgetränk fehlschlagen; ein unbemerkt verwendeter Standardpreis von null würde den fehlenden Preis verbergen. Der separate Zweig macht diese fehlende Information sichtbar.

Beim Aktualisieren eines Wörterbuchs bestimmen Schlüssel, was geändert wird. Die Zuweisung eines Werts kann ein neues Paar hinzufügen oder einen alten Wert ersetzen. Das Entfernen eines Paars kann außerdem eine benötigte Information zurückgeben, etwa die aus einem Warenbestand entnommene Menge.

Hinzufügen und ersetzen

scores = {"Ana": 8}
scores["Ben"] = 6
scores["Ana"] = 9
scores["Ben"] += 2
print(scores)

Das Ergebnis ist {'Ana': 9, 'Ben': 8}. Ben wird hinzugefügt, Anas Punktzahl wird aktualisiert und dann wird Bens vorhandene Punktzahl erhöht. Die Zeile mit += liest zuerst den alten Wert und löst daher bei einem fehlenden Schlüssel KeyError aus. Wörterbücher haben keine Methode append.

Wörterbücher verbinden

update kopiert Paare in ein vorhandenes Wörterbuch. Bei diesen Punktzahlen ändert scores.update({"Ben": 7, "Cara": 10}) Bens Wert auf 7 und fügt Cara mit 10 hinzu.

Seit Python 3.9 kann der Zusammenführungsoperator ein neues Wörterbuch erstellen:

left = {"x": 1, "y": 2}
right = {"y": 5, "z": 3}
merged = left | right
print(merged)

Dies gibt {'x': 1, 'y': 5, 'z': 3} aus. Bei einem gemeinsamen Schlüssel gilt der Wert von der rechten Seite. left bleibt unverändert; left |= right würde es direkt aktualisieren.

update() gibt None zurück. scores = scores.update(new_scores) verändert das alte Wörterbuch und lässt scores anschließend auf None verweisen. Rufe update in einer eigenen Zeile auf. Weise das Ergebnis von left | right zu, wenn du ein neues zusammengeführtes Wörterbuch möchtest.

Paare entfernen

Für {"a": 1, "b": 2, "c": 3} gibt popitem() den Wert ('c', 3) zurück. Entscheidend ist die Einfügereihenfolge, nicht die alphabetische Reihenfolge oder der größte Wert.

Eine Bestandsänderung nachvollziehen

inventory = {"pens": 10, "pads": 4}
inventory["pens"] -= 3
inventory["clips"] = 50
removed = inventory.pop("pads")

Nach dem Verkauf bleiben 7 Stifte. Das Hinzufügen der Büroklammern erzeugt einen neuen Schlüssel. Das Entfernen der Blöcke speichert 4 in removed; übrig bleibt {'pens': 7, 'clips': 50}. Der Rückgabewert von pop ermöglicht dem Programm, die entfernte Menge zu verwenden, nachdem das Paar gelöscht wurde.

Nur bei fehlendem Schlüssel einfügen

setdefault(key, default) gibt den vorhandenen Wert zurück oder fügt den Standardwert ein und gibt ihn zurück, wenn der Schlüssel fehlt. Für stock = {"apples": 12, "pears": 0, "plums": 7} fügt stock.setdefault("kiwis", 0) Kiwis ein und gibt 0 zurück. stock.setdefault("apples", 99) gibt 12 zurück und lässt den Wert für Äpfel unverändert. Dieses Einfügen unterscheidet die Methode von get.

Beim Aktualisieren eines vorhandenen Schlüssels bleibt sein Platz unverändert. Ausgehend von {"a": 1, "b": 2, "c": 3} bleibt "a" nach d["a"] = 10 an erster Stelle. Löschst du "a" und fügst es erneut ein, steht es nach "c". Ein Ersatzwert und ein neu eingefügtes Paar wirken sich unterschiedlich auf die Reihenfolge aus.

Wähle eine Schleife, die dir den benötigten Teil jedes Paars liefert. Ein Wörterbuch allein liefert Schlüssel. Seine Ansichten können Werte oder ganze Paare liefern, sodass du Informationen nicht erst ermitteln musst, die dir die Schleife direkt geben kann.

Schlüssel, Werte oder Paare durchlaufen

temps = {"Mon": 68, "Tue": 75, "Wed": 71}
for day, temp in temps.items():
    print(day, temp)

Die Temperaturen sind in Grad Fahrenheit angegeben. Dies gibt Mon 68, Tue 75 und Wed 71 in getrennten Zeilen und in Einfügereihenfolge aus. Jeder Eintrag ist ein Tupel mit zwei Elementen, das die Schleife in day und temp entpackt.

Bei for day in temps: verwendest du innerhalb der Schleife temps[day], wenn du den zugehörigen Wert brauchst. Benötigt das Programm jedes Mal beide Teile, macht .items() die Aufgabe meist deutlicher.

Ansichten verstehen

keys(), values() und items() geben Ansichten zurück, die spätere Änderungen an ihrem Wörterbuch widerspiegeln. Sie sind keine Listen und erlauben keinen Zugriff über Positionsindizes. temps.keys()[0] löst TypeError aus. Wandle die Ansicht in eine Liste um, wenn du eine Momentaufnahme mit Positionen brauchst: list(temps) ergibt ['Mon', 'Tue', 'Wed'].

Eine Summe berechnen oder einen zugehörigen Schlüssel finden

sum(temps.values()) gibt 214 zurück, und die Division durch len(temps) ergibt ein arithmetisches Mittel von etwa 71,33. max(temps.values()) gibt 75 zurück. Um den Tag mit diesem Wert zu finden, schreibe max(temps, key=temps.get). Das ergibt 'Tue'.

Das Argument key= gibt eine Funktion vor, die für den Vergleich verwendet wird. Hier durchläuft Python die Tagesschlüssel und ruft für jeden temps.get auf, um die zugehörige Temperatur zu erhalten. Schreibe den Funktionsnamen, ohne die Funktion aufzurufen: temps.get, nicht temps.get(). Bei gleichen Werten gibt max den zuerst gefundenen Schlüssel zurück.

Einen Bericht sortieren

sorted(temps) gibt Schlüssel in alphabetischer Reihenfolge zurück. sorted(temps.items()) gibt nach Schlüsseln sortierte Paare zurück. Um Tagesschlüssel nach Temperatur zu sortieren, verwende sorted(temps, key=temps.get). Das ergibt ['Mon', 'Wed', 'Tue']. Ergänze reverse=True für ['Tue', 'Wed', 'Mon']. Diese Aufrufe geben Listen zurück; sie ordnen temps nicht um.

grades = {"Ana": 88, "Ben": 72, "Cara": 95}
passing = 0
for name, grade in grades.items():
    print(f"{name}: {grade}")
    if grade >= 75:
        passing += 1

Der Bericht gibt jeden Namen mit der zugehörigen Punktzahl aus. Ana und Cara erreichen den Schwellenwert, also ist passing am Ende gleich 2.

Einträge entfernen, ohne den Durchlauf zu stören

Füge keine Schlüssel hinzu und lösche keine, während du ein Wörterbuch direkt durchläufst. Eine Änderung seiner Größe kann RuntimeError: dictionary changed size during iteration auslösen. Einen vorhandenen Wert zu ersetzen ist erlaubt.

Um kühlere Tage zu entfernen, verwende for day in list(temps): und lösche temps[day], wenn der Wert unter 70 liegt. Die Schleife durchläuft eine separate Liste von Schlüsseln; im Wörterbuch bleibt {'Tue': 75, 'Wed': 71} übrig. Ein neues gefiltertes Wörterbuch zu erstellen ist eine weitere Möglichkeit, den Durchlauf von den Änderungen zu trennen.

Ein neues Wörterbuch entsteht oft durch eine Regel, die auf vorhandene Daten angewendet wird. Beginne mit einer Schleife, die du erklären kannst, und verwende dann eine Comprehension, wenn dieselbe Regel klar in einen Ausdruck passt.

Ein Paar nach dem anderen erstellen

words = ["kiwi", "fig", "banana"]
lengths = {}
for word in words:
    lengths[word] = len(word)

Jeder Durchlauf wählt ein Wort als Schlüssel und seine Länge als Wert. Das Ergebnis ist {'kiwi': 4, 'fig': 3, 'banana': 6}. Das Wörterbuch wird vor der Schleife erstellt, damit frühere Paare bei späteren Durchläufen erhalten bleiben.

Eine Dictionary Comprehension drückt dieselbe Arbeit aus:

lengths = {word: len(word) for word in words}

Lies den for-Teil, um zu sehen, was durchlaufen wird, und dann den Ausdruck davor, um zu sehen, welches Paar entsteht. Der Doppelpunkt trennt den Schlüsselausdruck vom Wertausdruck. Ohne diesen Doppelpunkt erstellt {word for word in words} eine Menge.

Bestimmte Einträge behalten

Eine if-Klausel filtert die Eingabe:

grades = {"Ana": 88, "Ben": 72, "Cara": 95}
high_grades = {
    name: grade
    for name, grade in grades.items()
    if grade >= 80
}

Ana und Cara erfüllen die Bedingung. Das ergibt {'Ana': 88, 'Cara': 95}. Bens Paar wird weggelassen. Das Eingabewörterbuch bleibt unverändert; das Ergebnis enthält nur Paare, die die Bedingung erfüllen.

Werte umwandeln

Eine Comprehension kann die Tage beibehalten und zugleich Fahrenheit-Messwerte in Celsius umrechnen:

temps = {"Mon": 68, "Tue": 75, "Wed": 71}
celsius = {
    day: round((f - 32) * 5 / 9, 1)
    for day, f in temps.items()
}

Das Ergebnis ist {'Mon': 20.0, 'Tue': 23.9, 'Wed': 21.7}. Für Dienstag ergibt die Subtraktion von 32 den Wert 43; die Multiplikation mit 5 und die Division durch 9 ergeben etwa 23,89. round(..., 1) speichert 23,9. Der Schlüssel bleibt gleich, während sich der Wert ändert.

Listen sorgfältig paaren

dict(zip(names, scores)) verbindet jeden Namen mit der Punktzahl an derselben Position. zip endet, wenn die kürzere Eingabe endet. Die Verbindung von ["Ana", "Ben", "Cara"] mit [90, 85] ergibt {'Ana': 90, 'Ben': 85}. Keine Fehlermeldung weist auf Caras fehlende Punktzahl hin. Prüfe daher die Länge der Eingaben, wenn jeder Name eine Punktzahl haben muss.

Schlüssel und Werte vertauschen

favorites = {"Ana": "blue", "Ben": "red", "Cara": "blue"}
by_color = {color: name for name, color in favorites.items()}

Das Ergebnis ist {'blue': 'Cara', 'red': 'Ben'}. Ana und Cara bräuchten beide denselben neuen Schlüssel, daher ersetzt Caras späteres Paar das von Ana. Das Umkehren erhält nur dann alle Paare, wenn die alten Werte eindeutig und hashbar sind. Ein Listenwert kann überhaupt kein Wörterbuchschlüssel werden. Um mehrere Namen unter einer Farbe zu behalten, speichere unter dieser Farbe eine Liste von Namen.

Verwende eine gewöhnliche Schleife, wenn die Aufgabe mehrere Anweisungen, Meldungen oder Prüfungen benötigt. Eine Comprehension ist nützlich, weil sie eine kurze Regel sichtbar macht; zwängst du einen größeren Ablauf hinein, wird die Regel schwerer nachvollziehbar.

Eine Häufigkeitstabelle beantwortet, wie oft jedes unterschiedliche Element vorkommt. Ihre Schlüssel bezeichnen die Elemente; ihre Werte sind Zähler. Das Wörterbuch wächst, wenn ein neues Element erscheint, während spätere Vorkommen einen vorhandenen Zählwert erhöhen.

Einen Zähler nachvollziehen

counts = {}
for letter in "banana":
    if letter in counts:
        counts[letter] += 1
    else:
        counts[letter] = 1

Der erste Buchstabe erzeugt 'b': 1. Der nächste erzeugt 'a': 1 und dann folgt 'n': 1. Das nächste "a" erhöht seinen vorhandenen Zählwert auf 2. Nach den letzten beiden Buchstaben ist das Wörterbuch {'b': 1, 'a': 3, 'n': 2}. Seine Reihenfolge hält fest, wann jeder Buchstabe zuerst auftrat, nicht welcher Buchstabe am häufigsten ist.

Vor dem ersten Auftreten null verwenden

Die beiden Zweige können zu einer Zuweisung werden:

counts = {}
for letter in "banana":
    counts[letter] = counts.get(letter, 0) + 1

Die rechte Seite liest den bisherigen Zählwert, verwendet bei einem fehlenden Schlüssel null und addiert dann eins. Die linke Seite speichert den neuen Zählwert. get selbst fügt nichts ein; das erledigt die Zuweisung.

Wird nur counts[letter] += 1 verwendet, schlägt dies bei einem neuen Buchstaben fehl. Verschiebst du counts = {} in die Schleife, entsteht ein anderes Problem: Jeder Durchlauf löscht die bisherigen Zählwerte. Initialisiere das Wörterbuch einmal vor der Verarbeitung der Elemente.

Entscheiden, was als dasselbe Wort zählt

Bei Text beeinflussen Groß- und Kleinschreibung sowie Satzzeichen die Schlüssel. Die Zeichenketten "The" und "the" unterscheiden sich ebenso wie "dog." und "dog". Bereinige die Formen, bevor du sie als Schlüssel verwendest:

text = "The cat saw the dog. The dog ran."
counts = {}
for word in text.lower().split():
    word = word.strip(".,!?")
    counts[word] = counts.get(word, 0) + 1

Dies ergibt {'the': 3, 'cat': 1, 'saw': 1, 'dog': 2, 'ran': 1}. lower vereinheitlicht die Groß- und Kleinschreibung, split trennt Wörter an Leerraumzeichen und strip entfernt die aufgeführten Satzzeichen an den Rändern. Satzzeichen innerhalb eines Wortes entfernt die Methode nicht.

Die häufigsten Elemente finden

Für diese nicht leere Tabelle gibt max(counts, key=counts.get) den Wert 'the' zurück. Um die zwei häufigsten Wörter zu finden, verwende sorted(counts, key=counts.get, reverse=True)[:2]. Das ergibt ['the', 'dog']. Gleiche Zählwerte behalten beim Sortieren ihre ursprüngliche Reihenfolge.

Das Muster zählt auch Zahlen oder Tupel. Für die Würfelergebnisse [3, 6, 3, 1, 6, 3] erstellt es {3: 3, 6: 2, 1: 1}. Ein nie beobachteter Wert hat keinen Eintrag. Lies ihn mit dem Standardwert null, wenn das nützlich ist.

Die Abkürzung aus der Bibliothek kennenlernen

from collections import Counter
letter_counts = Counter("banana")
print(letter_counts.most_common(1))
print(letter_counts["z"])

Dies gibt [('a', 3)] und danach 0 aus. Der Import macht Counter aus Pythons Standardbibliothek verfügbar. Ein Counter ist ein Wörterbuch, das zum Zählen bestimmt ist: Seine Schlüssel sind hashbare Elemente, und der direkte Zugriff auf ein fehlendes Element gibt null zurück. Die angezeigten Zählwerte für diese Eingabe sind Counter({'a': 3, 'n': 2, 'b': 1}).

Ein Wörterbuch kann unter jedem Schlüssel eine ganze Gruppe speichern. Der Schlüssel benennt die Kategorie, und eine Liste enthält die ihr zugeordneten Elemente. So bleibt jedes Mitglied für spätere Summen, arithmetische Mittel oder Berichte verfügbar.

Separate Listen für Gruppen erstellen

words = ["apple", "bean", "avocado", "beet", "corn"]
groups = {}
for word in words:
    first = word[0]
    if first not in groups:
        groups[first] = []
    groups[first].append(word)

Für "apple" erstellt das Programm unter "a" eine leere Liste und hängt das Wort an. "bean" beginnt eine separate Liste unter "b". "avocado" wird der vorhandenen Liste unter "a" hinzugefügt. Das Ergebnis ist {'a': ['apple', 'avocado'], 'b': ['bean', 'beet'], 'c': ['corn']}.

Die leere Liste wird nur für eine neue Bezeichnung erstellt. Würde sie bei jedem Durchlauf erstellt, gingen die bisherigen Mitglieder dieser Gruppe verloren.

Die Initialisierung verkürzen

groups.setdefault(word[0], []).append(word) führt denselben Gruppierungsschritt aus. setdefault gibt die vorhandene Liste zurück, falls es eine gibt. Andernfalls speichert es die angegebene leere Liste und gibt sie zurück. Das folgende append verändert diese zurückgegebene Liste.

Eine andere Möglichkeit erstellt Listen automatisch:

from collections import defaultdict
groups = defaultdict(list)
for word in words:
    groups[word[0]].append(word)

Übergib list, die Funktion zum Erstellen einer neuen Liste, ohne Klammern. Beim Zugriff auf einen fehlenden Schlüssel erstellt und speichert dieses defaultdict eine neue leere Liste. Selbst ein lesender Zugriff wie groups["z"] fügt diesen fehlenden Schlüssel ein. Verwende "z" in groups, wenn du nur prüfen möchtest, ob eine Gruppe existiert.

Die Listen unabhängig halten

groups = dict.fromkeys(["a", "b"], []) legt dieselbe Liste unter beiden Schlüsseln ab. Das Anhängen von 1 über groups["a"] ergibt dann {'a': [1], 'b': [1]}. Beide Schlüssel referenzieren dieselbe Liste; sie wird nicht kopiert.

Um mit separaten Listen zu beginnen, verwende {key: [] for key in keys}, setdefault mit einer neuen [] oder defaultdict(list). Jede neue Kategorie muss ein eigenes Listenobjekt erhalten.

Beträge pro Kategorie addieren

Beim Zählen wird pro Vorkommen eins addiert. Eine Kategoriesumme addiert den Betrag jedes Elements:

expenses = [("food", 12.5), ("travel", 30),
            ("food", 7.25), ("books", 18)]
totals = {}
for category, amount in expenses:
    totals[category] = totals.get(category, 0) + amount

Lebensmittel beginnen bei 12,5; dann kommen 7,25 hinzu, sodass sich 19,75 ergeben. Für Reisen beträgt die Summe 30 und für Bücher 18. Würde nur amount gespeichert, ersetzte das die vorherige Summe, statt den Betrag zu addieren.

Das arithmetische Mittel einer Gruppe berechnen oder Duplikate entfernen

Für scores = {"A": [80, 90], "B": [70]} durchlaufe scores.items() und berechne sum(values) / len(values). Das arithmetische Mittel von Gruppe A ist 85,0, das von Gruppe B 70,0. Prüfe vor der Division if values:, damit eine leere Gruppe gesondert behandelt wird.

Sollen Wiederholungen innerhalb jeder Gruppe verschwinden, verwende Mengen als Werte. tags.setdefault(post, set()).add(tag) erstellt eine Menge für einen neuen Beitrag und fügt dessen Markierung hinzu. Eine wiederholte Markierung bleibt ein Element; eine Liste würde jedes Vorkommen behalten.

Ein Datensatz fasst zusammengehörige Felder zusammen, etwa Alter, Studienfach und Noten eines Studierenden. Ein verschachteltes Wörterbuch speichert ein anderes Wörterbuch als Wert. Die äußeren Schlüssel können Datensätze bezeichnen, während die inneren Schlüssel Felder bezeichnen.

Eine Ebene nach der anderen lesen

students = {
    "ana": {"age": 19, "major": "math", "grades": [88, 92]},
    "ben": {"age": 22, "major": "history", "grades": [75, 81, 79]},
}

students["ana"] liefert Anas Datensatz als Wörterbuch. Ergänzt du ["major"], wird das Studienfach daraus gelesen. students["ana"]["major"] gibt also 'math' zurück. Für Bens neueste Note gelangt students["ben"]["grades"][-1] zum Datensatz, dann zu dessen Liste und schließlich zum letzten Listenelement 79.

Jeder Zugriff wirkt auf das Objekt, das der vorherige Zugriff zurückgegeben hat. Dieselbe Schreibweise mit eckigen Klammern kann auf einer Ebene einen Wörterbuchschlüssel und auf einer anderen eine Listenposition bezeichnen.

Ein Feld ändern oder einen Datensatz hinzufügen

students["ana"]["age"] = 20
students["ben"]["email"] = "ben@example.com"
students["cara"] = {"age": 21, "major": "art", "grades": []}
students["cara"]["grades"].append(90)

Die ersten beiden Zeilen ändern Felder in vorhandenen Datensätzen oder fügen welche hinzu. Die dritte fügt einen ganzen Datensatz unter einer neuen ID hinzu. Die vierte greift auf Caras Notenliste zu und hängt eine Punktzahl an.

Die Zuweisung students["dev"]["age"] = 30 schlägt fehl, weil der äußere Zugriff auf "dev" zuerst erfolgt und KeyError: 'dev' auslöst. Erstelle den Datensatz, bevor du seinen Feldern Werte zuweist.

Für einen optionalen Zugriff gibt students.get("dev", {}).get("age") den Wert None zurück. Der erste Standardwert ist ein leeres Wörterbuch, sodass das zweite get ein Wörterbuch zum Lesen erhält, auch wenn der Datensatz fehlt. Bei diesen Datensätzen ist jeder äußere Wert selbst ein Wörterbuch.

Eine zum Zugriff passende Struktur wählen

Eine Liste von Wörterbüchern bewahrt die Reihenfolge der Zeilen:

rows = [{"name": "Ana", "city": "Austin"},
        {"name": "Ben", "city": "Denver"}]
print(rows[1]["city"])

Dies gibt Denver aus: zuerst der Listenindex, dann der Feldschlüssel. Ein Wörterbuch von Listen wie {"A": [80, 90], "B": [70]} speichert mehrere Werte pro Bezeichnung. Diese Strukturen lassen sich kombinieren, wenn ein Datensatz sowohl benannte Felder als auch eine geordnete Liste benötigt.

Wenn Namen Zeilen eindeutig bezeichnen, erstelle by_name = {row["name"]: row for row in rows}. Dann findet by_name["Ben"] Bens Zeile direkt. Die Werte sind die vorhandenen Zeilenwörterbücher, sodass Änderungen über diesen Index auch diese Zeilen betreffen. Wiederholen sich Namen, ersetzt eine spätere Zeile eine frühere unter demselben Schlüssel.

Verschachtelte Daten bewusst kopieren

backup = students referenziert dasselbe Wörterbuch. backup = students.copy() erstellt ein separates äußeres Wörterbuch, behält aber dieselben inneren Datensätze bei. Nach dieser flachen Kopie ändert backup["ana"]["age"] = 99 auch Anas Alter in students.

import copy
independent = copy.deepcopy(students)
independent["ana"]["age"] = 25

Bei diesen verschachtelten Wörterbüchern und Listen erstellt die tiefe Kopie auch separate innere Objekte. Eine Änderung des kopierten Alters lässt das ursprüngliche Alter unverändert. Verwende einheitliche Feldnamen in allen Datensätzen, damit derselbe Zugriffscode für jeden Datensatz funktioniert.

Beim Verarbeiten verschachtelter Daten musst du im Blick behalten, welche Ebene die Schleife erreicht hat. Eine äußere Schleife wählt einen Datensatz. Ein Feldzugriff erreicht einen Wert innerhalb dieses Datensatzes, und eine innere Schleife kann dann die Elemente einer gespeicherten Liste durchlaufen.

Pro Durchlauf einen Datensatz zusammenfassen

students = {
    "ana": {"major": "math", "grades": [88, 92]},
    "ben": {"major": "history", "grades": [75, 81, 79]},
    "cara": {"major": "art", "grades": []},
}
for name, info in students.items():
    grades = info["grades"]
    major = info["major"]
    if grades:
        average = sum(grades) / len(grades)
        print(f"{name}: {major}, average {average:.1f}")
    else:
        print(f"{name}: {major}, no grades")

Anas Punktzahlen ergeben zusammen 180, also beträgt ihr arithmetisches Mittel 90,0. Bens drei Punktzahlen ergeben zusammen 235 und damit etwa 78,33 im Mittel; das Format :.1f zeigt 78,3 an. Caras Liste ist leer, daher gibt das Programm cara: art, no grades aus, ohne durch null zu dividieren.

Die Zuweisung von grades und major innerhalb der Schleife gibt jedem Namen die Werte des aktuellen Datensatzes. Auch das arithmetische Mittel gehört in die Schleife: Es muss für jeden Studierenden separat berechnet werden.

Optionale Felder lesen

info.get("email", "no email") liefert einen Text für ein optionales E-Mail-Feld. Ein direkter Zugriff mit info["email"] würde bei einem Datensatz ohne dieses Feld KeyError auslösen. Ein Standardwert gehört auf die Ebene, auf der das Feld fehlen kann. get auf dem äußeren Wörterbuch würde nach Studierenden-IDs suchen, nicht nach E-Mail-Feldern.

Datensätze auswählen

math_students = []
for name, info in students.items():
    if info["major"] == "math":
        math_students.append(name)

Dies ergibt ['ana']. Die Bedingung liest ein Feld des aktuellen Datensatzes; der angehängte Wert ist der äußere Schlüssel. Benötigte der Bericht ganze Datensätze, könnte er stattdessen info anhängen. Entscheide, welche Art von Ergebnis der nächste Programmteil benötigt.

Jede gespeicherte Punktzahl durchlaufen

count = 0
for info in students.values():
    for grade in info["grades"]:
        if grade > 80:
            count += 1

Die innere Schleife durchläuft Anas 88 und 92, dann Bens 75, 81 und 79. Caras leere Liste führt zu keinem weiteren Durchlauf. Drei Punktzahlen liegen über 80: 88, 92 und 81. Der Zähler wird außerhalb beider Schleifen initialisiert, weil er alle Studierenden zusammen erfasst. Würde er innerhalb der äußeren Schleife zurückgesetzt, bliebe nur der Zählwert des letzten Datensatzes erhalten.

Datensätze nach einem Feld zählen

majors = {}
for info in students.values():
    major = info["major"]
    majors[major] = majors.get(major, 0) + 1

Jeder Datensatz erhöht den Zählwert seines Studienfachs um eins. Für Ana und Ben allein ist das Ergebnis {'math': 1, 'history': 1}; mit Cara kommt 'art': 1 hinzu. Um ein anderes Feld zu summieren oder zu gruppieren, behalte die äußere Schleife über die Datensätze bei und ändere den Wert, den sie beiträgt.

Gib für lesbare Berichte pro Datensatz eine formatierte Zeile aus statt des gesamten verschachtelten Wörterbuchs. Speichere in einem f-String ein Feld zunächst wie oben in einer Variablen oder verwende innerhalb der geschweiften Klammern die andere Art von Anführungszeichen, wie in f"{name}: {info['major']}".

Eine Menge hält fest, welche unterschiedlichen Werte vorhanden sind. Sie enthält jedes Element einmal und hat keine garantierte Reihenfolge. Mengen eignen sich für Zugehörigkeitsprüfungen und zum Entfernen von Duplikaten, wenn die Anzahl der Vorkommen keine Rolle spielt.

Eine Menge erstellen

colors = {"red", "green"}
numbers = set([3, 1, 3, 2, 1])
print(len(numbers))
print(sorted(numbers))

Dies gibt 3 und danach [1, 2, 3] aus. Wiederholte Eingaben werden zu einem einzigen Element. Eine leere Menge ist set(); {} erzeugt ein leeres Wörterbuch.

set("banana") durchläuft die Zeichen der Zeichenkette und lässt die unterschiedlichen Buchstaben "a", "b" und "n" übrig. {"banana"} übergibt die ganze Zeichenkette als ein Element. Wie bei Wörterbuchschlüsseln zählen gleiche numerische Werte nur einmal: {1, 1.0, True} hat ein Element.

Elemente müssen hashbar sein. Zahlen, Zeichenketten und Tupel aus hashbaren Werten funktionieren; Listen, Wörterbücher und gewöhnliche Mengen nicht. Verwende für ein Koordinatenelement (1, 2) statt [1, 2]. Ein frozenset ist eine unveränderliche Menge und kann selbst ein Mengenelement oder Wörterbuchschlüssel sein.

Ohne Positionen arbeiten

colors[0] löst TypeError aus, weil eine Menge keine Positionen hat. Ihre Ausgabereihenfolge ist nicht garantiert, und Zeichenkettenelemente können bei einem anderen Programmlauf in anderer Reihenfolge erscheinen. sorted(colors) erzeugt eine neue sortierte Liste, wenn die Elemente vergleichbar sind. Die Menge selbst erhält dadurch keine Reihenfolge.

Elemente verändern

add("blue") fügt eine Zeichenkette hinzu. update(["blue", "gold"]) fügt zwei Zeichenketten hinzu. update("blue") fügt dagegen einzelne Zeichen hinzu, weil eine Zeichenkette iterierbar ist. Mengen haben keine Methode append.

Bei Bedarf die Reihenfolge des ersten Auftretens bewahren

list(set(items)) entfernt Duplikate, verliert aber ihre ursprüngliche Reihenfolge. Ist die Reihenfolge des ersten Auftretens wichtig, nutze die Einfügereihenfolge eines Wörterbuchs:

items = [3, 1, 3, 2, 1]
unique = list(dict.fromkeys(items))
print(unique)

Dies gibt [3, 1, 2] aus. Die Werte werden zu Wörterbuchschlüsseln, sodass jeder einmal in der Reihenfolge seines ersten Auftretens erscheint.

Du kannst die Aufgaben auch ausdrücklich trennen:

seen = set()
unique = []
for item in items:
    if item not in seen:
        seen.add(item)
        unique.append(item)

Die Menge beantwortet, ob ein Element bereits aufgetreten ist; die Liste bewahrt die Reihenfolge des ersten Auftretens. Beide Formen setzen hashbare Eingabeelemente voraus.

Unterschiedliche Elemente zählen oder Zugehörigkeit prüfen

Für die acht Wörter in "the cat saw the dog the dog ran".split() ist len(set(words)) gleich 5: the, cat, saw, dog und ran. Das zählt unterschiedliche Wörter, nicht ihre Häufigkeiten.

Mit einer Menge blockierter Absender beantwortet sender in blocked, ob eine Adresse enthalten ist. Bei großen Sammlungen ist die Zugehörigkeitsprüfung in Mengen und Wörterbüchern üblicherweise viel schneller als das einzelne Durchsuchen einer Liste.

Mengenoperationen drücken Fragen zur Zugehörigkeit in zwei Sammlungen aus. Verwende die Operation, die zur Frage passt: Personen in mindestens einer Sammlung, nur gemeinsame Mitglieder oder Mitglieder, die nach Ausschlüssen übrig bleiben.

Die vier Operationen lesen

Angenommen, die Kursteilnahmen sind:

python = {"Ana", "Ben", "Cara", "Dev"}
sql = {"Ben", "Dev", "Eli"}

Die Vereinigungsmenge enthält alle fünf Studierenden jeweils einmal. Die Schnittmenge enthält nur die beiden gemeinsamen Studierenden. Die Differenzmenge geht von der linken Menge aus und schließt alles aus, was in der rechten Menge liegt. Wird die Differenz umgekehrt, ändert sich die Frage: sql - python enthält nur Eli. Die symmetrische Differenz enthält die beiden nicht überlappenden Teile; sie entspricht der Vereinigungsmenge abzüglich der Schnittmenge.

Die benannten Formen sind python.union(sql), python.intersection(sql), python.difference(sql) und python.symmetric_difference(sql).

Eine Beziehung prüfen

a <= b fragt, ob jedes Element von a zu b gehört. Das ist die Teilmengenprüfung. a < b verlangt außerdem, dass b mindestens ein weiteres Element enthält. Damit ist a eine echte Teilmenge. a >= b und a > b prüfen die entsprechenden Obermengenbeziehungen.

print({"Ben"} <= sql)
print(sql <= sql)
print(sql < sql)
print(python.isdisjoint(sql))

Diese Anweisungen geben True, True, False und False aus. Eine Menge ist eine Teilmenge ihrer selbst, aber keine echte Teilmenge ihrer selbst. Disjunkte Mengen haben kein gemeinsames Element; Python und SQL haben Ben und Dev gemeinsam. Auch die Methodenformen issubset und issuperset geben boolesche Ergebnisse zurück.

Ergebnisse getrennt halten oder eine Menge verändern

result = a | b erstellt eine neue Menge und lässt beide Eingaben unverändert. Die Formen zur direkten Veränderung a |= b, a &= b, a -= b und a ^= b ändern a zur Vereinigungsmenge, Schnittmenge, Differenzmenge beziehungsweise symmetrischen Differenz. Jeder andere Name, der auf dieselbe Menge verweist, sieht die Änderung.

Benannte Mengenmethoden akzeptieren iterierbare Objekte wie Listen. python.union(["Fay"]) funktioniert. Die gewöhnlichen Mengenoperatoren benötigen Mengen als Operanden: {"a"} | ["b"] löst TypeError aus.

Verwende |, um Mengen zu verbinden, nicht +. Unterscheide außerdem & von and: {1, 2} and {3} gibt {3} zurück, weil die linke Menge als wahr ausgewertet wird. Gemeinsame Elemente werden nicht berechnet.

Fehlende Anforderungen finden

required = {"python", "sql", "git"}
skills = {"python", "excel", "git"}
missing = required - skills
extra = skills - required
qualified = required <= skills

Die Menge der fehlenden Fähigkeiten enthält "sql"; die Menge der zusätzlichen Fähigkeiten enthält "excel". Die Schnittmenge enthält "git" und "python". qualified ist False, weil mindestens eine erforderliche Fähigkeit fehlt. Ein Bewerber kann viele Fähigkeiten haben und dennoch die Teilmengenprüfung nicht bestehen: Alle konkret geforderten Elemente müssen vorhanden sein.

Wähle eine Sammlung nach der Aufgabe, die das Programm damit erledigen muss. Reihenfolge, Wiederholungen, Nachschlagen über Namen und Veränderlichkeit sind unterschiedliche Anforderungen. Ein Programm kann mehrere Sammlungstypen verwenden, weil verschiedene Teile seiner Daten unterschiedlichen Zwecken dienen.

Die eingebauten Sammlungen vergleichen

Eine Liste eignet sich für eine Folge von Ereignissen: Die Reihenfolge ist wichtig, und dasselbe Ereignis kann mehrmals auftreten. Ein Tupel eignet sich für eine feste Gruppe zusammengehöriger Werte, etwa Koordinaten. Ein Tupel kann ein veränderliches Objekt enthalten, sodass die festen Plätze des Tupels nicht jedes enthaltene Objekt unveränderlich machen. Nur ein Tupel aus hashbaren Elementen kann ein Wörterbuchschlüssel oder Mengenelement sein.

Ein Wörterbuch eignet sich für benannte Informationen: Eine ID führt zu einem Datensatz oder ein Produktname zu einer Menge. Seine Werte können sich wiederholen und ganze Sammlungen sein. Eine Menge eignet sich für eine Zugehörigkeitsfrage: Das Programm muss wissen, ob eine ID vorhanden ist, und braucht keinen separaten Wert dafür.

Die für die Aufgabe nötigen Informationen bewahren

Die Umwandlung von [1, 2, 1] in eine Menge verliert sowohl das wiederholte Vorkommen als auch die Reihenfolge. Für eine Liste unterschiedlicher Elemente ist das nützlich, für ein vollständiges Ereignisprotokoll aber falsch. Ein Wörterbuch wie {"reader": True, "editor": True} kann oft zu {"reader", "editor"} werden, wenn die Werte keine zusätzlichen Informationen enthalten. Benötigt jede Rolle eine Berechtigungsstufe, behalte das Wörterbuch.

Für die Gleichheit ist die Bedeutung jeder Sammlung entscheidend. [1, 2] == [2, 1] ist False, weil die Reihenfolge der Sequenzen unterschiedlich ist. {1, 2} == {2, 1} ist True. Wörterbücher mit gleichen Schlüssel-Wert-Paaren sind beim Vergleich gleich, auch wenn die Schlüssel in unterschiedlicher Reihenfolge eingefügt wurden. Ihre Einfügereihenfolge wirkt sich auf das Durchlaufen aus, nicht auf diesen Gleichheitstest.

Wörterbuchschlüssel als Mengen vergleichen

store_a = {"pens": 10, "pads": 4, "ink": 2}
store_b = {"pads": 7, "clips": 30, "ink": 5}
common = store_a.keys() & store_b.keys()
only_a = store_a.keys() - store_b.keys()

Die gemeinsamen Schlüssel sind "ink" und "pads"; only_a enthält "pens". Dies sind geführte Produkte, unabhängig von ihren Mengen. Die beiden Geschäfte haben unterschiedliche Mengen an Tinte, aber Tinte ist dennoch ein gemeinsamer Schlüssel.

Schlüsselansichten von Wörterbüchern unterstützen Mengenoperationen, weil Schlüssel eindeutig und hashbar sind. Wertansichten unterstützen diese Operatoren nicht: store_a.values() & {1} löst TypeError aus. Werte lassen sich in eine Menge umwandeln, wenn sie hashbar sind. Dabei gehen aber wiederholte Werte verloren, und die Frage unterscheidet sich vom Vergleich der Produktschlüssel.

Strukturen in einem Programm kombinieren

Eine Bibliothek kann ein Wörterbuch verwenden, das Buch-IDs Datensatzwörterbüchern zuordnet, dazu eine Menge der aktuell ausgeliehenen IDs und eine Liste der heutigen Ausleihen in zeitlicher Reihenfolge. Ein Tupel wie ("Dune", 1965) hält einen Titel und ein Jahr zusammen. Das Wörterbuch findet die Details eines Buches; die Menge prüft den Ausleihstatus; die Liste bewahrt den Tagesverlauf.