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

URL: https://skillaria.top/de/guides/python/slovari-python

Ein Dictionary in Python (dict) ist eine veränderbare Sammlung von Paaren „Schlüssel — Wert“, in der Sie einen Wert nahezu sofort über seinen Schlüssel finden. Man legt es mit geschweiften Klammern an, zum Beispiel {"Kaffee": 250}, oder mit der Funktion dict(). Schlüssel sind eindeutig und müssen hashbar sein, seit Python 3.7 bleibt die Einfügereihenfolge erhalten, und in Python 3.15 gibt es die unveränderliche Variante 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

| Methode | Was sie macht |
| --- | --- |

| `get(k, default)` | Wert zum Schlüssel oder default ohne Fehler |

| `setdefault(k, default)` | liefert den Wert; fehlt der Schlüssel, wird zuerst default eingetragen |

| `update(other)` | fügt Paare aus einem anderen Dictionary hinzu und überschreibt vorhandene |

| `pop(k, default)` | entfernt den Schlüssel und liefert den Wert |

| `popitem()` | entfernt und liefert das zuletzt hinzugefügte Paar |

| `keys()`, `values()`, `items()` | Ansichten auf Schlüssel, Werte und Paare |

| `copy()` | flache Kopie |

| `clear()` | Dictionary leeren |

| `fromkeys(keys, value)` | neues Dictionary mit demselben Wert für alle Schlüssel |

### 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.

## FAQ

**Kann ein Dictionary Werte verschiedener Typen speichern?**

Ja, die Werte dürfen beliebig und untereinander verschieden sein: Zahlen, Strings, Listen, andere Dictionaries. Eine Einschränkung gibt es nur für die Schlüssel, sie müssen hashbar sein.

**Wie ermittle ich die Anzahl der Elemente in einem Dictionary?**

Die Funktion len(d) liefert die Anzahl der Paare. Für ein leeres Dictionary ergibt sie 0, und das leere Dictionary ist in einer if-Bedingung falsch.

**Worin unterscheidet sich dict von defaultdict?**

defaultdict ist eine Unterklasse von dict. Beim Zugriff auf einen fehlenden Schlüssel löst er keinen KeyError aus, sondern erzeugt den Wert über eine Fabrik, etwa int oder list. Ansonsten verhält er sich wie ein gewöhnliches Dictionary.

**Wie finde ich einen Schlüssel anhand seines Wertes?**

Eine direkte Methode gibt es nicht, Sie brauchen eine Durchsuchung: next((k for k, v in d.items() if v == value), None). Wird das oft benötigt, ist ein umgekehrtes Dictionary per Comprehension {v: k for k, v in d.items()} einfacher.

**Wie speichere ich ein Dictionary in einer Datei?**

Meist über das Modul json: json.dump(d, f, ensure_ascii=False, indent=2) schreibt in eine zum Schreiben geöffnete Datei, json.load(f) liest sie. Die Schlüssel werden dabei zu Strings.


---
Source: Skillaria.Top (https://skillaria.top)