How do you write a Python closure that accumulates a running total across calls?

### The idiom An accumulator closure is two functions and one variable: ```python def make_accumulator(start=0, step=1): total = start # state, owned by this call of the factory def bump(): nonlocal total # rebind the factory's variable, do not shadow it total += step return total return bump # the caller gets a function, not the variable ``` `make_accumulator()` returns `bump`. Calling `bump()` repeatedly walks `total` upward, and the value survives between calls because it lives in the frame of the `make_accumulator` call that created `bump`, not in `bump`'s own frame. `step` needs no declaration -- `bump` only reads it. The `nonlocal` line is the whole trick. Remove it and `total += step` makes `total` a local of `bump` for the entire body, so the function no longer refers to the factory's variable at all. ### Independence is per factory call, not per function Every call to the factory creates a fresh binding, so two accumulators are genuinely separate: ```python tick = make_accumulator() by_five = make_accumulator(start=100, step=5) tick(); tick() # 1, 2 by_five() # 105 tick() # 3 - unaffected ``` This is the property that makes closures a real alternative to objects rather than a curiosity: the factory call plays the role of `__init__`, and the returned function plays the role of a method. ### Several functions can share one state Return more than one inner function and they close over the *same* enclosing binding, which is how you get an accumulator you can both feed and read: ```python def make_running_mean(): total, count = 0.0, 0 def add(reading): nonlocal total, count total += reading count += 1 def mean(): return total / count if count else 0.0 return add, mean ``` `add` declares both names `nonlocal`; `mean` declares nothing because it only reads. One `nonlocal` statement can list several names, separated by commas. ### The older container idiom, and why `nonlocal` beats it Before Python 3.0 there was no `nonlocal`, so the state was smuggled into a mutable container: ```python def make_counter(): state = [0] def bump(): state[0] += 1 # mutation, not rebinding - so no declaration needed return state[0] return bump ``` This still works today, for the reason covered by the rebind-versus-mutate distinction: `state[0] += 1` calls into the list, it never assigns to `state`. But it is worse on two counts. It hides the intent behind an index that means nothing, and it gives up a compile-time check -- a mistyped key in a dict version compiles fine and fails only when that branch runs, whereas a mistyped `nonlocal` target refuses to import. ### Alternatives worth naming in an interview * **`itertools.count`** covers the pure "give me the next integer" case with no closure at all, and it supports a start and a step. * **`itertools.accumulate`** covers running totals over an existing iterable, which is often what the question really is. * **A class.** An object with an attribute and an `__call__` or an ordinary method does the same job once the state grows past a value or two. It is the right answer whenever the state must be *inspected*, *reset*, *logged*, *serialised* or *subclassed*. ### The real limitations of closure state Closure state is deliberately opaque: the only way to reach `total` is through the functions the factory handed out. That is a feature when you want encapsulation and a liability when you are debugging, because there is no attribute to print and no obvious way to reset the counter without building a new one. Closures are also not picklable, so an accumulator cannot be shipped to another process the way an instance of a module-level class can. And every read or write of the captured variable goes through the returned function, so there is no way to swap the storage without changing the callers. ### Where the idiom genuinely earns its place The strongest everyday use is a decorator that keeps per-decoration state -- a call counter, a one-shot initialiser, a small memo -- because the state is naturally scoped to the single decoration and there is no object for it to live on: ```python import functools def counted(func): calls = 0 @functools.wraps(func) def wrapper(*args, **kwargs): nonlocal calls calls += 1 return func(*args, **kwargs) wrapper.call_count = lambda: calls return wrapper ``` That is the shape to reach for when the state belongs to one wrapping and nobody else needs to see it. The moment a second component wants to read the number, promote it to an object.