Python Sets

Ein Python Set ist eine ungeordnete Sammlung einzigartiger, hashbarer Elemente. Da Sets die Einzigartigkeit automatisch erzwingen und schnelle Mitgliedschaftsprüfungen unterstützen, eignen sie sich ideal für Deduplizierung, mathematische Mengenalgebra und das Prüfen von Überschneidungen zwischen Sammlungen.

Dieses Kapitel behandelt:

• Wie man Sets erstellt (Literal-Syntax und set())
• Elemente hinzufügen und entfernen — und wann jede Methode einen Fehler auslöst
• Die vier Mengenoperationen: Vereinigung, Schnittmenge, Differenz, symmetrische Differenz
• Operator-Kürzel (|, &, -, ^)
• Teilmengen- und Obermengen-Tests
• Set-Comprehensions
• Frozen Sets (frozenset) für unveränderliche, hashbare Sets

Sets erstellen

Geschweifte Klammern verwenden

Die schnellste Möglichkeit, ein nicht-leeres Set zu erstellen, ist ein Literal mit geschweiften Klammern. Jeder Wert erscheint nur einmal, unabhängig davon, wie oft er geschrieben wird.

Ein Set in Python definieren

Den set()-Konstruktor verwenden

Übergebe ein beliebiges Iterable — eine Liste, ein Tuple, einen string oder einen range — an set(), um daraus ein Set zu erstellen. Doppelte Werte werden stillschweigend entfernt.

Eine Liste in Python in ein Set umwandeln

Wichtig: Leeres Set

Um ein leeres Set zu erstellen, muss man set() verwenden. Das Schreiben von {} erstellt ein leeres Dictionary, kein Set.

empty_set  = set()          # correct
empty_dict = {}             # this is a dict!

print(type(empty_set))   # <class 'set'>
print(type(empty_dict))  # <class 'dict'>

Was kann in ein Set?

Ein Set-Element muss hashbar sein — unveränderliche Typen wie int, float, str, bool und tuple funktionieren einwandfrei. Listen und andere Sets können keine Elemente sein, da sie veränderlich und daher nicht hashbar sind.

valid   = {1, "hello", (2, 3), True}  # OK
# invalid = {[1, 2]}                  # TypeError: unhashable type: 'list'
print(valid)

Auf Set-Elemente zugreifen

Sets sind ungeordnet, daher haben Elemente keinen Index, und man kann ein einzelnes Element nicht nach Position abrufen. Der standardmäßige Weg, jedes Element zu besuchen, ist eine for-Schleife.

colors = {"red", "green", "blue"}
for color in colors:
    print(color)
# Output order may vary — sets are unordered

Um zu prüfen, ob ein bestimmter Wert vorhanden ist, verwendet man den in-Operator:

colors = {"red", "green", "blue"}
print("red" in colors)    # True
print("yellow" in colors) # False

Die Mitgliedschaftsprüfung in einem Set ist im Durchschnitt O(1) — viel schneller als die Suche in einer Liste bei großen Sammlungen.

Für ein eigenes Kapitel, siehe Auf Set-Elemente zugreifen.

Elemente hinzufügen

Verwende add(), um ein einzelnes Element einzufügen, oder update(), um mehrere Elemente aus einem beliebigen Iterable hinzuzufügen.

Ein Element zu einem Set in Python hinzufügen

update() akzeptiert ein beliebiges Iterable und fügt alle seine Elemente hinzu:

my_set = {1, 2, 3}
my_set.update([4, 5], {6, 7})
print(my_set)   # {1, 2, 3, 4, 5, 6, 7}

Siehe Set-Elemente hinzufügen für weitere Details.

Elemente entfernen

Python bietet mehrere Methoden zum Entfernen von Elementen, jede mit unterschiedlichem Verhalten, wenn das Element fehlt.

Ein Element aus einem Set in Python entfernen

Wann remove vs. discard wählen: Verwende remove(), wenn das Element vorhanden sein sollte und sein Fehlen auf einen Fehler hinweist. Verwende discard(), wenn das Element vorhanden sein kann oder nicht und man es einfach entfernen möchte.

Siehe Set-Elemente entfernen für alle Entfernungsmethoden.

Mengenoperationen

Python-Sets implementieren die vier klassischen Mengenalgebra-Operationen. Jede Operation ist sowohl als Methode als auch als Operator verfügbar — wähle je nachdem, was im Kontext klarer ist.

Mengenoperationen in Python

set1 = {1, 2, 3}
set2 = {2, 3, 4}

# Union — all elements from both sets
print(set1.union(set2))              # {1, 2, 3, 4}
print(set1 | set2)                   # {1, 2, 3, 4}

# Intersection — only elements present in both
print(set1.intersection(set2))       # {2, 3}
print(set1 & set2)                   # {2, 3}

# Difference — elements in set1 but not set2
print(set1.difference(set2))         # {1}
print(set1 - set2)                   # {1}

# Symmetric difference — elements in either set, but not both
print(set1.symmetric_difference(set2))  # {1, 4}
print(set1 ^ set2)                      # {1, 4}

Teilmengen- und Obermengen-Prüfungen

Verwende issubset(), issuperset() oder die Vergleichsoperatoren <= / >=, um Enthaltensein-Beziehungen zu testen.

a = {1, 2}
b = {1, 2, 3, 4}

print(a.issubset(b))    # True  — every element of a is in b
print(a <= b)           # True

print(b.issuperset(a))  # True  — b contains all elements of a
print(b >= a)           # True

print(a < b)            # True  — proper subset (a != b)
print(a == b)           # False

isdisjoint() gibt True zurück, wenn zwei Sets überhaupt keine Elemente gemeinsam haben:

x = {1, 2, 3}
y = {4, 5, 6}
print(x.isdisjoint(y))  # True

Siehe Sets verbinden für In-Place-Update-Varianten wie |=, &=, -= und ^=.

Set-Comprehensions

Wie List-Comprehensions kann man ein Set mit einem kompakten Ausdruck aus geschweiften Klammern und einer for-Klausel erstellen.

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

# With a filter condition
even_squares = {x ** 2 for x in range(1, 11) if x % 2 == 0}
print(even_squares)  # {4, 16, 36, 64, 100}

Da das Ergebnis ein Set ist, werden doppelte Werte automatisch zusammengefasst:

words = ["apple", "banana", "avocado", "blueberry"]
first_letters = {w[0] for w in words}
print(first_letters)  # {'a', 'b'}

Frozen Sets

Ein frozenset ist eine unveränderliche Version eines Sets. Nach der Erstellung können keine Elemente hinzugefügt oder entfernt werden. Frozen Sets sind hashbar, was bedeutet, dass sie als Dictionary-Schlüssel oder als Elemente eines anderen Sets verwendet werden können.

fs = frozenset([1, 2, 3])
print(fs)               # frozenset({1, 2, 3})

# All read-only operations work
print(2 in fs)          # True
print(fs | {4, 5})      # frozenset({1, 2, 3, 4, 5})

# fs.add(4)             # AttributeError — frozenset has no add()

# Use as a dictionary key
permissions = {
    frozenset(["read", "write"]): "editor",
    frozenset(["read"]):          "viewer",
}
user_perms = frozenset(["read", "write"])
print(permissions[user_perms])  # editor

Wann frozenset verwenden: Immer wenn man ein Set-ähnliches Objekt benötigt, das sich nicht ändern darf — als konstante Konfiguration, als sicherer Dictionary-Schlüssel oder wenn ein Set ohne Sperren über Threads hinweg geteilt wird.

Praktische Beispiele

Duplikate aus einer Liste entfernen

Das Umwandeln in ein Set und zurück ist die einfachste Möglichkeit, eine Liste zu deduplizieren. Beachte, dass die ursprüngliche Reihenfolge nicht erhalten bleibt; wenn die Reihenfolge wichtig ist, verwende stattdessen dict.fromkeys().

Duplikate aus einer Liste mit einem Set in Python entfernen

Prüfen, ob zwei Listen ein gemeinsames Element haben

Prüfen, ob zwei Listen gemeinsame Elemente haben in Python mit Sets

isdisjoint() ist eine direktere Alternative für diese Prüfung:

list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(not set(list1).isdisjoint(set(list2)))  # False — no common elements

Einzigartige Tags über Artikel hinweg finden

article_a_tags = {"python", "tutorial", "beginner"}
article_b_tags = {"python", "advanced", "data-science"}

all_tags    = article_a_tags | article_b_tags
shared_tags = article_a_tags & article_b_tags
only_in_a   = article_a_tags - article_b_tags

print("All tags:    ", all_tags)
print("Shared tags: ", shared_tags)
print("Only in A:   ", only_in_a)

Zusammenfassung

Verwandte Kapitel: Set-Elemente hinzufügen · Set-Elemente entfernen · Auf Set-Elemente zugreifen · Sets durchlaufen · Sets verbinden · Set-Methoden

Übungen