frozenset()

Einleitung

frozenset ist set minus alle mutierenden Methoden — kein add, remove, pop, update. Dafür gilt:

• Hashable: Lässt sich als Dict-Key verwenden oder in einem anderen Set ablegen.
• Konstante Sets: Ideal für Globale Konstanten, Konfigurations-Mengen.
• Cache-fähig: Funktioniert mit functools.lru_cache.

Anwendungsfälle:

• Erlaubte Werte: ALLOWED_HTTP_METHODS = frozenset({"GET", "POST", "PUT", "DELETE"})
• Mehrdimensionale Lookups: Dict mit Frozenset-Key für „symmetrische" Beziehungen.
• Set-Vergleich-Cache: Frozensets als Cache-Schlüssel.

Syntax

frozenset()
frozenset(iterable)

Rückgabewert

Eine neue frozenset-Instanz mit den eindeutigen Elementen des Iterables.

Beispiele

Erzeugung und Operationen

frozenset unterstützt alle Set-Operatoren — die mutierenden Methoden fehlen aber:

a = frozenset([1, 2, 3, 4])
b = frozenset([3, 4, 5])
print(a | b)         # Union
print(a & b)         # Intersection
print(a - b)         # Difference
print(2 in a)

frozenset({1, 2, 3, 4, 5})
frozenset({3, 4})
frozenset({1, 2})
True

Als Dict-Key

Der Hauptgrund für frozenset: hashable sein. Ein normales Set wirft TypeError:

relationships = {
    frozenset({"Alice", "Bob"}):  "Freunde",
    frozenset({"Bob", "Cleo"}):   "Geschwister",
}
# Reihenfolge der Namen egal:
print(relationships[frozenset({"Bob", "Alice"})])

Freunde

Mutation schlägt fehl

Alle set-Mutations-Methoden fehlen — Versuche werfen AttributeError:

fs = frozenset([1, 2, 3])
try:
    fs.add(4)
except AttributeError as e:
    print(e)

'frozenset' object has no attribute 'add'

Praktische Beispiele

Konstanten-Set für Validierung

frozenset ist ideal für globale „erlaubte Werte"-Listen — kann nicht versehentlich modifiziert werden:

ALLOWED_METHODS = frozenset({"GET", "POST", "PUT", "PATCH", "DELETE"})

def validate_method(method):
    if method not in ALLOWED_METHODS:
        raise ValueError(f"{method!r} ist nicht erlaubt")

validate_method("GET")
try:
    validate_method("XYZ")
except ValueError as e:
    print(e)

'XYZ' ist nicht erlaubt

Frozenset in Set verschachteln

Da frozenset hashable ist, lassen sich verschachtelte Sets bauen — z. B. eine Menge von Strukturen:

# Eine Menge von Mengen — geht nur mit frozenset:
groups = {
    frozenset({1, 2, 3}),
    frozenset({4, 5}),
    frozenset({1, 2, 3}),   # Duplikat
}
print(groups)
print(len(groups))

{frozenset({4, 5}), frozenset({1, 2, 3})}
2

Cache-Schlüssel mit lru_cache

Funktionen mit Mengen-Argumenten können dank frozenset gecacht werden — set würde scheitern, weil nicht hashable:

from functools import lru_cache

@lru_cache(maxsize=128)
def common_count(a, b):
    return len(a & b)

a = frozenset({1, 2, 3, 4})
b = frozenset({3, 4, 5, 6})
print(common_count(a, b))
print(common_count(a, b))   # zweiter Aufruf aus Cache

2
2

Praktische Hinweise

• frozenset ist hashable, set nicht — der einzige Grund, eines dem anderen vorzuziehen.
• Nur nicht-mutierende Methoden verfügbar — union, intersection, difference, symmetric_difference, issubset, issuperset.
• Konstanten-Sets auf Modul-Ebene als frozenset definieren — schützt vor versehentlicher Mutation.
• Performance: Identisch zu set für Lookups (O(1)) und Iteration.
• Verwandte Typen: set (mutable), tuple (geordnet, hashable), dict (Key-Value).