Python Dictionaries

Ein Python Dictionary ist eine veränderliche, geordnete Sammlung von Schlüssel-Wert-Paaren. Anders als Listen oder Tupel (die Integer-Positionen verwenden) ermöglicht ein Dictionary, jeden Wert mit einem aussagekräftigen Schlüssel zu versehen – das macht Abfragen schnell und den Code lesbarer. Dictionaries gehören zu den am häufigsten verwendeten eingebauten Typen in Python und bilden das Rückgrat für JSON-Verarbeitung, Konfigurationsverwaltung, Wortzählung und vieles mehr.

Dieses Kapitel behandelt alles, was Sie wissen müssen, um Dictionaries sicher einzusetzen: Erstellung, Zugriff, Änderung, Löschung, Iteration, Comprehensions und häufige Fallstricke.

Verwandte Kapitel: Dictionary Methods | Nested Dictionaries | Loop Dictionaries | Copy Dictionaries | Python Comprehensions

Was ist ein Dictionary?

Ein Dictionary ordnet eindeutige, hashbare Schlüssel Werten beliebigen Typs zu. Die wichtigste Regel: Schlüssel müssen unveränderlich (immutable) sein – Strings, Zahlen und Tupel aus unveränderlichen Elementen sind geeignet; Listen und andere Dictionaries nicht.

# string keys → integer values
inventory = {'apple': 10, 'banana': 5, 'orange': 8}

# mixed value types are fine
person = {'name': 'Alice', 'age': 30, 'active': True}

# tuple keys work because tuples are immutable
grid = {(0, 0): 'origin', (1, 0): 'east', (0, 1): 'north'}

Seit Python 3.7 behalten Dictionaries die Einfügereihenfolge bei – beim Iterieren werden die Schlüssel stets in der Reihenfolge geliefert, in der sie hinzugefügt wurden.

Ein Dictionary erstellen

Literal mit geschweiften Klammern

Der häufigste Weg: Schlüssel-Wert-Paare durch Kommas trennen, einen Doppelpunkt zwischen Schlüssel und Wert setzen und das Ganze in {} einschließen.

config = {'host': 'localhost', 'port': 5432, 'debug': True}
print(config)
# {'host': 'localhost', 'port': 5432, 'debug': True}

Ein leeres Dictionary ist einfach {}.

empty = {}
print(type(empty))  # <class 'dict'>

dict()-Konstruktor

Übergeben Sie Schlüsselwortargumente an dict(), wenn Ihre Schlüssel gültige Python-Bezeichner sind:

config = dict(host='localhost', port=5432, debug=True)
print(config)
# {'host': 'localhost', 'port': 5432, 'debug': True}

Sie können auch ein iterierbares Objekt aus zweigliedrigen Sequenzen übergeben:

pairs = [('x', 10), ('y', 20)]
point = dict(pairs)
print(point)  # {'x': 10, 'y': 20}

dict.fromkeys()

Ein Dictionary aus einer Liste von Schlüsseln erstellen, die alle denselben Anfangswert teilen:

defaults = dict.fromkeys(['timeout', 'retries', 'verbose'], 0)
print(defaults)
# {'timeout': 0, 'retries': 0, 'verbose': 0}

Fallstrick: Ist der Standardwert ein veränderliches Objekt (wie eine Liste), teilen alle Schlüssel dasselbe Objekt. Verwenden Sie stattdessen eine Dictionary Comprehension (siehe unten).

Dictionary Comprehension

Eine kompakte Möglichkeit, ein Dictionary aus einem iterierbaren Objekt zu erstellen:

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

Die vollständige Syntax finden Sie unter Python Comprehensions.

Werte abrufen

Zugriff mit eckigen Klammern

inventory = {'apple': 10, 'banana': 5, 'orange': 8}
print(inventory['apple'])   # 10

Existiert der Schlüssel nicht, wirft Python einen KeyError:

try:
    print(inventory['grape'])
except KeyError as e:
    print(f'KeyError: {e}')   # KeyError: 'grape'

get() – sicherer Zugriff mit Standardwert

dict.get(key, default) gibt den Wert zurück, wenn der Schlüssel existiert, andernfalls default (bei Auslassung None) – ohne Exception.

print(inventory.get('grape'))       # None
print(inventory.get('grape', 0))    # 0
print(inventory.get('apple', 0))    # 10

Verwenden Sie .get(), wenn Sie nicht sicher sind, ob ein Schlüssel existiert. Verwenden Sie den Klammerzugriff, wenn der Schlüssel vorhanden sein muss – ein fehlender Schlüssel ist dann ein echter Fehler, der als Exception auftauchen soll.

Prüfen, ob ein Schlüssel existiert

print('apple' in inventory)    # True
print('grape' in inventory)    # False
print('grape' not in inventory) # True

in prüft Schlüssel, nicht Werte. Die Prüfung läuft in O(1) durchschnittlicher Zeit – konstant, unabhängig von der Größe des Dictionaries.

Einträge hinzufügen und aktualisieren

Neues Schlüssel-Wert-Paar hinzufügen

Einem noch nicht vorhandenen Schlüssel einen Wert zuweisen:

inventory['grape'] = 12
print(inventory)
# {'apple': 10, 'banana': 5, 'orange': 8, 'grape': 12}

Vorhandenen Wert aktualisieren

Einem bereits vorhandenen Schlüssel einen Wert zuweisen – der alte Wert wird ersetzt:

inventory['apple'] = 15
print(inventory['apple'])  # 15

update() – Einträge en masse hinzufügen oder überschreiben

Ein anderes Dictionary oder ein iterierbares Objekt aus Schlüssel-Wert-Paaren übergeben:

inventory.update({'banana': 7, 'mango': 3})
print(inventory)
# {'apple': 15, 'banana': 7, 'orange': 8, 'grape': 12, 'mango': 3}

Zusammenführen mit | (Python 3.9+)

Der |-Operator erstellt ein neues zusammengeführtes Dictionary. Erscheint ein Schlüssel in beiden, gewinnt die rechte Seite:

a = {'x': 1, 'y': 2}
b = {'y': 99, 'z': 3}
merged = a | b
print(merged)   # {'x': 1, 'y': 99, 'z': 3}

Verwenden Sie |=, um b in-place in a einzufügen – gleichwertig mit a.update(b), aber lesbarer.

setdefault() – nur einfügen, wenn nicht vorhanden

dict.setdefault(key, default) fügt den Schlüssel mit dem Standardwert ein, wenn er fehlt, und gibt dann stets den Wert für diesen Schlüssel zurück. Das ist effizienter als das Muster if key not in d: d[key] = default.

scores = {'Alice': 95}
scores.setdefault('Bob', 0)     # Bob absent → inserts 0, returns 0
scores.setdefault('Alice', 0)   # Alice present → does nothing, returns 95
print(scores)   # {'Alice': 95, 'Bob': 0}

Ein klassischer Anwendungsfall ist das Gruppieren von Elementen:

words = ['cat', 'car', 'bus', 'can', 'bat']
groups = {}
for word in words:
    groups.setdefault(word[0], []).append(word)
print(groups)
# {'c': ['cat', 'car', 'can'], 'b': ['bus', 'bat']}

Einträge entfernen

del – nach Schlüssel entfernen

inventory = {'apple': 15, 'banana': 7, 'orange': 8, 'grape': 12}
del inventory['orange']
print(inventory)
# {'apple': 15, 'banana': 7, 'grape': 12}

del wirft einen KeyError, wenn der Schlüssel fehlt. Um das zu vermeiden, prüfen Sie zuerst mit in, oder verwenden Sie pop() mit einem Standardwert.

pop() – entfernen und Wert zurückgeben

removed = inventory.pop('grape')
print(removed)      # 12
print(inventory)    # {'apple': 15, 'banana': 7}

Übergeben Sie ein zweites Argument, um KeyError zu vermeiden, wenn der Schlüssel möglicherweise nicht vorhanden ist:

val = inventory.pop('pear', 'not found')
print(val)   # not found

popitem() – letzten eingefügten Eintrag entfernen (Python 3.7+)

d = {'a': 1, 'b': 2, 'c': 3}
last = d.popitem()
print(last)   # ('c', 3)
print(d)      # {'a': 1, 'b': 2}

clear() – alles entfernen

d = {'a': 1, 'b': 2}
d.clear()
print(d)   # {}

Über ein Dictionary iterieren

Drei Sichten ermöglichen das Iterieren über verschiedene Teile eines Dictionaries. Alle drei sind Live-Sichten – sie spiegeln Änderungen am Dictionary wider, ohne neu erstellt werden zu müssen.

Schlüssel (Standarditeration)

Das direkte Iterieren über ein Dictionary liefert seine Schlüssel:

person = {'name': 'Alice', 'age': 30, 'city': 'Paris'}

for key in person:
    print(key)
# name
# age
# city

person.keys() gibt dieselben Schlüssel als explizites dict_keys-View-Objekt zurück.

Werte

for val in person.values():
    print(val)
# Alice
# 30
# Paris

Schlüssel-Wert-Paare

for key, val in person.items():
    print(f'{key}: {val}')
# name: Alice
# age: 30
# city: Paris

.items() ist die häufigste Wahl, wenn Sie innerhalb der Schleife sowohl Schlüssel als auch Wert benötigen. Fortgeschrittene Muster finden Sie unter Loop Dictionaries.

Sichten sind live

d = {'a': 1}
keys_view = d.keys()
d['b'] = 2
print(keys_view)   # dict_keys(['a', 'b'])  ← reflects the new key

Dictionary Comprehensions

Dictionary Comprehensions ermöglichen es, Dictionaries in einem einzigen lesbaren Ausdruck zu erstellen oder zu transformieren.

Nach Wert filtern

inventory = {'apple': 15, 'banana': 7, 'orange': 8, 'grape': 12, 'mango': 3}
popular = {k: v for k, v in inventory.items() if v >= 8}
print(popular)
# {'apple': 15, 'orange': 8, 'grape': 12}

Ein Dictionary umkehren (Schlüssel und Werte tauschen)

original = {'a': 1, 'b': 2, 'c': 3}
swapped = {v: k for k, v in original.items()}
print(swapped)   # {1: 'a', 2: 'b', 3: 'c'}

Dies funktioniert nur sicher, wenn alle Werte eindeutig sind.

Worthäufigkeitszähler

sentence = 'the quick brown fox jumps over the lazy dog'
freq = {}
for word in sentence.split():
    freq[word] = freq.get(word, 0) + 1
print(freq)
# {'the': 2, 'quick': 1, 'brown': 1, 'fox': 1, ...}

Nützliche eingebaute Funktionen

Eine vollständige Referenz aller Dictionary-Methoden (copy, fromkeys, update, setdefault, popitem und mehr) finden Sie unter Python Dictionary Methods.

Häufige Fallstricke

1. KeyError bei fehlendem Schlüssel – Verwenden Sie immer .get() oder in, wenn ein Schlüssel möglicherweise nicht vorhanden ist.

2. Nicht hashbare Schlüsseltypen – Listen können keine Dictionary-Schlüssel sein, weil sie veränderlich sind. Verwenden Sie stattdessen ein Tupel:

# This raises TypeError: unhashable type: 'list'
# bad = {[1, 2]: 'value'}

# Use a tuple:
coords = {(1, 2): 'A', (3, 4): 'B'}
print(coords[(1, 2)])  # A

3. Mutieren während der Iteration – Das Hinzufügen oder Entfernen von Schlüsseln während einer Schleife über ein Dictionary wirft einen RuntimeError. Erstellen Sie zuerst eine Momentaufnahme:

d = {'a': 1, 'b': 2, 'c': 3}
for key in list(d):          # list() copies the keys
    if d[key] < 2:
        del d[key]
print(d)   # {'b': 2, 'c': 3}

4. Flache Kopie vs. tiefe Kopie – dict.copy() und {**d} erstellen beide eine flache Kopie. Verschachtelte veränderliche Werte (Listen, Dicts) werden weiterhin gemeinsam genutzt. Verwenden Sie copy.deepcopy(), wenn Sie vollständig unabhängige Kopien benötigen. Siehe Copy Dictionaries.

Dictionaries vs. andere Sammeltypen

Wenn Sie etwas anhand einer aussagekräftigen Bezeichnung statt einer Position nachschlagen möchten, ist ein Dictionary fast immer die richtige Wahl. Für geordnete eindeutige Werte sollten Sie ein set in Betracht ziehen. Für eine einfache geordnete Sequenz verwenden Sie eine list.

Übungen