Dictionaries in Python meistern

Dictionaries (kurz: Dicts) gehören zu den mächtigsten und am häufigsten verwendeten Datenstrukturen in Python. Sie speichern Daten als Key-Value-Paare (Schlüssel-Wert-Paare) und ermöglichen blitzschnellen Zugriff auf Werte über ihren Schlüssel.

Was sind Dictionaries?

Stell dir ein Wörterbuch vor: Du schlägst ein Wort (Schlüssel) nach und findest dessen Bedeutung (Wert). Genau so funktionieren Python-Dictionaries.

# Ein einfaches Wörterbuch
woerterbuch = {
    "Hund": "Ein domestiziertes Tier",
    "Python": "Eine Programmiersprache",
    "Buch": "Eine Sammlung bedruckter Seiten"
}

print(woerterbuch["Python"])  # Eine Programmiersprache

Wichtige Eigenschaften von Dictionaries:

• Jeder Schlüssel muss einzigartig sein
• Schlüssel müssen unveränderbar (immutable) sein: Strings, Zahlen, Tuples
• Werte können beliebige Datentypen sein
• Seit Python 3.7 ist die Einfügereihenfolge garantiert

Dictionary erstellen

# Methode 1: Geschweifte Klammern
person = {
    "name": "Anna",
    "alter": 28,
    "stadt": "Berlin"
}

# Methode 2: dict() Konstruktor
person = dict(name="Anna", alter=28, stadt="Berlin")

# Methode 3: Aus Liste von Tupeln
paare = [("name", "Anna"), ("alter", 28), ("stadt", "Berlin")]
person = dict(paare)

# Methode 4: Mit zip() aus zwei Listen
schluessel = ["name", "alter", "stadt"]
werte = ["Anna", 28, "Berlin"]
person = dict(zip(schluessel, werte))

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

# Leeres Dictionary
leer = {}
auch_leer = dict()

Werte lesen

person = {"name": "Anna", "alter": 28, "stadt": "Berlin"}

# Methode 1: Eckige Klammern (wirft KeyError bei fehlendem Schlüssel)
print(person["name"])   # Anna
# print(person["beruf"])  # KeyError: 'beruf'

# Methode 2: get() -- sicher, kein Fehler!
print(person.get("name"))    # Anna
print(person.get("beruf"))   # None (kein Fehler)
print(person.get("beruf", "Unbekannt"))  # Unbekannt (Standardwert)

# Prüfen, ob ein Schlüssel existiert
if "alter" in person:
    print(f"Alter: {person['alter']}")

if "beruf" not in person:
    print("Kein Beruf angegeben")

Empfehlung: Verwende get() immer dann, wenn du nicht sicher bist, ob ein Schlüssel existiert. So vermeidest du unerwartete Fehler.

Werte setzen und ändern

person = {"name": "Anna", "alter": 28}

# Neuen Schlüssel hinzufügen
person["stadt"] = "Berlin"
print(person)  # {'name': 'Anna', 'alter': 28, 'stadt': 'Berlin'}

# Bestehenden Wert ändern
person["alter"] = 29
print(person)  # {'name': 'Anna', 'alter': 29, 'stadt': 'Berlin'}

# setdefault() -- nur setzen, wenn Schlüssel NICHT existiert
person.setdefault("beruf", "Studentin")
print(person["beruf"])  # Studentin

person.setdefault("name", "Max")  # Wird NICHT geändert, da "name" schon existiert
print(person["name"])  # Anna

# Mehrere Werte gleichzeitig setzen/aktualisieren
person.update({
    "alter": 30,
    "email": "anna@beispiel.de",
    "hobby": "Programmieren"
})
print(person)
# {'name': 'Anna', 'alter': 30, 'stadt': 'Berlin',
#  'beruf': 'Studentin', 'email': 'anna@beispiel.de', 'hobby': 'Programmieren'}

# Update mit Keyword-Argumenten
person.update(alter=31, stadt="München")

Elemente entfernen

person = {
    "name": "Anna",
    "alter": 28,
    "stadt": "Berlin",
    "beruf": "Entwicklerin"
}

# del -- nach Schlüssel entfernen
del person["beruf"]
print(person)  # {'name': 'Anna', 'alter': 28, 'stadt': 'Berlin'}

# pop() -- entfernen und Wert zurückgeben
alter = person.pop("alter")
print(alter)    # 28
print(person)   # {'name': 'Anna', 'stadt': 'Berlin'}

# pop() mit Standardwert (kein Fehler bei fehlendem Schlüssel)
hobby = person.pop("hobby", "Keines")
print(hobby)  # Keines

# popitem() -- letztes eingefügtes Paar entfernen
person = {"a": 1, "b": 2, "c": 3}
letztes = person.popitem()
print(letztes)  # ('c', 3)
print(person)   # {'a': 1, 'b': 2}

# clear() -- alles entfernen
person.clear()
print(person)  # {}

Dictionary-Methoden

student = {
    "name": "Ben",
    "alter": 22,
    "fach": "Informatik",
    "semester": 4
}

# Alle Schlüssel
print(student.keys())
# dict_keys(['name', 'alter', 'fach', 'semester'])

# Alle Werte
print(student.values())
# dict_values(['Ben', 22, 'Informatik', 4])

# Alle Paare als Tupel
print(student.items())
# dict_items([('name', 'Ben'), ('alter', 22), ('fach', 'Informatik'), ('semester', 4)])

# In Listen umwandeln
schluessel_liste = list(student.keys())
werte_liste = list(student.values())

# Anzahl der Einträge
print(len(student))  # 4

# Kopie erstellen
kopie = student.copy()

Über Dictionaries iterieren

noten = {
    "Mathematik": 1.7,
    "Physik": 2.3,
    "Informatik": 1.0,
    "Englisch": 1.3
}

# Über Schlüssel iterieren (Standard)
print("Fächer:")
for fach in noten:
    print(f"  {fach}")

# Über Werte iterieren
print("\nNoten:")
for note in noten.values():
    print(f"  {note}")

# Über Schlüssel-Wert-Paare iterieren (am häufigsten!)
print("\nNotenübersicht:")
for fach, note in noten.items():
    print(f"  {fach}: {note}")

# Mit Bedingung
print("\nSehr gute Fächer (Note <= 1.5):")
for fach, note in noten.items():
    if note <= 1.5:
        print(f"  {fach}: {note}")

# Durchschnittsnote berechnen
durchschnitt = sum(noten.values()) / len(noten)
print(f"\nDurchschnitt: {durchschnitt:.2f}")

Dictionary Comprehensions

Wie bei Listen gibt es auch für Dictionaries eine kompakte Schreibweise:

# Quadratzahlen-Dictionary
quadrate = {x: x**2 for x in range(1, 11)}
print(quadrate)
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}

# Mit Bedingung
gerade_quadrate = {x: x**2 for x in range(1, 11) if x % 2 == 0}
print(gerade_quadrate)  # {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}

# Wörter und ihre Längen
woerter = ["Hund", "Katze", "Elefant", "Maus"]
wort_laengen = {wort: len(wort) for wort in woerter}
print(wort_laengen)  # {'Hund': 4, 'Katze': 5, 'Elefant': 7, 'Maus': 4}

# Schlüssel und Werte tauschen
original = {"a": 1, "b": 2, "c": 3}
getauscht = {wert: schluessel for schluessel, wert in original.items()}
print(getauscht)  # {1: 'a', 2: 'b', 3: 'c'}

# Alle Werte in Großbuchstaben
staedte = {"de": "berlin", "fr": "paris", "es": "madrid"}
gross = {k: v.upper() for k, v in staedte.items()}
print(gross)  # {'de': 'BERLIN', 'fr': 'PARIS', 'es': 'MADRID'}

Verschachtelte Dictionaries

Dictionaries können andere Dictionaries als Werte enthalten:

schule = {
    "Klasse 10a": {
        "klassenlehrer": "Herr Müller",
        "schueler_anzahl": 28,
        "raum": "A204"
    },
    "Klasse 10b": {
        "klassenlehrer": "Frau Schmidt",
        "schueler_anzahl": 26,
        "raum": "B102"
    }
}

# Zugriff auf verschachtelte Werte
print(schule["Klasse 10a"]["klassenlehrer"])  # Herr Müller
print(schule["Klasse 10b"]["raum"])           # B102

# Verschachtelte Werte ändern
schule["Klasse 10a"]["schueler_anzahl"] = 29

# Sicherer Zugriff auf verschachtelte Daten
lehrer = schule.get("Klasse 10c", {}).get("klassenlehrer", "Nicht gefunden")
print(lehrer)  # Nicht gefunden

# Über verschachtelte Dicts iterieren
for klasse, info in schule.items():
    print(f"\n{klasse}:")
    for eigenschaft, wert in info.items():
        print(f"  {eigenschaft}: {wert}")

defaultdict und Counter

Das collections-Modul bietet spezielle Dictionary-Varianten:

defaultdict

from collections import defaultdict

# Normales Dict wirft KeyError bei fehlendem Schlüssel
# defaultdict erstellt automatisch einen Standardwert

# Zähler (Standard: 0)
buchstaben_zaehler = defaultdict(int)
for buchstabe in "mississippi":
    buchstaben_zaehler[buchstabe] += 1
print(dict(buchstaben_zaehler))
# {'m': 1, 'i': 4, 's': 4, 'p': 2}

# Listen als Standardwert
gruppen = defaultdict(list)
schueler = [("10a", "Anna"), ("10b", "Ben"), ("10a", "Clara"), ("10b", "David")]
for klasse, name in schueler:
    gruppen[klasse].append(name)
print(dict(gruppen))
# {'10a': ['Anna', 'Clara'], '10b': ['Ben', 'David']}

# Sets als Standardwert
tags = defaultdict(set)
artikel = [("Python", "Tutorial"), ("Python", "News"), ("Java", "Tutorial")]
for sprache, tag in artikel:
    tags[sprache].add(tag)
print(dict(tags))
# {'Python': {'Tutorial', 'News'}, 'Java': {'Tutorial'}}

Counter

from collections import Counter

# Elemente zählen
text = "die katze und der hund und die maus"
wort_zaehler = Counter(text.split())
print(wort_zaehler)
# Counter({'die': 2, 'und': 2, 'katze': 1, 'der': 1, 'hund': 1, 'maus': 1})

# Häufigste Elemente
print(wort_zaehler.most_common(2))
# [('die', 2), ('und', 2)]

# Buchstaben zählen
buchstaben = Counter("programmierung")
print(buchstaben)
# Counter({'r': 3, 'g': 2, 'm': 2, 'p': 1, 'o': 1, 'a': 1, 'i': 1, 'e': 1, 'u': 1, 'n': 1})

# Counter-Operationen
c1 = Counter(a=3, b=1)
c2 = Counter(a=1, b=2, c=4)
print(c1 + c2)  # Counter({'c': 4, 'a': 4, 'b': 3})
print(c1 - c2)  # Counter({'a': 2})

Praxis: Wörterbuch-Programm

def woerterbuch_app():
    """Ein einfaches Wörterbuch-Programm."""
    woerterbuch = {
        "Hallo": "Hello",
        "Welt": "World",
        "Programmieren": "Programming",
        "Lernen": "Learning"
    }

    while True:
        print("\n--- Deutsch-Englisch Wörterbuch ---")
        print("1. Wort nachschlagen")
        print("2. Neues Wort hinzufügen")
        print("3. Wort löschen")
        print("4. Alle Wörter anzeigen")
        print("5. Wort suchen (Teiltext)")
        print("6. Beenden")

        wahl = input("\nDeine Wahl: ")

        if wahl == "1":
            wort = input("Deutsches Wort eingeben: ")
            uebersetzung = woerterbuch.get(wort)
            if uebersetzung:
                print(f"  {wort} -> {uebersetzung}")
            else:
                print(f"  '{wort}' nicht im Wörterbuch gefunden.")

        elif wahl == "2":
            deutsch = input("Deutsches Wort: ")
            englisch = input("Englische Übersetzung: ")
            woerterbuch[deutsch] = englisch
            print(f"  '{deutsch}' -> '{englisch}' wurde hinzugefügt.")

        elif wahl == "3":
            wort = input("Welches Wort löschen? ")
            if wort in woerterbuch:
                del woerterbuch[wort]
                print(f"  '{wort}' wurde gelöscht.")
            else:
                print(f"  '{wort}' nicht gefunden.")

        elif wahl == "4":
            if not woerterbuch:
                print("  Das Wörterbuch ist leer.")
            else:
                print(f"\n  {len(woerterbuch)} Einträge:")
                for de, en in sorted(woerterbuch.items()):
                    print(f"    {de} -> {en}")

        elif wahl == "5":
            suche = input("Suchbegriff: ").lower()
            treffer = {k: v for k, v in woerterbuch.items()
                       if suche in k.lower() or suche in v.lower()}
            if treffer:
                print(f"  {len(treffer)} Treffer:")
                for de, en in treffer.items():
                    print(f"    {de} -> {en}")
            else:
                print("  Keine Treffer gefunden.")

        elif wahl == "6":
            print("Auf Wiedersehen!")
            break

woerterbuch_app()

Praxis: Telefonbuch

def telefonbuch():
    """Ein einfaches Telefonbuch mit Dictionaries."""
    kontakte = {}

    def kontakt_hinzufuegen():
        name = input("Name: ")
        nummer = input("Telefonnummer: ")
        email = input("E-Mail (optional, Enter zum Überspringen): ")

        kontakte[name] = {"nummer": nummer}
        if email:
            kontakte[name]["email"] = email
        print(f"Kontakt '{name}' wurde gespeichert.")

    def kontakt_suchen():
        name = input("Name suchen: ")
        if name in kontakte:
            info = kontakte[name]
            print(f"\n  Name: {name}")
            print(f"  Telefon: {info['nummer']}")
            if "email" in info:
                print(f"  E-Mail: {info['email']}")
        else:
            # Teilsuche
            treffer = {k: v for k, v in kontakte.items()
                       if name.lower() in k.lower()}
            if treffer:
                print(f"\n  Ähnliche Kontakte ({len(treffer)}):")
                for n, info in treffer.items():
                    print(f"    {n}: {info['nummer']}")
            else:
                print(f"  '{name}' nicht gefunden.")

    def alle_anzeigen():
        if not kontakte:
            print("  Keine Kontakte vorhanden.")
        else:
            for name in sorted(kontakte):
                print(f"  {name}: {kontakte[name]['nummer']}")

    while True:
        print("\n--- Telefonbuch ---")
        print("1. Kontakt hinzufügen")
        print("2. Kontakt suchen")
        print("3. Alle Kontakte")
        print("4. Beenden")

        wahl = input("Wahl: ")
        if wahl == "1":
            kontakt_hinzufuegen()
        elif wahl == "2":
            kontakt_suchen()
        elif wahl == "3":
            alle_anzeigen()
        elif wahl == "4":
            break

telefonbuch()

Wann Dict, wann Liste?

Faustregel: Wenn du Daten über einen Namen oder Schlüssel abrufen willst, verwende ein Dictionary. Wenn die Reihenfolge und Position wichtig ist, verwende eine Liste.

Übungen

Übung 1: Buchstaben zählen

Schreibe eine Funktion, die zählt, wie oft jeder Buchstabe in einem Text vorkommt (ohne Counter zu verwenden).

def buchstaben_zaehlen(text):
    # Deine Lösung hier
    pass

# Test
print(buchstaben_zaehlen("programmieren"))
# Erwartete Ausgabe: {'p': 1, 'r': 3, 'o': 1, 'g': 1, ...}

Übung 2: Wort-Häufigkeit

Schreibe eine Funktion, die die Häufigkeit jedes Wortes in einem Satz zählt.

def wort_haeufigkeit(satz):
    # Deine Lösung hier
    pass

# Test
text = "die Katze und der Hund und die Maus und die Katze"
print(wort_haeufigkeit(text))
# {'die': 3, 'katze': 2, 'und': 3, 'der': 1, 'hund': 1, 'maus': 1}

Übung 3: Dictionary zusammenführen

Schreibe eine Funktion, die zwei Dictionaries zusammenführt. Bei gleichen Schlüsseln sollen die Werte addiert werden.

def zusammenfuehren(dict1, dict2):
    # Deine Lösung hier
    pass

# Test
a = {"Äpfel": 3, "Bananen": 2, "Kirschen": 5}
b = {"Bananen": 4, "Datteln": 1, "Äpfel": 2}
print(zusammenfuehren(a, b))
# {'Äpfel': 5, 'Bananen': 6, 'Kirschen': 5, 'Datteln': 1}

Übung 4: Gruppenbildung

Schreibe eine Funktion, die eine Liste von Wörtern nach ihrem Anfangsbuchstaben gruppiert.

def nach_anfangsbuchstabe(woerter):
    # Deine Lösung hier
    pass

# Test
woerter = ["Apfel", "Banane", "Ananas", "Birne", "Avocado", "Brombeere"]
print(nach_anfangsbuchstabe(woerter))
# {'A': ['Apfel', 'Ananas', 'Avocado'], 'B': ['Banane', 'Birne', 'Brombeere']}

# Ab Python 3.9
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}

# Neues Dict (dict2 hat Vorrang bei Duplikaten)
merged = dict1 | dict2
print(merged)  # {'a': 1, 'b': 3, 'c': 4}

# In-Place Update
dict1 |= dict2
print(dict1)  # {'a': 1, 'b': 3, 'c': 4}