07 – Dictionaries & Sets

Lernziele dieses Kapitels

Du erstellst Dictionaries und greifst sicher auf Werte zu
Du nutzt get(), keys(), values() und items() professionell
Du verwendest Sets für einzigartige Werte und Mengenoperationen
Du baust PyBuddy's Nutzerprofil als Dictionary

Dictionaries Grundlagen

Ein Dictionary ist wie ein Telefonbuch oder ein Inventar in einem Spiel: Jeder Wert hat einen eindeutigen Namen (Schlüssel). Statt über Zahlen-Indizes greifst du über Namen zu.

Erstellen: spieler = {"name": "Max", "level": 5}
Zugriff: spieler["name"]
Sicherer Zugriff: spieler.get("name")

# Dictionary erstellen
spieler = {
    "name": "DragonSlayer99",
    "level": 12,
    "klasse": "Magier",
    "hp": 100
}

print(spieler["name"])       # DragonSlayer99
print(spieler.get("level"))  # 12

# Wert ändern
spieler["level"] = 13
spieler["xp"] = 450  # Neuer Schlüssel!

# Löschen
del spieler["klasse"]
print(spieler)

Ausgabe

DragonSlayer99 12 {'name': 'DragonSlayer99', 'level': 13, 'hp': 100, 'xp': 450}

Du kennst bereits JavaScript aus dem JS-Quest. Hier ist der direkte Vergleich:

Python

spieler = {"name": "Max", "level": 5}
print(spieler["name"])
print(spieler.get("level"))

JavaScript

let spieler = { name: "Max", level: 5 };
console.log(spieler.name);
console.log(spieler.level);

Merke: Python-Dicts sind wie JavaScript-Objekte. Der Zugriff in Python ist spieler["name"] oder .get(), in JS spieler.name oder ["name"].

Methoden und Nested Dicts

Dictionaries haben mächtige Methoden: keys(), values(), items(). Und du kannst Dictionaries ineinander verschachteln — perfekt für komplexe Datenstrukturen wie Spieler-Profile.

# Dictionary-Methoden
nutzer = {"name": "Anna", "alter": 17, "ort": "Wien"}

print(list(nutzer.keys()))    # ['name', 'alter', 'ort']
print(list(nutzer.values()))  # ['Anna', 17, 'Wien']

# items() liefert Schlüssel-Wert-Paare
for key, value in nutzer.items():
    print(f"{key}: {value}")

# Verschachtelte Dicts
profil = {
    "user": {"name": "Max", "id": 42},
    "stats": {"level": 5, "xp": 1200},
    "badges": ["Newbie", "Coder"]
}
print(profil["stats"]["level"])  # 5

Ausgabe

['name', 'alter', 'ort'] ['Anna', 17, 'Wien'] name: Anna alter: 17 ort: Wien 5

Sets für einzigartige Werte

Ein Set ist wie eine Liste, aber jeder Wert kommt nur einmal vor — Duplikate werden automatisch entfernt. Sets sind perfekt für eindeutige Sammlungen und Mengenoperationen.

# Sets erstellen
besucht = {"Paris", "Tokio", "New York", "Paris"}
print(besucht)  # {'Tokio', 'New York', 'Paris'} — keine Duplikate!

# Mengenoperationen
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a | b)  # Vereinigung: {1, 2, 3, 4, 5, 6}
print(a & b)  # Schnittmenge: {3, 4}
print(a - b)  # Differenz: {1, 2}

# Prüfung
print(3 in a)  # True
print(7 in a)  # False

Ausgabe

{'Tokio', 'New York', 'Paris'} {1, 2, 3, 4, 5, 6} {3, 4} {1, 2} True False

Du kennst bereits JavaScript aus dem JS-Quest. Hier ist der direkte Vergleich:

Python

a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)
print(3 in a)

JavaScript

let a = new Set([1, 2, 3]);
let b = new Set([3, 4, 5]);
let vereinigung = new Set([...a, ...b]);
console.log(vereinigung);
console.log(a.has(3));

Merke: Python hat | und & direkt als Operatoren für Sets. JavaScript nutzt Set-Objekte und den Spread-Operator ....

Dict Comprehensions

Wie bei Listen gibt es auch für Dictionaries Comprehensions. Du erstellst ein Dictionary in einer Zeile — elegant und pythonic.

# Dict Comprehension
namen = ["Anna", "Ben", "Clara"]
laengen = {name: len(name) for name in namen}
print(laengen)  # {'Anna': 4, 'Ben': 3, 'Clara': 5}

# Mit Bedingung
zahlen = [1, 2, 3, 4, 5, 6]
quadrate = {z: z**2 for z in zahlen if z % 2 == 0}
print(quadrate)  # {2: 4, 4: 16, 6: 36}

# Aus zwei Listen
keys = ["a", "b", "c"]
values = [1, 2, 3]
paar = {k: v for k, v in zip(keys, values)}
print(paar)  # {'a': 1, 'b': 2, 'c': 3}

Ausgabe

{'Anna': 4, 'Ben': 3, 'Clara': 5} {2: 4, 4: 16, 6: 36} {'a': 1, 'b': 2, 'c': 3}

Dictionaries in Aktion: Spieler-Profil

Stell dir ein vollständiges Spieler-Profil vor: Name, Level, XP, Badges und Ausrüstung — alles in einem verschachtelten Dictionary. Das ist die Datenstruktur, die echte Spiele intern nutzen.

# Spieler-Profil
spieler = {
    "name": "PyKnight",
    "level": 7,
    "xp": 3400,
    "badges": ["First Blood", "Level 5"],
    "ausruestung": {
        "waffe": "Stahlschwert",
        "ruestung": "Lederpanzer",
        "gold": 150
    }
}

# XP hinzufügen
gewonnen = 500
spieler["xp"] += gewonnen

# Level-Up prüfen
if spieler["xp"] >= 4000:
    spieler["level"] += 1
    spieler["badges"].append(f"Level {spieler['level']}")
    print(f" Level-Up! Du bist jetzt Level {spieler['level']}!")

# Profil anzeigen
print(f"\n  {spieler['name']} — Level {spieler['level']}")
print(f" XP: {spieler['xp']}")
print(f"  Rüstung: {spieler['ausruestung']['ruestung']}")

Ausgabe

Level-Up! Du bist jetzt Level 8! PyKnight — Level 8 XP: 3900 Rüstung: Lederpanzer

Erstelle ein Dictionary mit 3 Kontakten (Name → Telefonnummer). Nutze input() für eine Suche und gib die Nummer aus oder 'Nicht gefunden'.

Erstelle kontakte.py
Erstelle Dictionary mit 3 Kontakten
Frage mit input() nach Namen
Nutze get() mit Default-Wert

Hinweis: kontakte = {"Anna": "0664/123", "Ben": "0664/456", "Clara": "0664/789"} name = input("Suche: ") print(kontakte.get(name, " Nicht gefunden"))

kontakte = {"Anna": "0664/123", "Ben": "0664/456", "Clara": "0664/789"}
name = input("Suche: ")
print(kontakte.get(name, " Nicht gefunden"))

Der Nutzer gibt einen Satz ein. Zähle, wie oft jedes Wort vorkommt. Nutze ein Dictionary mit Wörtern als Schlüssel und Häufigkeiten als Werte.

Erstelle woerter.py
Lies Satz ein und teile in Wörter
Zähle Häufigkeit in Dict
Gib Ergebnis aus

Hinweis: satz = input("Satz: ").lower() woerter = satz.split() haeufigkeit = {} for wort in woerter: haeufigkeit[wort] = haeufigkeit.get(wort, 0) + 1 for wort, anzahl in haeufigkeit.items(): print(f"{wort}: {anzahl}x")

satz = input("Satz: ").lower()
woerter = satz.split()

haeufigkeit = {}
for wort in woerter:
    haeufigkeit[wort] = haeufigkeit.get(wort, 0) + 1

for wort, anzahl in haeufigkeit.items():
    print(f"{wort}: {anzahl}x")

PyBuddy speichert Name, Level, XP und Badges in einem Dictionary. Zeige das Profil formatiert an und erlaube das Hinzufügen von XP.

Öffne pybuddy/main.py
Erstelle Dictionary profil
Zeige Profil-Daten formatiert an
Erlaube XP-Update mit input()

Hinweis: # pybuddy/main.py profil = { "name": "Max", "level": 1, "xp": 0, "badges": ["PyBuddy Nutzer"] } print(f" Profil von {profil['name']}") print(f" Level {profil['level']} | {profil['xp']} XP") print(f"🎖️ Badges: {', '.join(profil['badges'])}") # XP hinzufügen bonus = int(input("Bonus-XP: ")) profil["xp"] += bonus print(f"Neuer XP-Stand: {profil['xp']}")

# pybuddy/main.py
profil = {
    "name": "Max",
    "level": 1,
    "xp": 0,
    "badges": ["PyBuddy Nutzer"]
}

print(f" Profil von {profil['name']}")
print(f" Level {profil['level']} | {profil['xp']} XP")
print(f"🎖️  Badges: {', '.join(profil['badges'])}")

# XP hinzufügen
bonus = int(input("Bonus-XP: "))
profil["xp"] += bonus
print(f"Neuer XP-Stand: {profil['xp']}")

Didaktische Pause

In Pokémon wird jedes Monster als Dictionary gespeichert: Name, Typ, KP, Angriff, Verteidigung, Attacken-Liste. Wenn du ein Pokémon fängst, fügt das Spiel einfach ein neues Dict zu deiner Liste hinzu. Du baust gerade die Grundlagen für deine eigene Monster-Sammlung!

Zusammenfassung

Dictionary = {'key': 'value'} — wie ein Telefonbuch
get(), keys(), values(), items() für Zugriff
Sets = {1, 2, 3} — nur einzigartige Werte
Dict Comprehensions für elegante Erstellung
Verschachtelte Dicts für komplexe Daten

Dictionaries & Sets

Lernziele dieses Kapitels

Dictionaries Grundlagen

Methoden und Nested Dicts

Sets für einzigartige Werte

Dict Comprehensions

Dictionaries in Aktion: Spieler-Profil

Warm-Up: Kontaktbuch

Challenge: Wort-Häufigkeit

PyBuddy-Checkpoint: Nutzerprofil

Zusammenfassung