How do enum.Enum members compare with `is` and `==`, and why?

### Members are built once, and only once When the body of an `enum.Enum` subclass finishes executing, the enum machinery walks the plain assignments in that body and turns each one into a **member**: an instance of the class being created, carrying a `.name` (the attribute you wrote) and a `.value` (what you assigned). Those instances are created exactly once, at class-creation time, and then cached on the class. Every later route to a member hands back that same object: ```python Color.RED # attribute access Color["RED"] # lookup by name Color(1) # lookup by value - a LOOKUP, not a constructor call list(Color)[0] # iteration, in definition order ``` All four are the identical object, and `Color.RED is Color(1) is Color["RED"]` is `True`. There is no path that produces a second `Color` instance holding 1. That is what "members are singletons" means, and it is the property `is` rests on. ### Why identity is the idiomatic comparison A plain `Enum` does not define `__eq__`, so it inherits `object`'s, which *is* identity. `==` and `is` therefore agree, and `is` says the intent out loud: you are asking "is this that member?", not "does this value happen to match?". It is also marginally faster - no method dispatch - and it does not tempt you into writing `stage == "build"`, which for a plain enum is quietly `False` forever. ### Where equality is not identity Two cases. First, a member never equals its raw value: `Color.RED == 1` is `False`, because the member is an instance of `Color`, not an `int`; the 1 lives in `.value`. Second, members of two *different* enum classes never compare equal even with the same value - `Color.RED == Shade.RED` is `False`. That second property is most of the reason to use an enum at all: a value drawn from one vocabulary cannot silently pass as a value from another. The exception is the mixed-in kinds. `enum.IntEnum` and `enum.StrEnum` members really are `int` and `str` subclass instances, so they inherit that type's `__eq__` and *do* equal their raw values and each other across classes. There, `==` and `is` genuinely diverge: `Priority.HIGH == 3` is `True` while `Priority.HIGH is 3` is not. That divergence is the whole reason to know which kind you are holding. ### Ordering, hashing, truthiness Plain members are unordered. `Color.RED < Color.GREEN` raises `TypeError: '<' not supported between instances of 'Color' and 'Color'`, and `sorted(Color)` fails for the same reason - sort with an explicit key such as `sorted(Color, key=lambda m: m.value)`, or rely on iteration, which yields members in **definition order**, not value order. Members are hashable and make excellent dict keys and set elements. A plain member hashes by its name, so `{Color.RED: "stop"}[Color.RED]` works while `[1]` raises `KeyError`. Truthiness is a sharp edge worth remembering: a plain member is always truthy, whatever its value, because nothing overrides the default truthiness of an object; but a member of an `IntEnum` with value 0 is **falsy**, because there `bool()` is the integer's. `if priority:` therefore means two different things depending on which kind you chose. ### Identity across copies, pickles and processes Enum defines its own reduction, so pickling a member stores the class plus the value and unpickling performs a lookup - you get the existing member back, and `is` still holds. `copy.copy` and `copy.deepcopy` likewise return the member itself. So identity survives queues, caches and round-trips inside one interpreter. The guarantee is scoped to *one imported class object*. If the same module is somehow imported twice under different names, or the member crosses into a separate interpreter or a subprocess that re-imports it, you are comparing members of two distinct class objects and identity fails. When a member has to cross such a boundary, send `.value` (or `.name`) and rebuild the member on the far side by calling the class. ### What to say in an interview "Enum members are created once and cached, so every access to `Color.RED` returns the same object. That makes `is` the natural comparison, and since a plain Enum does not override `__eq__`, equality is identity anyway. A plain member is deliberately not equal to its raw value - `Color.RED == 1` is `False` - and not equal to a same-valued member of another enum. If I need equality with raw values I opt into it explicitly with `enum.IntEnum` or `enum.StrEnum`, knowing that it costs me exactly that isolation."