Dictionaries in Python (dict): Anlegen, Methoden, Durchlaufen, Sortieren und frozendict

Ein Dictionary in Python (dict) ist eine Sammlung von Paaren aus „Schlüssel und Wert“. Den Wert finden Sie über seinen Schlüssel praktisch sofort, egal wie viele Einträge vorhanden sind. Wollen Sie Ausgaben nach Kategorien summieren, Einstellungen speichern oder einen Benutzer über seine ID schnell finden, nehmen Sie ein Dictionary. Im Folgenden finden Sie alles, was Sie für die Arbeit mit dem Python-dict brauchen: Anlegen, Methoden, Durchlaufen, Sortieren, Zusammenführen und die Neuheit aus 3.15, frozendict.

Was ein Dictionary in Python ist

Ein Dictionary speichert Paare, deren Schlüssel eindeutig ist: Schreiben Sie einen Wert unter einem vorhandenen Schlüssel, wird der alte Wert ersetzt. Intern handelt es sich um eine Hashtabelle. Deshalb laufen Suche, Hinzufügen und Löschen über einen Schlüssel im Mittel in konstanter Zeit und nicht durch Durchsuchen.

Als Schlüssel ist nur ein hashbares Objekt zulässig, etwa ein String, eine Zahl oder ein Tupel aus unveränderlichen Werten. Eine Liste kann kein Schlüssel sein, Sie erhalten dann TypeError: unhashable type: 'list'. Werte dagegen dürfen beliebig sein, auch andere Dictionaries oder Listen.

Seit Python 3.7 merkt sich ein Dictionary garantiert die Einfügereihenfolge: Beim Durchlaufen erhalten Sie die Schlüssel in der Reihenfolge, in der Sie sie hinzugefügt haben.

So legen Sie ein Dictionary an

Es gibt mehrere Wege, ein Dictionary anzulegen, alle kommen im echten Code vor.

spent = {"Essen": 1200, "Taxi": 450}       # Literal
empty = {}                                 # leeres Dictionary
also_empty = dict()                        # dasselbe über die Funktion dict
user = dict(name="Anna", age=30)           # benannte Argumente
pairs = dict([("a", 1), ("b", 2)])         # aus einer Liste von Paaren
keys = dict.fromkeys(["x", "y"], 0)        # {'x': 0, 'y': 0}

Beachten Sie: Leere geschweifte Klammern {} erzeugen ein leeres Dictionary, keine Menge. Eine leere Menge entsteht nur mit set().

Ein praktischer Weg, aus zwei Listen ein Dictionary zu bauen, ist zip:

names = ["Essen", "Taxi", "Kino"]
sums = [1200, 450, 600]
spent = dict(zip(names, sums))
print(spent)   # {'Essen': 1200, 'Taxi': 450, 'Kino': 600}

Zugriff über den Schlüssel: d[k] und get

Einen Wert lesen Sie mit eckigen Klammern. Fehlt der Schlüssel, wirft Python einen KeyError. Um keinen Fehler zu bekommen, verwenden Sie die Methode get: Sie liefert None oder den angegebenen Standardwert.

spent = {"Essen": 1200}
print(spent["Essen"])            # 1200
print(spent.get("Kino"))         # None
print(spent.get("Kino", 0))      # 0
spent["Kino"]                    # KeyError: 'Kino'

Ob ein Schlüssel vorhanden ist, prüfen Sie mit dem Operator in: "Essen" in spent liefert True. Der Operator prüft nur Schlüssel, nicht Werte. Für Werte schreiben Sie 1200 in spent.values().

Hinzufügen, Ändern und Löschen

Einen Eintrag hinzufügen oder aktualisieren Sie mit einer einzigen Zuweisung. Für Zählungen ist die Kombination mit get sehr praktisch:

spent = {}
for category, amount in [("Essen", 250), ("Taxi", 300), ("Essen", 400)]:
    spent[category] = spent.get(category, 0) + amount
print(spent)   # {'Essen': 650, 'Taxi': 300}

Einen Schlüssel entfernen Sie mit del d[k], das bei fehlendem Schlüssel einen KeyError auslöst, oder mit d.pop(k, default), das den Wert zusätzlich zurückgibt. Das ganze Dictionary leeren Sie mit d.clear(). Die Länge, also die Anzahl der Paare, erhalten Sie mit len(d).

Methoden von Dictionaries: Spickzettel

setdefault: Dictionary mit Listen füllen

Die Methode setdefault hilft, wenn die Werte Listen sind und Sie gruppieren möchten:

groups = {}
for item, cat in [("Kaffee", "Essen"), ("U-Bahn", "Verkehr"), ("Pizza", "Essen")]:
    groups.setdefault(cat, []).append(item)
print(groups)   # {'Essen': ['Kaffee', 'Pizza'], 'Verkehr': ['U-Bahn']}

update: Dictionary aktualisieren

update verändert das Dictionary direkt: Neue Schlüssel werden hinzugefügt, vorhandene überschrieben.

cfg = {"debug": False, "lang": "de"}
cfg.update({"debug": True, "theme": "dark"})
print(cfg)   # {'debug': True, 'lang': 'de', 'theme': 'dark'}

defaultdict: Dictionary mit Standardwert

collections.defaultdict ist eine Unterklasse von dict. Greifen Sie auf einen fehlenden Schlüssel zu, erzeugt er den Wert selbst über eine Fabrikfunktion. Der Code für Zählungen und Gruppierungen wird dadurch kürzer.

from collections import defaultdict

spent = defaultdict(int)
for cat, amount in [("Essen", 250), ("Taxi", 300), ("Essen", 400)]:
    spent[cat] += amount
print(dict(spent))   # {'Essen': 650, 'Taxi': 300}

groups = defaultdict(list)
groups["Essen"].append("Kaffee")

Für einfaches Zählen gibt es außerdem collections.Counter: Counter(["a", "b", "a"]) ergibt Counter({'a': 2, 'b': 1}).

Dictionary durchlaufen: for-Schleife

Durchläuft man ein Dictionary mit for, geht man standardmäßig über die Schlüssel. Um Schlüssel und Wert gleichzeitig zu erhalten, durchlaufen Sie items(). Das ist die gebräuchlichste Variante.

spent = {"Essen": 650, "Taxi": 300}

for cat in spent:                    # Schlüssel
    print(cat)

for amount in spent.values():        # Werte
    print(amount)

for cat, amount in spent.items():    # Paare
    print(f"{cat}: {amount} €")

Die Größe eines Dictionaries dürfen Sie während des Durchlaufs nicht ändern, sonst erhalten Sie RuntimeError: dictionary changed size during iteration. Wenn Sie einen Teil der Schlüssel entfernen wollen, durchlaufen Sie eine Kopie: for k in list(d):.

Dictionary ausgeben

print(d) gibt das Dictionary in einer einzigen Zeile aus. Bei großen oder verschachtelten Dictionaries eignen sich das Modul pprint oder json.dumps(d, ensure_ascii=False, indent=2). Sie zeigen die Daten mit Einrückungen und ohne Escapezeichen für Umlaute an.

Dictionary sortieren

Das Dictionary selbst lässt sich nicht direkt sortieren, es hat keine Methode sort. Sortieren bedeutet hier, aus den sortierten Paaren mit sorted ein neues Dictionary zu bauen.

spent = {"Taxi": 300, "Essen": 650, "Kino": 120}

by_key = dict(sorted(spent.items()))
print(by_key)    # {'Essen': 650, 'Kino': 120, 'Taxi': 300}

by_value = dict(sorted(spent.items(), key=lambda p: p[1], reverse=True))
print(by_value)  # {'Essen': 650, 'Taxi': 300, 'Kino': 120}

Brauchen Sie nur die Top-N-Kategorien, wandeln Sie das Ergebnis nicht zurück in ein Dictionary: sorted(spent.items(), key=lambda p: p[1], reverse=True)[:2] liefert eine Liste von Paaren.

Eine Liste von Dictionaries nach einem Feld sortieren Sie so: sorted(users, key=lambda u: u["age"]).

Dictionaries zusammenführen

Seit Python 3.9 führt der Operator | Dictionaries zusammen, |= aktualisiert ein Dictionary direkt. Bei gleichen Schlüsseln gewinnt der rechte Operand.

a = {"x": 1, "y": 2}
b = {"y": 20, "z": 3}
print(a | b)          # {'x': 1, 'y': 20, 'z': 3}
print({**a, **b})     # dasselbe über Entpacken
a |= b                # wie a.update(b)

Beachten Sie: a + b funktioniert für Dictionaries nicht und ergibt einen TypeError. Wenn Sie die Werte bei gleichen Schlüsseln addieren möchten, verwenden Sie Counter: Counter(a) + Counter(b).

Dictionary entpacken

Zwei Sterne ** entpacken ein Dictionary in benannte Argumente einer Funktion oder in ein anderes Dictionary:

def greet(name, city):
    return f"{name} aus {city}"

data = {"name": "Anna", "city": "Hamburg"}
print(greet(**data))   # Anna aus Hamburg

Dictionary-Comprehension

Eine Dictionary-Comprehension erzeugt ein Dictionary in einer Zeile aus einer beliebigen Folge:

squares = {n: n * n for n in range(5)}
print(squares)   # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

big = {k: v for k, v in spent.items() if v > 200}

inverted = {v: k for k, v in {"a": 1, "b": 2}.items()}
print(inverted)  # {1: 'a', 2: 'b'}

Das letzte Beispiel zeigt, wie man ein Dictionary umdreht, indem man Schlüssel und Werte vertauscht. Das funktioniert nur, wenn die Werte eindeutig und hashbar sind. Andernfalls gehen Paare verloren.

Verschachtelte Dictionaries

Ein Wert kann wiederum ein Dictionary sein. So beschreibt man Strukturen wie JSON-Antworten einer API oder ein Dictionary von Benutzern.

users = {
    101: {"name": "Anna", "skills": ["python", "sql"]},
    102: {"name": "Olaf", "skills": ["go"]},
}
print(users[101]["skills"][0])            # python
print(users.get(103, {}).get("name"))     # None, ohne KeyError

Dictionary kopieren: Kopie oder zweiter Name

Die Zuweisung b = a kopiert kein Dictionary, sondern gibt demselben Objekt einen zweiten Namen. Ändern Sie es über b, sehen Sie die Änderung auch in a. Dasselbe geschieht, wenn Sie ein Dictionary an eine Funktion übergeben: Sie erhält einen Verweis auf das gemeinsame Objekt und kann es unbemerkt verändern.

import copy

a = {"limits": [0, 500]}
b = a.copy()              # flache Kopie
b["limits"].append(1000)  # die verschachtelte Liste ist gemeinsam!
print(a)                  # {'limits': [0, 500, 1000]}

c = copy.deepcopy(a)      # vollständig unabhängige Kopie

Dictionaries vergleichen

Der Operator == vergleicht Dictionaries nach ihrem Inhalt: Sie sind gleich, wenn alle Paare übereinstimmen. Die Reihenfolge der Schlüssel spielt dabei keine Rolle: {"a": 1, "b": 2} == {"b": 2, "a": 1} ergibt True. Um gemeinsame Schlüssel zu finden, verwenden Sie Mengenoperationen auf den Ansichten: a.keys() & b.keys().

Typisierte Dictionaries: Annotationen

Die Annotation eines Dictionaries schreibt man als dict[str, int]. Hat ein Dictionary eine feste Menge von Feldern mit unterschiedlichen Typen, eignet sich TypedDict aus dem Modul typing:

from typing import TypedDict

class User(TypedDict):
    name: str
    age: int

u: User = {"name": "Anna", "age": 30}

Annotationen werden zur Laufzeit nicht geprüft. Sie werden von IDEs und Analysewerkzeugen wie mypy gelesen.

Unveränderliches Dictionary: frozendict in Python 3.15

In Python 3.15 kam der eingebaute Typ frozendict hinzu (PEP 814). Er braucht keinen Import, und ein Änderungsversuch führt sofort zu einem TypeError. Bisher musste man ein unveränderliches Dictionary mit einer Hülle aus dem Modul types oder mit einem Drittpaket nachbilden. Genau das braucht man für gemeinsame Einstellungen, die keine Funktion stillschweigend ändern darf.

config = frozendict(min_amount=0, max_amount=500)
config["max_amount"] = 1000
# TypeError: 'frozendict' object does not support item assignment

strict = config | {"max_amount": 300}   # neues frozendict, das Original bleibt
cache = {config: "Bericht für Mai"}     # hashbar — also als Schlüssel geeignet

Was Sie nach dem Material des Kurses wissen sollten:

• frozendict erbt von object und nicht von dict. Deshalb liefert isinstance(cfg, dict) den Wert False. Um „irgendein Dictionary“ zu prüfen, verwenden Sie collections.abc.Mapping oder isinstance(x, (dict, frozendict)).
• Er ist nur hashbar, wenn Schlüssel und Werte hashbar sind: frozendict(a=[1]) lässt sich anlegen, aber hash() schlägt fehl. Die Unveränderlichkeit ist flach, wie beim Tupel.
• Die Reihenfolge wird gespeichert, == berücksichtigt sie aber nicht.
• json.dumps, pickle und copy verarbeiten frozendict.

Typische Fehler

• KeyError beim Lesen — verwenden Sie get oder eine Prüfung mit in.
• Liste als Schlüssel — wandeln Sie sie in ein Tupel um: d[tuple(lst)].
• Dictionary während der Schleife ändern — durchlaufen Sie list(d).
• Erwartung einer Kopie bei einer Zuweisung — verwenden Sie copy() oder deepcopy.
• {} statt einer leeren Menge — das ist ein leeres Dictionary.

Fazit

Das dict in Python ist die wichtigste Datenstruktur der Sprache: schneller Zugriff über den Schlüssel, erhaltene Einfügereihenfolge, praktische Methoden wie get, setdefault und update, Durchlauf über items(), Sortierung mit sorted und das Zusammenführen mit dem Operator |. Achten Sie auf das Kopieren und die hashbaren Schlüssel, und für Einstellungen in Python 3.15 nehmen Sie frozendict. Dictionaries, Listen, Tupel und Mengen werden im Kurs „Python 3.15: vom Einsteiger zum Profi“ am Beispiel des Ausgabentrackers praktisch durchgespielt.