frozenset vs set: Membership Lab

Intro — what this post promises

After you build once, is frozenset any slower than set for repeated in checks? This lab times lookup-heavy membership on Linux localhost for set, frozenset, and a list baseline — plus frozenset as a dict key (something set cannot do).

Related links:

• set vs list membership localhost lab
• enum vs constants localhost lab
• contextlib vs try/finally localhost lab
• itemgetter vs lambda sort localhost lab
• lru_cache hit vs miss localhost lab
• ThreadPoolExecutor vs sequential localhost lab
• array vs list ints localhost lab
• itertools vs python loops localhost lab

Lab honesty (1 Oct 2026 IST): Python 3.13.5. 200,000 probes per lookup arm; sizes 64 / 1 024 / 10 000. Containers built once outside the timer. Affiliates: 0. Complements the set-vs-list lab by adding frozenset and hashability.

Verdict up front: at n=1 024, set ~23.3M/s and frozenset ~23.2M (~0.997× — a wash). List ~0.26M (~90× behind). At n=10 000 set vs list ~821×. Prefer frozenset when you need immutability or dict/set nesting.

Arms

Lab topology

probes = 200000 mixed hit/miss from universe (size*4)
membership sizes: 64, 1024, 10000
metric: p50 ops/s (probes)

Script: lab-evidence/62-frozenset-vs-set-membership/results/run_lab.py.

Lead table — lookup (p50)

Build cost (from list)

Build set vs frozenset at n=1 024: ~0.994× — also a wash. Pay build once; amortize over lookups.

Hashable bonus — dict keys

set raises TypeError as a dict key (unhashable). Frozenset keyed ~1.49× a sorted-tuple stand-in here.

Reading it

• Lookup parity — frozenset and set share the same hash-table story (~1.00× across sizes).
• List dies with n — ~90× at 1 024, ~821× at 10 000.
• Pick frozenset for API contracts — “this membership set will not mutate” and nestable in other sets/dicts.
• Pick set when you mutate — .add / .discard in place.

Pitfalls

1. Rebuilding the set every request — then build cost dominates; cache a frozenset.
2. Using list for “small” membership — even n=64 was ~6.5× faster as a set here.
3. Assuming frozenset is slower — not on the lookup path in this lab.
4. Putting a set in a dict — hashability, not speed, forces frozenset.

When to pick what

Reproduce

python3 lab-evidence/62-frozenset-vs-set-membership/results/run_lab.py

Evidence: /workspace/lab-evidence/62-frozenset-vs-set-membership/results/.

Closing

frozenset ≈ set on lookups. On this box n=1 024 both sat near ~23M/s while list lagged ~90×; at n=10 000 the list gap grew to ~821×. Use frozenset when immutability or hashability matters — not because it is faster.