Why does `def add(x, bucket=[])` accumulate values across separate calls in Python?

### What actually happens ```python def add(x, bucket=[]): bucket.append(x) return bucket add(1) # [1] add(2) # [1, 2] ``` When Python executes the `def` statement — once, when the module is imported or the enclosing scope runs — it evaluates every default expression in the signature *in the enclosing scope*, collects the resulting objects, and attaches them to the newly created function object. Positional-or-keyword defaults land in the `__defaults__` tuple; keyword-only defaults land in the `__kwdefaults__` dictionary. The `def` statement then binds the function object to the name. From that point the defaults are fixed objects. A call that omits `bucket` does not re-run `[]`; the interpreter simply binds the parameter to the object already sitting in `__defaults__`. So every default-using call shares one list, and `bucket.append(x)` mutates a list whose lifetime is the lifetime of the function object — usually the lifetime of the process. You can watch it happen without any tooling: ```python add(1) add.__defaults__ # ([1],) add(2) is add.__defaults__[0] # True ``` The returned list *is* the stored default. That identity check is the cleanest way to demonstrate the mechanism at a whiteboard, and it also explains a symptom that confuses people: passing the argument explicitly is unaffected — `add(3, [])` binds the parameter to the caller's fresh list and leaves the stored default alone. ### Why the language does it this way A default is an ordinary expression evaluated in the scope where the `def` appears, at the moment the `def` runs. That is consistent with how Python evaluates every other expression: there is no implicit laziness anywhere in the language. Deferring evaluation to call time would need the interpreter to keep the *unevaluated* expression plus the scope to evaluate it in, and would change what names it can see and when side effects happen. A late-bound-default syntax has been proposed (PEP 671, which would spell it with a `=>` marker) but it has never been accepted and is not in any released Python, 3.14 included. Assume def-time evaluation, always. It is also worth knowing that this is not a bug being tolerated — it is what makes a default able to capture a value deliberately, and it is fast: no expression is re-evaluated per call. ### The failure modes beyond accumulation Accumulation is the demo, but the same rule produces two other production bugs. A **frozen computed value**: `def stamp(event, at=time.time()):` records the time the module was imported for the rest of the process. In a nightly inventory sync between two systems, every record ends up stamped with process start rather than the moment it was reconciled, and the downstream system silently treats the whole batch as simultaneous. A **resource created at import and never closed**: `def sync(records, session=make_session()):` opens a connection while the module loads. It is shared by every call, nobody owns closing it, and because it never appears in a `with` block it survives every code path — including the ones that raise. On an 11-person team the person who writes the default and the person who debugs the lingering socket are rarely the same person, which is exactly why lint rules exist for this. ### The fix, and the near-miss fixes The fix is to default to `None` and construct inside the body: ```python def add(x, bucket=None): if bucket is None: bucket = [] bucket.append(x) return bucket ``` Two attempts that look like fixes but are not: calling `bucket.clear()` at the top of the body does reset the shared default, but it also empties a list a caller passed in — a much worse bug; and writing `bucket = bucket or []` replaces an explicitly-passed empty list, so the caller's object never receives the append. Rebinding `bucket = []` unconditionally at the top just makes the parameter useless. Immutable defaults need none of this. `def add(x, bucket=())` shares a tuple, and since a tuple cannot be appended to, sharing is invisible; you would build a new tuple with `bucket + (x,)`. ### What an interviewer is really testing The question is a proxy for "do you know when the expressions in a signature run?" A candidate who answers only "never use a mutable default" has memorized a rule. A candidate who says defaults are evaluated once at `def` time, stored in `__defaults__`, shared by every default-using call, and that the same rule explains stale timestamps and import-time resources, has the model — and will recognize the next variant of the bug instead of just the list one.