Python Dictionary-Methoden

Python-Dictionaries speichern Daten als Schlüssel-Wert-Paare und verfügen über eine umfangreiche Sammlung eingebauter Methoden zum Lesen, Hinzufügen, Aktualisieren und Entfernen von Einträgen. Dieses Kapitel behandelt jede Dictionary-Methode, die in Python 3 verfügbar ist, mit korrekten Beispielen und praktischen Hinweisen dazu, wann – und wann nicht – man sie einsetzen sollte.

Eine allgemeine Einführung in Dictionaries (Erstellung, Zugriff auf Elemente, Verschachtelung) finden Sie im Kapitel Python Dictionaries.

Was ist ein Python-Dictionary?

Ein Dictionary bildet eindeutige Schlüssel auf Werte ab. Schlüssel müssen hashbar sein (Strings, Zahlen und Tupel aus hashbaren Werten funktionieren; Listen nicht). Werte können beliebige Python-Objekte sein.

person = {"name": "Alice", "age": 28, "city": "Berlin"}

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

Dictionary-Methoden auf einen Blick

clear()

clear() entfernt alle Einträge aus dem Dictionary an Ort und Stelle und hinterlässt ein leeres Dict. Verwenden Sie es, wenn Sie dasselbe Dict-Objekt wiederverwenden möchten, anstatt ein neues zu erstellen.

Fallstrick: inventory = {} sieht ähnlich aus, erstellt aber ein neues Dict-Objekt. Wenn eine andere Variable auf dasselbe Dict zeigt, leert clear() es für beide; eine Neuzuweisung hingegen nicht.

a = {"x": 1}
b = a
a.clear()
print(b)   # Output: {}  — b sees the change

a = {"x": 1}
b = a
a = {}
print(b)   # Output: {'x': 1}  — b is unaffected

copy()

copy() gibt eine flache Kopie zurück – ein neues Dict mit denselben Schlüsseln und Referenzen auf dieselben Werte.

Fallstrick: Wenn ein Wert ein veränderbares Objekt (Liste, Dict, Set) ist, teilen sich das Original und die Kopie dieses Objekt. Verwenden Sie copy.deepcopy(), wenn Sie vollständige Unabhängigkeit benötigen.

Weitere Details zum sicheren Kopieren von Dicts finden Sie unter Copy Dictionaries.

fromkeys()

fromkeys(iterable, value) ist eine Klassenmethode, die ein neues Dict aus einer Folge von Schlüsseln erstellt, die alle dem gleichen Wert zugeordnet sind (Standard: None).

fields = ["name", "email", "phone"]
record = dict.fromkeys(fields, "")
print(record)
# Output: {'name': '', 'email': '', 'phone': ''}

Fallstrick: Wenn der Standardwert veränderbar ist (z. B. eine Liste), teilen sich alle Schlüssel dasselbe Objekt:

bad = dict.fromkeys(["a", "b"], [])
bad["a"].append(1)
print(bad)  # Output: {'a': [1], 'b': [1]}  — both share the list!

Die Lösung ist, stattdessen ein Dict-Comprehension zu verwenden:

good = {k: [] for k in ["a", "b"]}
good["a"].append(1)
print(good)  # Output: {'a': [1], 'b': []}

get()

get(key, default=None) gibt den Wert für key zurück, wenn er vorhanden ist, andernfalls default. Es wird niemals ein KeyError ausgelöst.

Wann verwenden: Bevorzugen Sie get() gegenüber dict[key], wenn der Schlüssel möglicherweise fehlt. Verwenden Sie die Zwei-Argument-Form, um einen sinnvollen Standardwert anzugeben, anstatt KeyError in einem try/except abzufangen.

items()

items() gibt eine dict_items-View zurück – ein Iterable aus (key, value)-Tupeln, das den aktuellen Zustand des Dicts widerspiegelt.

Die häufigste Verwendung ist das Entpacken von Schlüssel und Wert in einer for-Schleife:

scores = {"math": 90, "english": 85, "science": 92}
for subject, grade in scores.items():
    print(f"{subject}: {grade}")
# Output:
# math: 90
# english: 85
# science: 92

Views sind live – sie spiegeln Änderungen am Dict wider, ohne neu generiert werden zu müssen.

Weitere Schleifenmuster finden Sie unter Loop Dictionaries.

keys()

keys() gibt eine dict_keys-View aller Schlüssel in Einfügereihenfolge zurück.

Da es sich um eine View handelt, können Sie sie in Mengenoperationen verwenden, um zwei Dicts zu vergleichen:

a = {"x": 1, "y": 2}
b = {"y": 3, "z": 4}

print(a.keys() & b.keys())  # Output: {'y'}    — keys in both
print(a.keys() | b.keys())  # Output: {'x', 'y', 'z'}  — all keys
print(a.keys() - b.keys())  # Output: {'x'}    — keys only in a

values()

values() gibt eine dict_values-View aller Werte zurück.

Häufige Anwendungsfälle:

prices = {"apple": 0.99, "banana": 0.59, "cherry": 2.49}

total = sum(prices.values())
print(f"Total: {total:.2f}")   # Output: Total: 4.07

most_expensive = max(prices.values())
print(most_expensive)          # Output: 2.49

Im Gegensatz zu keys() unterstützt values() keine Mengenoperationen, da Werte nicht eindeutig sein müssen.

pop()

pop(key, default) entfernt das Element mit dem angegebenen Schlüssel und gibt seinen Wert zurück. Wenn der Schlüssel fehlt und kein Standard angegeben ist, wird KeyError ausgelöst.

Wann verwenden: pop() ist das richtige Werkzeug, wenn Sie ein Element sowohl entfernen als auch seinen Wert in derselben Operation nutzen möchten, beispielsweise beim Verarbeiten von Elementen aus einem warteschlangenähnlichen Dict.

popitem()

popitem() entfernt das zuletzt eingefügte Schlüssel-Wert-Paar und gibt es als (key, value)-Tupel zurück. Der Aufruf auf einem leeren Dict löst KeyError aus.

data = {"a": 1, "b": 2, "c": 3}

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

Ein praktisches Muster ist die destruktive Verarbeitung eines Dicts, bis es leer ist:

tasks = {"write tests": True, "review PR": False, "deploy": True}
while tasks:
    name, done = tasks.popitem()
    status = "done" if done else "pending"
    print(f"{name}: {status}")

setdefault()

setdefault(key, default=None) gibt den Wert für key zurück, wenn er vorhanden ist. Ist key nicht vorhanden, wird er mit default eingefügt und default zurückgegeben.

options = {"color": "blue"}

# Key exists — returns existing value, does NOT overwrite
print(options.setdefault("color", "red"))   # Output: blue

# Key absent — inserts and returns default
print(options.setdefault("size", "medium")) # Output: medium

print(options)
# Output: {'color': 'blue', 'size': 'medium'}

Hauptanwendungsfall: Aufbau von Dictionaries mit Listen (Gruppierung):

words = ["apple", "avocado", "banana", "blueberry", "cherry"]
grouped = {}
for word in words:
    grouped.setdefault(word[0], []).append(word)

print(grouped)
# Output: {'a': ['apple', 'avocado'], 'b': ['banana', 'blueberry'], 'c': ['cherry']}

Dies ist sauberer als eine if key not in d: d[key] = []-Prüfung bei jeder Iteration.

update()

update(other) fügt other in das Dictionary ein und überschreibt dabei vorhandene Schlüssel. other kann ein weiteres Dict, ein Iterable aus (key, value)-Paaren oder Schlüsselwortargumente sein.

Python 3.9+ Alternative: Der |=-Operator zum Zusammenführen an Ort und Stelle bewirkt dasselbe auf prägnantere Weise:

profile = {"name": "Alice", "age": 28}
profile |= {"age": 29, "city": "Berlin"}
print(profile)
# Output: {'name': 'Alice', 'age': 29, 'city': 'Berlin'}

Der |-Operator (ohne =) gibt ein neues Dict zurück, anstatt das vorhandene zu verändern.

Auf Elemente zugreifen und sie ändern

Über die oben genannten Methoden hinaus bietet Python eine direkte Syntax zum Lesen, Hinzufügen und Entfernen von Dictionary-Einträgen.

Einen Wert per Schlüssel lesen:

Der Zugriff auf einen nicht vorhandenen Schlüssel löst KeyError aus. Verwenden Sie get(), um dies zu vermeiden.

Einen Wert hinzufügen oder überschreiben:

person = {"name": "Alice", "age": 28}
person["occupation"] = "Engineer"  # new key
person["age"] = 29                 # overwrite existing key
print(person)
# Output: {'name': 'Alice', 'age': 29, 'occupation': 'Engineer'}

Über Schlüssel und Werte iterieren:

Die richtige Methode wählen

Verwandte Kapitel

• Python Dictionaries — Grundlagen: Erstellen, Zugreifen und Mitgliedschaftsprüfung
• Nested Dictionaries — Dicts von Dicts für hierarchische Daten
• Loop Dictionaries — alle Schleifenmuster mit keys(), values() und items()
• Copy Dictionaries — flache vs. tiefe Kopie im Detail
• List Methods — die entsprechende Referenz für Python-Listen

Übungen