Which expressions does CPython's compiler fold into co_consts before the code runs?

## What folding is Constant folding is an optimisation the compiler performs while turning the syntax tree into bytecode: an expression whose value is fully determined at compile time is evaluated *there*, and only the result is stored, in the code object's `co_consts` tuple. Nothing is computed at run time; the code simply loads the constant. ```python print(compile("t = 60 * 60 * 24", "<s>", "exec").co_consts) # (60, None, 86400) print(compile("t = seconds * 60", "<s>", "exec").co_consts) # (60, None) ``` In the first case the whole expression collapsed to `86400`. In the second, `seconds` is a name whose value the compiler cannot know, so nothing is folded and the multiplication happens on every execution. ## What gets folded * Arithmetic and bitwise operations on numeric literals: `60 * 60 * 24`, `1 << 20`. * Unary operators: `-5` is stored as the constant `-5`. * String and bytes operations on literals: concatenation, and repetition within the size cap. Adjacent string literals (`"a" "b"`) are joined even earlier, by the parser. * Comparisons and membership tests over literals. * Tuple displays of constants — `(1, 2, 3)` is one constant, not three loads and a build. * A set literal on the right of `in`: `x in {1, 2, 3}` stores a `frozenset` constant, which is both faster and a nice demonstration that the compiler will change the *type* when it is provably safe. ## What does not get folded * Anything mentioning a **name**: `seconds * 60`, `SCALE * 2`. The compiler has no idea what the name will be bound to. * Anything reaching through an **attribute**: a module constant accessed as `mod.value` is a run-time lookup, so the surrounding arithmetic stays at run time too. * Any **call**, even of a builtin — a builtin can be shadowed before the code runs. * **Mutable displays**: a list or dict literal must produce a fresh object per execution, so it can never be a shared constant. The compiler may still pre-build the *elements* as a constant tuple and construct the list from it. * Results that exceed a **size cap**. A string repetition whose result is longer than 4096 characters, or a very large integer power, is left alone so that compiled output does not balloon. ```python folded = compile("s = 'x' * 4096", "<s>", "exec").co_consts print(len(folded[-1])) # 4096 - folded print(compile("s = 'x' * 4097", "<s>", "exec").co_consts) # ('x', 4097, None) - not folded ``` ## The senior point: optimise the right half Take a route-optimisation batch job whose inner loop runs tens of millions of times and whose regression run has crept out to a 27-minute suite. The instinct is to hand-hoist arithmetic — replacing `60 * 60 * 24` with a precomputed `SECONDS_PER_DAY` at the top of the module. That change makes the code *slower*: the literal expression was already folded into a single constant load, while the module-level name is a global lookup on every iteration, recorded in `co_names` rather than baked into `co_consts`. The version that pays is the opposite move — bind the things the compiler *cannot* fold into locals just before the loop: a method you call repeatedly, a module attribute, a configuration value. That converts repeated name and attribute lookups into slot reads, which is a real saving precisely because folding never touches them. ## A neighbouring compile-time transformation Folding is not the only thing settled before the code runs. `compile()` takes an `optimize` argument, and the interpreter's `-O` switch sets it for the whole process: at level 1 the compiler removes `assert` statements outright and folds the builtin `__debug__` to the constant `False`; at level 2 it also drops docstrings out of `co_consts`. At the default level `__debug__` folds to `True`. It is worth knowing alongside folding for the same reason — it is a compile-time rewrite you can see in `co_consts` — and because it explains why code that leans on `assert` for real validation silently stops validating when someone runs it optimised. ## Treat it as an implementation detail Folding is not part of the language definition. CPython has moved the work around across versions — it used to live in a peephole pass over bytecode and now happens earlier, on the syntax tree — the caps have been tuned, and another implementation may fold more or less. So do not write code whose *correctness* depends on it, and do not argue about it from memory: compile the snippet and print `co_consts`. That habit also answers the adjacent question of whether an expensive-looking literal in a hot path is worth extracting, in about ten seconds, with evidence.