Zum Hauptinhalt springen

Wörterbücher und Mengen

Wörterbuch (Dictionary)​

Wörterbücher sind veränderbare Datenstrukturen, die Daten als Schlüssel-Wert-Paare speichern.

Wörterbuch erstellen​

# Leeres Wörterbuch
empty = {}
empty = dict()

# Wörterbuch mit Werten
person = {
    "name": "홍길동",
    "age": 25,
    "city": "서울"
}

# dict() Funktion
person = dict(name="홍길동", age=25, city="서울")

# Aus Liste konvertieren
pairs = [("name", "홍길동"), ("age", 25)]
person = dict(pairs)

# Schlüssel erstellen
keys = ["a", "b", "c"]
values = [1, 2, 3]
result = dict(zip(keys, values))
print(result)  # {'a': 1, 'b': 2, 'c': 3}

# Standardwert mit fromkeys setzen
keys = ["a", "b", "c"]
result = dict.fromkeys(keys, 0)
print(result)  # {'a': 0, 'b': 0, 'c': 0}

Auf Wörterbuch zugreifen​

person = {"name": "홍길동", "age": 25, "city": "서울"}

# Über Schlüssel zugreifen
print(person["name"])  # 홍길동
print(person["age"])   # 25

# get() Methode (sicher)
print(person.get("name"))     # 홍길동
print(person.get("phone"))    # None (Schlüssel nicht vorhanden)
print(person.get("phone", "없음"))  # 없음 (Standardwert)

# Schlüssel-Existenz prüfen
print("name" in person)   # True
print("phone" in person)  # False

# Alle Schlüssel, Werte, Paare
print(person.keys())      # dict_keys(['name', 'age', 'city'])
print(person.values())    # dict_values(['홍길동', 25, '서울'])
print(person.items())     # dict_items([('name', '홍길동'), ...])

# In Liste umwandeln
keys_list = list(person.keys())
values_list = list(person.values())

Wörterbuch ändern​

person = {"name": "홍길동", "age": 25}

# Wert hinzufügen/ändern
person["city"] = "서울"     # Hinzufügen
person["age"] = 26          # Ändern
print(person)

# update() - Mehrere Werte hinzufügen/ändern
person.update({"age": 27, "job": "개발자"})
print(person)

person.update(age=28, phone="010-1234-5678")
print(person)

# setdefault - Nur hinzufügen, wenn Schlüssel nicht existiert
person.setdefault("city", "부산")  # Ignoriert, wenn bereits vorhanden
print(person["city"])  # 서울 (bestehender Wert beibehalten)

person.setdefault("hobby", "독서")  # Hinzufügen, wenn nicht vorhanden
print(person["hobby"])  # 독서

# Wert löschen
del person["hobby"]    # Nach Schlüssel löschen
age = person.pop("age")  # Löschen und Wert zurückgeben
print(age)  # 28

# Letztes Element löschen (Python 3.7+ behält Einfügereihenfolge bei)
item = person.popitem()
print(item)  # ('phone', '010-1234-5678')

# Alles löschen
person.clear()
print(person)  # {}

Wörterbuch durchlaufen​

person = {"name": "홍길동", "age": 25, "city": "서울"}

# Über Schlüssel iterieren
for key in person:
    print(key)

# Schlüssel explizit
for key in person.keys():
    print(key)

# Über Werte iterieren
for value in person.values():
    print(value)

# Über Schlüssel-Wert-Paare iterieren (am häufigsten verwendet)
for key, value in person.items():
    print(f"{key}: {value}")

# Mit Index
for index, (key, value) in enumerate(person.items()):
    print(f"{index+1}. {key}: {value}")

Dictionary Comprehension​

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

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

# Zeichenkettenlänge
words = ["apple", "banana", "cherry"]
lengths = {word: len(word) for word in words}
print(lengths)  # {'apple': 5, 'banana': 6, 'cherry': 6}

# Schlüssel und Wert 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'}

# Bedingte Transformation
scores = {"홍길동": 85, "김철수": 92, "이영희": 78}
grades = {name: "Pass" if score >= 80 else "Fail"
          for name, score in scores.items()}
print(grades)

Verschachtelte Wörterbücher​

# Studenteninformationen
students = {
    "2024001": {
        "name": "홍길동",
        "age": 20,
        "scores": {"math": 85, "english": 90}
    },
    "2024002": {
        "name": "김철수",
        "age": 21,
        "scores": {"math": 92, "english": 88}
    }
}

# Zugriff
print(students["2024001"]["name"])  # 홍길동
print(students["2024001"]["scores"]["math"])  # 85

# Iteration
for student_id, info in students.items():
    print(f"ID: {student_id}")
    print(f"이름: {info['name']}")
    avg = sum(info['scores'].values()) / len(info['scores'])
    print(f"평균: {avg:.1f}")
    print()

Menge (Set)​

Mengen sind ungeordnete Kollektionen, die keine Duplikate zulassen.

Menge erstellen​

# Leere Menge (Achtung: {} ist ein Wörterbuch!)
empty = set()

# Menge mit Werten
numbers = {1, 2, 3, 4, 5}
fruits = {"사과", "바나나", "체리"}

# Duplikate werden automatisch entfernt
numbers = {1, 2, 2, 3, 3, 3}
print(numbers)  # {1, 2, 3}

# Aus anderen Datentypen konvertieren
numbers = set([1, 2, 2, 3, 4, 4, 5])
print(numbers)  # {1, 2, 3, 4, 5}

chars = set("hello")
print(chars)  # {'h', 'e', 'l', 'o'} - Duplikate entfernt

Mengenoperationen​

# Element hinzufügen
fruits = {"사과", "바나나"}
fruits.add("체리")
print(fruits)  # {'사과', '바나나', '체리'}

# Mehrere Elemente hinzufügen
fruits.update(["포도", "멜론"])
print(fruits)

# Element löschen
fruits.remove("바나나")  # Fehler, wenn nicht vorhanden
fruits.discard("수박")   # Kein Fehler, wenn nicht vorhanden
popped = fruits.pop()    # Zufälliges Element entfernen
fruits.clear()           # Alles löschen

# Enthält prüfen
numbers = {1, 2, 3, 4, 5}
print(3 in numbers)      # True
print(10 in numbers)     # False

# Länge
print(len(numbers))      # 5

Mengenoperationen​

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}

# Vereinigung (union)
print(a | b)            # {1, 2, 3, 4, 5, 6, 7, 8}
print(a.union(b))       # Gleiches Ergebnis

# Schnittmenge (intersection)
print(a & b)            # {4, 5}
print(a.intersection(b))  # Gleiches Ergebnis

# Differenz (difference)
print(a - b)            # {1, 2, 3}
print(a.difference(b))  # Gleiches Ergebnis

# Symmetrische Differenz (symmetric difference)
print(a ^ b)            # {1, 2, 3, 6, 7, 8}
print(a.symmetric_difference(b))  # Gleiches Ergebnis

# Teilmenge/Obermenge
small = {1, 2}
large = {1, 2, 3, 4}
print(small.issubset(large))      # True
print(large.issuperset(small))    # True
print(small.isdisjoint({5, 6}))   # True (keine Schnittmenge)

Set Comprehension​

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

# Mit Bedingung
even_nums = {x for x in range(1, 11) if x % 2 == 0}
print(even_nums)  # {2, 4, 6, 8, 10}

# Zeichenkettenverarbeitung
text = "hello world"
unique_chars = {c.upper() for c in text if c.isalpha()}
print(unique_chars)  # {'H', 'E', 'L', 'O', 'W', 'R', 'D'}

frozenset (Unveränderliche Menge)​

# Unveränderliche Menge
immutable = frozenset([1, 2, 3, 4, 5])
print(immutable)

# Nicht änderbar
# immutable.add(6)  # ❌ AttributeError

# Kann als Wörterbuchschlüssel verwendet werden
data = {
    frozenset([1, 2]): "group1",
    frozenset([3, 4]): "group2"
}
print(data[frozenset([1, 2])])  # group1

Praxisbeispiele​

Worthäufigkeitsanalyse​

def word_frequency(text):
    """Worthäufigkeit berechnen"""
    # Kleinschreibung und Sonderzeichen entfernen
    words = text.lower().split()

    # Häufigkeit berechnen
    frequency = {}
    for word in words:
        frequency[word] = frequency.get(word, 0) + 1

    # Nach Häufigkeit sortieren
    sorted_freq = sorted(frequency.items(),
                        key=lambda x: x[1],
                        reverse=True)

    return dict(sorted_freq)

text = """
Python is a popular programming language.
Python is easy to learn.
Many developers use Python.
"""

result = word_frequency(text)
print("=== 단어 빈도 ===")
for word, count in result.items():
    print(f"{word}: {count}회")

Telefonbuch​

class PhoneBook:
    def __init__(self):
        self.contacts = {}

    def add(self, name, phone):
        """Kontakt hinzufügen"""
        self.contacts[name] = phone
        print(f"{name} 추가됨")

    def get(self, name):
        """Kontakt abrufen"""
        return self.contacts.get(name, "등록되지 않음")

    def update(self, name, phone):
        """Kontakt aktualisieren"""
        if name in self.contacts:
            self.contacts[name] = phone
            print(f"{name} 수정됨")
        else:
            print(f"{name}을 찾을 수 없음")

    def remove(self, name):
        """Kontakt löschen"""
        if name in self.contacts:
            del self.contacts[name]
            print(f"{name} 삭제됨")
        else:
            print(f"{name}을 찾을 수 없음")

    def list_all(self):
        """Alle auflisten"""
        if not self.contacts:
            print("등록된 연락처가 없습니다")
            return

        print("\n=== 전화번호부 ===")
        for name, phone in sorted(self.contacts.items()):
            print(f"{name}: {phone}")

# Verwendung
phonebook = PhoneBook()
phonebook.add("홍길동", "010-1234-5678")
phonebook.add("김철수", "010-2345-6789")
phonebook.list_all()
print(f"\n홍길동: {phonebook.get('홍길동')}")

Duplikate entfernen und analysieren​

def analyze_data(data):
    """Daten analysieren"""
    # Duplikate entfernen
    unique = set(data)

    # Statistiken
    stats = {
        "전체": len(data),
        "고유값": len(unique),
        "중복": len(data) - len(unique),
        "최대": max(data),
        "최소": min(data),
        "중복값": [x for x in unique if data.count(x) > 1]
    }

    return stats

data = [1, 2, 2, 3, 3, 3, 4, 5, 5]
result = analyze_data(data)

print("=== 데이터 분석 ===")
for key, value in result.items():
    print(f"{key}: {value}")

Studentennotenverwaltung​

class GradeManager:
    def __init__(self):
        self.students = {}

    def add_student(self, name):
        """Student hinzufügen"""
        if name not in self.students:
            self.students[name] = {}
            print(f"{name} 추가됨")

    def add_score(self, name, subject, score):
        """Punktzahl hinzufügen"""
        if name not in self.students:
            self.add_student(name)
        self.students[name][subject] = score

    def get_average(self, name):
        """Durchschnitt berechnen"""
        if name not in self.students or not self.students[name]:
            return 0
        scores = self.students[name].values()
        return sum(scores) / len(scores)

    def get_subject_average(self, subject):
        """Durchschnitt nach Fach"""
        scores = [student[subject]
                 for student in self.students.values()
                 if subject in student]
        if not scores:
            return 0
        return sum(scores) / len(scores)

    def get_ranking(self):
        """Rangfolge berechnen"""
        averages = {name: self.get_average(name)
                   for name in self.students}
        return sorted(averages.items(),
                     key=lambda x: x[1],
                     reverse=True)

    def show_report(self):
        """Zeugnis ausgeben"""
        print("\n=== 성적표 ===")
        for name, scores in self.students.items():
            print(f"\n{name}:")
            for subject, score in scores.items():
                print(f"  {subject}: {score}점")
            print(f"  평균: {self.get_average(name):.1f}점")

# Verwendung
manager = GradeManager()
manager.add_score("홍길동", "수학", 85)
manager.add_score("홍길동", "영어", 90)
manager.add_score("김철수", "수학", 92)
manager.add_score("김철수", "영어", 88)

manager.show_report()

print("\n=== 순위 ===")
for rank, (name, avg) in enumerate(manager.get_ranking(), 1):
    print(f"{rank}. {name}: {avg:.1f}점")

Tag-System​

class TagSystem:
    def __init__(self):
        self.items = {}  # {item_id: {tags}}
        self.tags = {}   # {tag: {item_ids}}

    def add_item(self, item_id, tags):
        """Element und Tags hinzufügen"""
        self.items[item_id] = set(tags)
        for tag in tags:
            if tag not in self.tags:
                self.tags[tag] = set()
            self.tags[tag].add(item_id)

    def find_by_tag(self, tag):
        """Element nach Tag finden"""
        return self.tags.get(tag, set())

    def find_by_tags(self, tags, mode="any"):
        """Mit mehreren Tags finden"""
        if not tags:
            return set()

        tag_sets = [self.tags.get(tag, set()) for tag in tags]

        if mode == "any":  # OR-Bedingung
            return set.union(*tag_sets) if tag_sets else set()
        else:  # AND-Bedingung
            return set.intersection(*tag_sets) if tag_sets else set()

    def get_related_tags(self, tag):
        """Verwandte Tags finden"""
        items = self.find_by_tag(tag)
        related = set()
        for item in items:
            related.update(self.items[item])
        related.discard(tag)
        return related

# Verwendung
tags = TagSystem()
tags.add_item("post1", ["python", "tutorial", "beginner"])
tags.add_item("post2", ["python", "advanced", "performance"])
tags.add_item("post3", ["javascript", "tutorial", "beginner"])

print("Python 태그:", tags.find_by_tag("python"))
print("Tutorial + Beginner:", tags.find_by_tags(["tutorial", "beginner"], "all"))
print("Python 관련 태그:", tags.get_related_tags("python"))

Häufig gestellte Fragen​

F1. Welche Typen können als Wörterbuchschlüssel verwendet werden?​

A: Nur unveränderliche (immutable) Typen sind möglich

# ✅ Möglich
d = {
    "string": 1,
    42: 2,
    3.14: 3,
    (1, 2): 4,
    frozenset([1, 2]): 5
}

# ❌ Nicht möglich
# d = {[1, 2]: 1}  # Liste nicht möglich
# d = {{1, 2}: 1}  # Menge nicht möglich
# d = {{"a": 1}: 1}  # Wörterbuch nicht möglich

F2. Haben Wörterbücher eine Reihenfolge?​

A: Ab Python 3.7+ wird die Einfügereihenfolge beibehalten

# Python 3.7+
d = {"c": 3, "a": 1, "b": 2}
print(list(d.keys()))  # ['c', 'a', 'b'] - Einfügereihenfolge

# Wenn Sortierung erforderlich, explizit angeben
sorted_d = dict(sorted(d.items()))
print(list(sorted_d.keys()))  # ['a', 'b', 'c']

F3. Kann auf Mengen nicht per Index zugegriffen werden?​

A: Nein, da sie keine Reihenfolge haben, ist dies nicht möglich

s = {1, 2, 3}
# print(s[0])  # ❌ TypeError

# In Liste umwandeln oder Schleife verwenden
s_list = list(s)
print(s_list[0])  # ✅

for item in s:  # ✅
    print(item)

F4. Wie setzt man Standardwerte für Wörterbuchswerte?​

A: Verwenden Sie defaultdict

from collections import defaultdict

# Normales Wörterbuch
normal = {}
# normal["key"] += 1  # ❌ KeyError

# defaultdict
counter = defaultdict(int)  # Standardwert 0
counter["key"] += 1  # ✅
print(counter["key"])  # 1

groups = defaultdict(list)  # Standardwert []
groups["a"].append(1)  # ✅
print(groups)  # {'a': [1]}

Nächste Schritte​

Sie haben Wörterbücher und Mengen gemeistert!

Zusammenfassung:
✅ Wörterbuch: Schlüssel-Wert-Paare, schnelle Suche
✅ Menge: Duplikate entfernen, Mengenoperationen
✅ Comprehensions für prägnante Erstellung
✅ Praktische Anwendungen (Häufigkeitsanalyse, Tag-System usw.)

Nächster Schritt: Lernen Sie in Bedingungen und Schleifen, wie Sie den Programmfluss steuern!