Python-Sets: eindeutige Elemente, Vereinigung, Schnittmenge und Differenz

Ein Set ist ein ungeordneter Beutel eindeutiger Elemente

Wo Listen und Tupel sich für Ordnung interessieren, tun Sets es nicht. Wo Listen Duplikate stapeln lassen, verwerfen Sets sie stillschweigend. Das Set ist die richtige Datenstruktur, wenn du zwei konkrete Bedürfnisse hast:

1. Du willst eindeutige Elemente, Punkt.
2. Du willst schnell auf Mitgliedschaft prüfen.

Schreib eins mit geschweiften Klammern:

colors = {"red", "green", "blue"}
print(colors)

with_dupes = {"red", "green", "red", "blue", "green"}
print(with_dupes)   # {"red", "green", "blue"}

Die Duplikate "red" und "green" im zweiten Set verschwinden einfach. Das ist kein Fehler — das ist der ganze Witz.

Sets erzeugen

Die zwei Wege, die du tatsächlich benutzt:

# Literal with curly braces.
primes = {2, 3, 5, 7, 11}

# From any iterable.
letters = set("banana")
print(letters)

numbers = set([1, 2, 2, 3, 3, 3])
print(numbers)

# Empty set — must use set(), not {}
empty = set()
print(empty, type(empty))

Der letzte Punkt erwischt jeden einmal: {} erzeugt ein leeres Dictionary, kein leeres Set. Die syntaktische Doppeldeutigkeit musste bei einem der beiden landen, und Dicts haben gewonnen.

Hinzufügen und Entfernen

tags = {"python", "docs"}

tags.add("beginner")
print(tags)

tags.update(["seo", "tutorial", "python"])  # adds multiple, ignores dupes
print(tags)

tags.remove("seo")       # raises KeyError if the item isn't there
tags.discard("missing")  # same as remove, but silent if not present
print(tags)

popped = tags.pop()      # removes and returns an arbitrary item
print("popped:", popped, "remaining:", tags)

remove vs. discard ist der zentrale Unterschied: remove besteht darauf, dass das Element vorhanden ist; discard ist das egal. Wähl, je nachdem, ob Abwesenheit ein Fehler sein soll.

Schnelle Mitgliedschaft

Hier verdienen Sets sich ihren Platz wirklich. x in some_set läuft in konstanter Zeit, egal wie groß das Set ist. x in some_list muss die Liste durchlaufen, was bei großen Listen langsam wird.

# Imagine this list has 1,000,000 items.
known_users = set(range(1_000_000))

# Each check is near-instant.
for user_id in [42, 999_999, 1_000_001]:
    if user_id in known_users:
        print(f"{user_id}: known")
    else:
        print(f"{user_id}: unknown")

Faustregel: wann immer du if x in some_list innerhalb einer Schleife schreibst und die Liste mehr als ein paar Dutzend Elemente hat, wandle sie vorher in ein Set um.

Set-Mathematik

Hier werden Sets wirklich unterhaltsam. Du kannst sie mit Operatoren kombinieren, die mathematischen Mengenoperationen entsprechen:

frontend = {"html", "css", "javascript", "react"}
backend = {"python", "sql", "javascript", "docker"}

# Union: everything from both.
all_skills = frontend | backend
print(all_skills)

# Intersection: what's in both.
shared = frontend & backend
print(shared)

# Difference: in frontend but not backend.
only_frontend = frontend - backend
print(only_frontend)

# Symmetric difference: in one or the other, but not both.
unique_skills = frontend ^ backend
print(unique_skills)

Jeder Operator hat auch eine Methodenform (.union(), .intersection(), .difference(), .symmetric_difference()). Die Operatoren sind kompakter; die Methoden akzeptieren jede Iterable, nicht nur ein anderes Set.

Eine Liste deduplizieren

Einer der häufigsten Set-Einsätze, auch außerhalb von „Set-Logik“:

visits = ["alice", "bob", "alice", "carol", "bob", "alice"]
unique_visitors = list(set(visits))
print(unique_visitors)

Eine Zeile, Duplikate weg. Ein Punkt dazu: die Reihenfolge ist nicht erhalten. Brauchst du Eindeutigkeit und die Originalreihenfolge, nimm stattdessen dict.fromkeys():

visits = ["alice", "bob", "alice", "carol", "bob", "alice"]
unique_in_order = list(dict.fromkeys(visits))
print(unique_in_order)

Dicts behalten in modernem Python die Einfügereihenfolge, und dict.fromkeys baut eins, das die Iterable-Elemente als Schlüssel nutzt — praktisch ein geordnetes Set.

Teilmengen und Obermengen

Prüfen, ob ein Set in einem anderen enthalten ist:

known = {"python", "bash", "sql"}
required = {"python", "bash"}

print(required.issubset(known))     # True — required is inside known
print(known.issuperset(required))   # True
print(required <= known)            # same as issubset, with an operator
print(known >= required)            # same as issuperset

Das kommt bei Dingen wie Berechtigungsprüfungen vor („hat dieser Nutzer alle erforderlichen Rollen?“).

Was in ein Set darf

Nur hashbare Elemente. Das ist ein Fachbegriff — in der Praxis heißt es:

• Unveränderliche Dinge sind hashbar: Zahlen, Strings, Tupel aus Hashbarem, frozensets.
• Veränderbare Dinge nicht: Listen, Dicts, andere Sets können keine Set-Elemente sein.

ok = {1, "hello", (1, 2), 3.14}
print(ok)

# {[1, 2]}  # TypeError — lists aren't hashable

Brauchst du ein Set von Sets, nimm frozenset — eine unveränderliche Set-Variante.

Iteration ist ungeordnet

Eine Schleife über ein Set liefert Elemente in keiner garantierten Reihenfolge:

for item in {"a", "b", "c", "d"}:
    print(item)

Führ das ein paar Mal aus, und die Reihenfolge variiert. Zählt die Reihenfolge, ist ein Set nicht die richtige Struktur — sortier den Inhalt, wenn nötig, oder nimm eine Liste.

Wann du kein Set nutzen solltest

Trifft eines davon zu, ist eine Liste oder ein Dict vermutlich passender:

• Die Reihenfolge ist wichtig.
• Du willst Duplikate speichern.
• Jedes Element hat zugehörige Daten (nimm ein Dict mit dem Element als Schlüssel).

Weiter

Sets erledigen Eindeutigkeit und Mitgliedschaft. Dictionaries — als Nächstes — erledigen das breitere Muster „Wert per Schlüssel nachschlagen“, vermutlich die nützlichste Nicht-Listen-Datenstruktur in Python.