Enum vs Constants: Access Cost Lab

Intro — what this post promises

How expensive is enum.Enum compared with module-level ints/strings? This lab measures attribute / value reads, equality, membership, Enum(value) construction, IntFlag bitwise OR, and a rare class-creation path on Linux localhost.

Related links:

• itemgetter vs lambda sort localhost lab
• ThreadPoolExecutor vs sequential localhost lab
• set vs list membership localhost lab
• dataclass vs slots vs dict localhost lab
• lru_cache hit vs miss localhost lab
• perf_counter vs time localhost lab
• array vs list ints localhost lab
• itertools vs python loops localhost lab

Lab honesty (1 Oct 2026 IST): Python 3.13.5. N=200,000 loop iters for hot arms. Read arms count one “bundle” of three status reads per op. Affiliates: 0. Enum still wins on typed APIs and exhaustiveness — this is cost, not a ban.

Verdict up front: module int consts ~30M/s bundles vs Enum.value ~4.0M (~7.4×); IntEnum ~16M (~1.82×). IntFlag OR ~32× behind bare ints. Prefer Enum for API clarity; use IntEnum when you need int-like speed + typing.

Arms

Lab topology

N = 200000; repeats=9; p50 ops/s
Status(Enum), StatusInt(IntEnum), Flag(IntFlag)

Script: lab-evidence/61-enum-vs-constants/results/run_lab.py.

Lead table — read / compare (p50)

Membership, construct, flags

Membership via a precomputed values set matched const sets (~1.01×). Calling Status(v) every time is the expensive validation path (~209 ns).

Creation (rare path)

Metaclass work: consts ~2145× “faster” — irrelevant at import time once; relevant if you generate enums in a hot loop (don’t).

Reading it

• IntEnum closes most of the gap vs plain ints on read (~1.82× vs Enum.value’s ~7.4×).
• Compare members with is / identity when you already hold Enum objects — cheap; don’t call .value unless you need the int.
• IntFlag is convenience, not a bit-twiddling speedup — ~32× behind bare int OR here.
• API boundary: accept Enum in public functions; keep hot inner loops on ints if a profiler complains.

Pitfalls

1. Banishing Enum after a microbench — clarity and invalid-value rejection matter more than 200 ns.
2. Enum vs IntEnum mixups — plain Enum is not an int; Status.OK == 1 is False.
3. Rebuilding membership sets every call — cache {m.value for m in Status}.
4. Creating Enum classes dynamically in a loop — metaclass tax is huge.

When to pick what

Reproduce

python3 lab-evidence/61-enum-vs-constants/results/run_lab.py

Evidence: /workspace/lab-evidence/61-enum-vs-constants/results/.

Closing

Enums cost a little; IntEnum costs less. On this box const int reads were ~7.4× Enum.value and ~1.82× IntEnum; IntFlag OR trailed bare bits by ~32×. Use Enum at boundaries; profile before ripping types out of a hot path.