Python Dictionary iterieren: items, keys & values einfach erklärt

Stell dir vor, du bekommst in deiner Abschlussprüfung, im Studium oder im ersten Job ein Dictionary mit 50 Produkten: Der Produktname ist der Schlüssel, der Preis der Wert. Deine Aufgabe: den Gesamtwert berechnen. Wer hier nur `for i in range(len(...))` im Kopf hat, scheitert - denn beim Python Dictionary iterieren funktionieren Schleifen anders als bei Listen. Gut, dass du das jetzt lernst, denn Dictionaries begegnen dir überall: von JSON-APIs bis zur Config-Verwaltung.

Was bedeutet "Dictionary iterieren" in Python?

Ein Dictionary (`dict`) in Python speichert Paare aus Schlüssel (Key) und Wert (Value) - wie ein Wörterbuch, bei dem du unter einem Stichwort die passende Erklärung findest. Iterieren bedeutet, diese Einträge der Reihe nach in einer Schleife zu durchlaufen.

Der wichtigste Punkt vorab: Iterierst du direkt über ein Dictionary, bekommst du nur die Schlüssel, nicht die Werte.

user = {"name": "Lena", "rolle": "Admin", "id": 42}

for eintrag in user:
    print(eintrag)

Ausgabe: `name`, `rolle`, `id`. Genau dieser Punkt verwirrt Einsteiger am häufigsten - und führt zu Fehler 3 weiter unten.

Kernregel: `for x in d:` liefert die Schlüssel eines Dictionaries - niemals die Werte.

Welche drei Methoden gibt es? keys(), values() und items() im Vergleich

Python stellt dir drei Methoden zur Verfügung, um gezielt über Schlüssel, Werte oder beides zu iterieren:

Wichtig zu wissen: Alle drei Methoden geben sogenannte View-Objekte zurück - live Ansichten auf das Dictionary, keine Kopien. Änderst du das Dictionary, spiegelt sich das im View wider. Details dazu findest du in der offiziellen Python-Dokumentation zu dict-Views.

Merke: Seit Python 3.7 behalten Dictionaries die Einfügereihenfolge - die Ausgabe erfolgt also in der Reihenfolge, in der du die Einträge hinzugefügt hast. Sortiert ist das Dictionary deswegen aber nicht.

Wie iteriere ich über alle Schlüssel? keys()

Die Methode `.keys()` liefert alle Schlüssel. Sie ist technisch optional - `for key in user:` macht exakt dasselbe. Viele erfahrene Entwickler schreiben `.keys()` trotzdem explizit hin, weil der Code dann selbsterklärender wird.

user = {"name": "Lena", "rolle": "Admin", "id": 42}

for key in user.keys():
    print(key)

Wie iteriere ich über alle Werte? values()

Brauchst du nur die Werte, nutzt du `.values()`. Das ist der Standardweg für Berechnungen wie Summen oder Durchschnitte.

preise = {"laptop": 999.0, "maus": 24.5, "monitor": 189.0}

for preis in preise.values():
    print(preis)

# Summe aller Werte - hier geht auch direkt sum()
gesamt = sum(preise.values())
print(f"Gesamtwert: {gesamt} EUR")

Wie bekommst du Schlüssel und Wert zusammen? items()

Die Methode `.items()` ist das Arbeitstier unter den drei Varianten. Sie liefert pro Durchlauf ein Tupel aus Schlüssel und Wert - und dank Tuple-Unpacking kannst du beide direkt in zwei Variablen aufteilen:

user = {"name": "Lena", "rolle": "Admin", "id": 42}

for key, value in user.items():
    print(f"{key}: {value}")

Ausgabe:

name: Lena
rolle: Admin
id: 42

Stell dir das wie eine Tabelle vor, die du Zeile für Zeile abläufst: links der Schlüssel, rechts der Wert. In 80 % aller Fälle im Alltag (und in Prüfungen) ist `.items()` die richtige Wahl.

Merke: `for key, value in d.items():` ist der Standardweg, wenn du Schlüssel und Wert gleichzeitig brauchst.

Die Grundlagen von Dictionaries selbst habe ich übrigens ausführlicher in Python Dictionary: Aufbau, Methoden & Einsatz einfach erklärt beschrieben, falls du bei den Basics noch Unsicherheiten hast.

Praxisbeispiel: Lagerbestand auswerten

So sieht ein komplettes, lauffähiges Programm aus, wie es dir in einer Prüfungsaufgabe oder im ersten Berufsjahr begegnen könnte - ein Lagerbestand mit Nachbestellungs-Warnung:

lager = {"schrauben": 120, "hammer": 3, "nagel": 450, "saege": 1, "bohrer": 8}

MINDESTBESTAND = 10

# 1. Gesamteinheiten berechnen
einheiten_gesamt = sum(lager.values())
print(f"Gesamtbestand: {einheiten_gesamt} Einheiten")

# 2. Produkte unter Mindestbestand finden
nachbestellen = []
for produkt, bestand in lager.items():
    if bestand < MINDESTBESTAND:
        nachbestellen.append(produkt)
        print(f"WARNUNG: {produkt} nur noch {bestand} Stueck")

# 3. Kompakt als List Comprehension
knapp = [p for p, b in lager.items() if b < MINDESTBESTAND]
print(f"Nachbestellen: {knapp}")

Das letzte Beispiel zeigt, wie Dictionary-Iteration und List Comprehension zusammenspielen - eine Kombination, die dir in der Praxis ständig begegnen wird.

Welche häufigen Fehler gibt es beim Dictionary-Iterieren?

Drei Stolperfallen tauchen in Prüfungen und Code-Reviews immer wieder auf. Kenne sie, bevor sie dich Punkte oder Nerven kosten.

Fehler 1: Dictionary während der Iteration verändern

Löschst oder fügst du Einträge hinzu, während die Schleife läuft, wirft Python einen `RuntimeError: dictionary changed size during iteration`. Warum? Weil Python nicht weiß, welche Einträge die Schleife noch besuchen soll - wie wenn jemand dir Karten wegnimmt, während du sie abzählst.

# FALSCH - RuntimeError!
for produkt, bestand in lager.items():
    if bestand == 0:
        del lager[produkt]  # crasht

# RICHTIG - ueber eine Kopie der Schluessel iterieren
for produkt in list(lager.keys()):
    if lager[produkt] == 0:
        del lager[produkt]

Im korrigierten Beispiel läuft die Schleife über `list(lager.keys())`, also eine feste Kopie der Schlüssel. Dadurch darf sich das Dictionary währenddessen ändern, ohne dass Python durcheinanderkommt.

Merke: Während der Iteration niemals Schlüssel hinzufügen oder löschen. Werte ändern mit `d[key] = ...` ist dagegen erlaubt.

Fehler 2: KeyError durch direkten Zugriff

Wer innerhalb der Schleife mit `d[key]` auf vielleicht nicht existierende Schlüssel zugreift, riskiert einen KeyError. Sicherer ist die Methode `.get()` mit Standardwert, die stattdessen `None` (oder deinen Wunschwert) zurückgibt:

einstellungen = {"design": "dark"}

# FALSCH - KeyError, wenn Schluessel fehlt
design = einstellungen["design"]
sprache = einstellungen["sprache"]  # boom

# RICHTIG - .get() mit Standardwert
sprache = einstellungen.get("sprache", "de")
print(sprache)  # de

Mehr zum sicheren Umgang mit `None` und `.get()` findest du in Python None Optional: None-Werte sicher behandeln, das Zusammenspiel mit try/except in Python Exception Handling: try except finally einfach erklärt.

Fehler 3: Direkte Iteration und Werte erwarten

Der Klassiker unter Anfängerfehlern: `for eintrag in user:` liefert Schlüssel, nicht Werte. Wer `eintrag` dann als Wert benutzt, wundert sich über seltsame Ausgaben. Die Lösung: `.values()` oder `.items()` explizit aufrufen.

Übungstipp: Notenverwaltung selbst programmieren

Nimm dir 15 Minuten und baue eine kleine Notenverwaltung: Ein Dictionary mit Schülername als Schlüssel und Note als Wert. Iteriere mit `.items()` und gib jede Person aus, die bestanden hat (Note ≤ 4). Berechne danach den Notendurchschnitt mit `.values()`. Erweitere das Programm danach um eine Nachprüfung: Wer eine 5 hat, darf nachschreiben - ändere den Wert in der Schleife (das ist erlaubt!) und gib die neue Übersicht aus. Diese eine Übung trainiert alle drei Iterationsvarianten.

FAQ: Häufige Fragen zum Python Dictionary iterieren

Wie iteriere ich über ein Python Dictionary?

Mit `for key, value in d.items():` bekommst du Schlüssel und Wert zusammen. Für nur Schlüssel nutzt du `for key in d:` (oder `d.keys()`), für nur Werte `for value in d.values():`.

Was gibt die Methode .items() zurück?

Ein View-Objekt, das Tupel der Form `(schluessel, wert)` liefert. Es ist eine live Ansicht - keine Kopie. Bei jeder Iteration bekommst du also den aktuellen Zustand des Dictionaries.

Wie iteriere ich sortiert über ein Dictionary?

Mit der eingebauten Funktion `sorted()`: `for key, value in sorted(d.items()):` iteriert nach Schlüsseln sortiert. Nach Werten sortiert geht es mit `sorted(d.items(), key=lambda paar: paar[1])`. Das Dictionary selbst bleibt unverändert - Details stehen in der offiziellen Python-Doku zu sorted().

Kann ich Werte während der Iteration ändern?

Ja, Werte ändern ist erlaubt: `for k in d: d[k] = 0` funktioniert. Schlüssel hinzufügen oder löschen während der Iteration führt dagegen zu einem `RuntimeError`. Dann vorher mit `list(d.keys())` eine Kopie der Schlüssel erstellen.

Was ist der Unterschied zwischen Liste und Dictionary beim Iterieren?

Eine Liste liefert ihre Elemente in fester Reihenfolge über einen Index. Ein Dictionary liefert standardmäßig seine Schlüssel und hat keinen Index-Zugriff per Position - `for i in range(len(d)):` funktioniert daher nicht. Mehr dazu in Iterable und Iterator in Python: __iter__ und __next__.

Fazit

Beim Python Dictionary iterieren entscheidest du mit drei Werkzeugen über den Erfolg: `.keys()` für Schlüssel, `.values()` für Werte, `.items()` für beides zusammen. Diese Grundfertigkeit taucht in jeder Prüfung und jedem Alltagstag als Entwickler auf. Pass besonders auf die zwei Fallen auf: nie Schlüssel während der Iteration löschen und fehlende Schlüssel mit `.get()` abfangen.

Wenn du dich gezielt auf deine IHK-Abschlussprüfung, eine Klausur oder dein erstes Job-Interview vorbereiten willst, hilft dir individuelle Nachhilfe weiter. Schau vorbei bei study-it.education - dort kümmern wir uns um deine offenen Fragen zu Python und allem anderen rund ums Programmieren.