Python Closures — Late Binding Loop Bug in Rate Limiters

Most Python developers hit a wall around the same time: they understand functions, they understand variables, and then they write slightly more complex code and something weird happens — a function 'remembers' a value it seemingly shouldn't have access to anymore. That moment of confusion is actually you bumping into one of Python's most powerful and elegant features: closures. They're not an advanced academic concept — they're built into how Python evaluates and stores functions, and once you get them, a whole class of real-world problems becomes easy to solve.

The problem closures solve is surprisingly common: how do you give a function some persistent, private state without creating a whole class? Before closures, the only clean answer was to write a class with an __init__ method and self.some_value sprinkled everywhere — a lot of ceremony for something conceptually simple. Closures let you attach state to a function directly, keeping that state private and scoped exactly to where it's needed. They're also the engine under the hood of Python decorators, which means understanding closures is the key to understanding one of Python's most widely-used patterns.

By the end of this article you'll know exactly what makes a closure a closure (it's a specific three-part contract Python enforces), you'll be able to write closures that solve real problems like function factories and stateful callbacks, and you'll know the two gotchas that trip up almost every developer the first time they use closures in a loop. Let's build it up from scratch.

What Python Actually Needs to Form a Closure

A closure isn't magic — it's the result of three specific conditions being true at the same time. First, there must be a nested function (a function defined inside another function). Second, the inner function must reference at least one variable from the outer function's scope — not a global variable, not one of its own local variables, but one that belongs to the enclosing function. Third, the outer function must return the inner function. When all three are true, Python doesn't just return a plain function object. It returns a function object bundled together with a snapshot of the variables it referenced from outside. That bundle is the closure.

You can actually inspect this bundle yourself. Every closure in Python has a __closure__ attribute, which is a tuple of 'cell' objects. Each cell holds one of those remembered variables. If a function has no closure, __closure__ is None. This isn't just trivia — it's confirmation that Python is doing real work to preserve that state for you.

The variable that gets captured is called a 'free variable'. It's free because it isn't local to the inner function and isn't global — it floats between those two worlds, owned by the enclosing scope. Understanding this scoping layer (called the Enclosing scope in Python's LEGB rule) is the key to predicting how closures behave.

# Demonstrates the three conditions that form a closure
# and how to inspect the captured state Python stores.

def make_multiplier(factor):           # Outer function defines 'factor'
    """Returns a function that multiplies any number by 'factor'."""

    def multiply(number):              # Inner function — condition 1: nested function
        return number * factor         # References 'factor' from outer scope — condition 2

    return multiply                    # Returns the inner function — condition 3


# Creating two separate multiplier functions from the same template
double = make_multiplier(2)
triple = make_multiplier(3)

print(double(10))   # 'factor' remembered as 2
print(triple(10))   # 'factor' remembered as 3
print(double(7))    # Each closure has its OWN independent 'factor'

# Inspecting the closure internals Python stores under the hood
print(type(double))                         # It's a regular function object
print(double.__closure__)                   # Tuple of cell objects holding captured vars
print(double.__closure__[0].cell_contents)  # The actual value of 'factor' stored inside
print(double.__code__.co_freevars)          # Name of every free variable this closure captured

LEGB Scope Resolution — Step-by-Step Visual

Python resolves variable names using the LEGB rule: Local, Enclosing, Global, Built-in. Closures rely on the Enclosing (E) scope. When Python executes a nested function, it first looks for a variable in the function's local scope (L). If not found, it inspects the enclosing function's local scope (E) — that's where free variables live. Next comes the global module scope (G), then the built-in namespace (B) for functions like len and print. This chain is evaluated at runtime, which is why closures can see updated values of variables until they are called.

Understanding LEGB is crucial for debugging closures. If a variable unexpectedly resolves to a global instead of an enclosing scope, Python skipped the E because either the variable wasn't captured (not referenced in the inner function) or the inner function wasn't truly a closure (not returned). The diagram below walks through a typical scope chain for a closure.

The 'nonlocal' Keyword — Mutating Enclosed Variables

By default, Python treats any assignment inside a nested function as creating a new local variable. To modify a variable from an enclosing (non-global) scope, you must declare it nonlocal. This keyword tells Python: 'bind this name to the variable in the nearest enclosing scope that is not global.' Without nonlocal, writing count += 1 inside a nested function raises UnboundLocalError because Python sees the assignment and considers count local, but then can't find an initial value before the increment.

nonlocal is commonly used in closures that maintain mutable state: counters, accumulators, caches, and retry trackers. It is different from global: nonlocal climbs up only through function scopes, while global bypasses all function scopes and goes straight to the module level.

A key nuance: nonlocal is only valid at the beginning of a function (before any code that uses the variable), and the variable must already exist in an enclosing function scope. If the variable is not defined in any enclosing function, Python raises a SyntaxError at compile time. This is a safety net — it prevents accidental creation of a new global or outer scope variable.

Below is an example that demonstrates correct nonlocal usage for a closure that accumulates a sum.

# Demonstrates 'nonlocal' for mutating an enclosed variable.

def make_accumulator(initial=0):
    total = initial

    def add(x):
        nonlocal total
        total += x
        return total

    return add

acc = make_accumulator(10)
print(acc(5))   # 15
print(acc(3))   # 18
print(acc(-2))  # 16

# Without nonlocal, this would raise UnboundLocalError

# Another pattern: closure with reset capability
def make_mutable_counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    def reset():
        nonlocal count
        count = 0
    return increment, reset

inc, rst = make_mutable_counter()
print(inc())  # 1
print(inc())  # 2
rst()
print(inc())  # 1

Closures With Mutable State — Building a Counter Without a Class

So far the closure variables have been read-only inside the inner function. But what if you need the inner function to update that variable — to keep a running count, for example? This is where Python's nonlocal keyword comes in. Without it, any assignment inside the inner function creates a brand-new local variable and shadows the outer one rather than updating it. Python treats assignment as declaration by default.

nonlocal is your explicit instruction to Python: 'when I assign to this name, go up to the enclosing scope and update the variable there, don't create a new local one.' It's the closure equivalent of the global keyword, but scoped to the enclosing function rather than the module level. You should reach for nonlocal only when you genuinely need mutable state in a closure — if you're using it everywhere, a class is probably the cleaner choice.

The stateful counter pattern is a textbook example, but the real-world version is more interesting: rate limiters, request counters, retry trackers, and progress accumulators all use this exact shape. The closure gives each counter its own private state, completely isolated from any other counter you create from the same factory.

# Simulates an API endpoint call counter with a reset capability.
# Uses 'nonlocal' to mutate state stored in the closure.

def make_request_counter(endpoint_name):
    """Returns a counter function tied to a specific API endpoint."""
    call_count = 0   # This is the state we want to mutate from inside the inner function

    def record_call():
        nonlocal call_count              # Tell Python: update the OUTER 'call_count', don't create a new local one
        call_count += 1
        print(f"[{endpoint_name}] Call #{call_count}")

    def get_count():
        return call_count                # Read-only — no 'nonlocal' needed for reads

    def reset_count():
        nonlocal call_count
        call_count = 0
        print(f"[{endpoint_name}] Counter reset.")

    # Return multiple inner functions as a named tuple for clean access
    # All three share the SAME 'call_count' cell — they're all part of one closure
    return record_call, get_count, reset_count


# Create independent counters for two different endpoints
track_login,  get_login_count,  reset_login  = make_request_counter("/api/login")
track_search, get_search_count, reset_search = make_request_counter("/api/search")

track_login()
track_login()
track_search()
track_login()

print(f"Total login calls:  {get_login_count()}")
print(f"Total search calls: {get_search_count()}")

reset_login()
print(f"Login count after reset: {get_login_count()}")

The Classic Loop-Closure Gotcha (And Two Ways to Fix It)

Here's the trap that catches almost every developer writing closures inside a loop for the first time. You want to create a list of functions, each capturing a different loop variable. You write what looks like perfectly reasonable code, run it, and every single function in the list returns the same value — the last value the loop variable had. This isn't a bug in Python. It's the correct behaviour once you understand what closures actually capture.

A closure captures a variable by reference, not by value. That means all the inner functions point to the same index variable in the enclosing scope. By the time you call any of those functions, the loop has finished and index has settled at its final value. Every function looks up index right then, at call time, and sees the same thing.

There are two clean fixes. The first is to use a default argument in the inner function (def greet(name=name):), which forces the current value to be captured by value at definition time. The second is to wrap the inner function in another function call that immediately captures the current value in its own closure scope. Both work — the default argument approach is slightly more Pythonic for simple cases.

# Demonstrates the classic loop-closure bug and TWO correct fixes.

user_names = ["alice", "bob", "carol"]

# ---- THE BUG ------------------------------------------------
buggy_greeters = []
for name in user_names:
    def greet_buggy():
        return f"Hello, {name}!"   # Captures 'name' BY REFERENCE — looks it up at call time
    buggy_greeters.append(greet_buggy)

# Loop is done, 'name' is now "carol" for everyone
print("Buggy output:")
for greeter in buggy_greeters:
    print(greeter())   # Every function sees the LAST value of 'name'

# ---- FIX 1: Default Argument (captures value at definition time) ----
fixed_greeters_v1 = []
for name in user_names:
    def greet_with_default(captured_name=name):  # Default arg evaluated NOW, not at call time
        return f"Hello, {captured_name}!"
    fixed_greeters_v1.append(greet_with_default)

print("\nFix 1 — Default argument:")
for greeter in fixed_greeters_v1:
    print(greeter())

# ---- FIX 2: Wrapping factory (creates a fresh enclosing scope each iteration) ----
def make_greeter(person_name):          # Each call to make_greeter creates a NEW scope
    def greet():                        # 'person_name' is bound fresh in each scope
        return f"Hello, {person_name}!"
    return greet

fixed_greeters_v2 = [make_greeter(name) for name in user_names]

print("\nFix 2 — Factory function:")
for greeter in fixed_greeters_v2:
    print(greeter())

Closures and Decorators: The Hidden Relationship

Python decorators are the most widespread real-world use of closures. Every time you write @cache or @staticmethod, you're relying on the fact that a function can wrap another function and carry state. The decorator pattern is a closure: the outer function (the decorator) accepts a function, and the inner function (the wrapper) captures that function and adds behaviour before/after calling it.

Understanding this relationship demystifies decorators. When you see @decorator, Python calls decorator(func) and stores the returned closure in place of func. That returned closure references the original function and any configuration passed to the decorator factory. This means you can create parameterised decorators (like @retry(max_attempts=3)) by nesting three levels: outer factory returns a decorator, which returns a wrapper closure.

Be careful with decorator stacking: each decorator adds one layer of closure indirection. Too many layers can hurt readability and performance. Also, functools.wraps is essential to preserve the original function's metadata — without it, the wrapped closure will have the wrong __name__ and __doc__, breaking introspection tools and documentation generators.

# Demonstrates how decorators are closures wrapping the original function.
import functools
import time

def timer_decorator(func):
    """Outer function receives the decorated function. Returns a closure."""
    @functools.wraps(func)  # This copies __name__, __doc__, etc. from func to wrapper
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)      # 'func' is a free variable captured by the closure
        end = time.perf_counter()
        print(f"{func.__name__} took {end - start:.4f}s")
        return result
    return wrapper

@timer_decorator
def slow_add(a, b):
    """Add two numbers after a nap."""
    time.sleep(0.1)
    return a + b

print(slow_add(3, 4))            # Output shows time, then 7
print(f"Name: {slow_add.__name__}")  # Without @wraps, this would be 'wrapper'
print(f"Doc:  {slow_add.__doc__}")   # Without @wraps, this would be None

# To verify this is a closure, inspect:
print("Closure?", slow_add.__closure__ is not None)
print("Free vars:", slow_add.__code__.co_freevars)

Closure vs Class: Memory and Syntax Comparison

When building stateful callables, developers often wonder whether to use a closure or a class. Both can hold state and expose behaviour, but they differ in syntax overhead, memory usage, and capabilities. This section breaks down the practical trade‑offs so you can make an informed decision.

Memory – A closure stores captured variables in cell objects (one cell per free variable). Each cell is approximately 56 bytes on 64‑bit Python, plus the captured object itself. A closure function object adds around 56 bytes of overhead. In contrast, a class instance has an overhead of about 64 bytes plus the instance dictionary (which can be substantial if many attributes are added dynamically). For a single stateful callable with one or two variables, closures are more memory‑efficient.

Syntax – Closures are written as nested functions; the state is implicitly captured. Classes require a class definition, an __init__ method, and explicit self references. For simple cases, closures are far less verbose. However, if you need multiple methods that share state, a closure becomes awkward (you must return a tuple of functions), while a class naturally supports any number of methods.

Introspection – Class attributes are directly accessible via instance.attribute. Closure state is hidden behind __closure__ cells, which makes debugging harder. If you need to inspect or log internal state regularly, a class is clearer.

Inheritance – Closures cannot be subclassed. Classes fully support inheritance, which is essential for polymorphic dispatch.

Pickling – Closures can be pickled only if the outer function is importable and all captured variables are picklable. Class instances are generally easier to pickle.

Below is a comparison table summarising the key differences:

# Example: same functionality — a counter with increment and reset.

# Closure approach
def make_counter_closure(initial=0):
    count = initial
    def increment():
        nonlocal count
        count += 1
        return count
    def reset():
        nonlocal count
        count = initial
    return increment, reset

inc1, reset1 = make_counter_closure(10)
print(inc1())  # 11

# Class approach
class CounterClass:
    def __init__(self, initial=0):
        self.count = initial
    def increment(self):
        self.count += 1
        return self.count
    def reset(self):
        self.count = self.initial  # wait, need to store initial

# But we need to store initial separately:
class CounterClassFixed:
    def __init__(self, initial=0):
        self.initial = initial
        self.count = initial
    def increment(self):
        self.count += 1
        return self.count
    def reset(self):
        self.count = self.initial

c = CounterClassFixed(10)
print(c.increment())  # 11

Why You Should Care About Variable Capture (And When It Bites You)

Closures exist because Python needs to carry around state without allocating a class. The inner function "captures" variables from the enclosing scope — not copies, not snapshots, but live references. That's the power and the pain.

When you return a nested function, it brings along a cell object for each free variable. Inspect it with __closure__ and you'll see tuples of cells. Each cell holds a pointer to the current value. If that value changes before the closure executes, you get the loop-gotcha (already covered), but there's a subtler trap: capturing mutable objects like lists or dicts. You think you're saving a state snapshot; you're actually saving a leash to a shared kennel.

Watch for this in async callbacks. A closure capturing request from a loop iteration will see the last value if the callback fires after the loop finishes. The fix: default argument binding or a factory function that eagerly evaluates. Know your capture semantics, or your production bug will be a silent, data-corrupting ghost.

// io.thecodeforge — python tutorial

# The trap: all closures share the same list object
callbacks = []
for i in range(3):
    shared = []  # same list on each iteration? No, Python re-creates this.
    # But if you do this:
    callbacks.append(lambda: shared)

# All three callbacks return the same list (the last one)
print([cb() for cb in callbacks])

# The fix: bind the list eagerly
def make_callback(data):
    return lambda d=data: d

callbacks = [make_callback([i]) for i in range(3)]
print([cb() for cb in callbacks])

Factory Functions — Why You Build Functions That Build Functions

Factory functions are the classic closure use case. You've got a function that takes a parameter and returns a new function hard-wired with that parameter. No class, no __init__, no boilerplate. Just a closure that remembers what you gave it.

Example: an API rate limiter. You need different rate limits per endpoint. Write one factory, get back throttled callers that each carry their own wait time. No global state, no inheritance tree, no nonsense. Just a cell with a float.

Here's the production angle: factory functions let you parameterize behavior at definition time, not call time. That means you can precompute static data, validate arguments once, and fail fast during module import instead of silently at 3 AM. If the factory raises, you know immediately that your configuration is broken. That's worth more than a pretty class hierarchy.

When to avoid? If you need multiple methods or serialization, use a class. But for a single-method state-holder, a factory closure is less code, less cognitive load, and easier to test in isolation.

// io.thecodeforge — python tutorial

def rate_limiter(max_calls, period_seconds):
    """Returns a function that tracks call count per time window."""
    calls = []

    def check_allowed():
        now = __import__('time').time()
        # purge old calls
        while calls and calls[0] < now - period_seconds:
            calls.pop(0)
        if len(calls) >= max_calls:
            return False
        calls.append(now)
        return True

    return check_allowed

# Usage: different limits for different endpoints
login_limiter = rate_limiter(5, 60)    # 5 per minute
search_limiter = rate_limiter(30, 60)  # 30 per minute

# Simulate calls
for _ in range(6):
    print(login_limiter())

Memoization With Closures — Caching Without a Class

Memoization is the poster child for closures. You wrap a pure function with a cache dictionary that lives in the closure's scope. The first call computes and stores; subsequent calls hit the cache. No global dict, no class instance, no decorator syntax needed if you want to keep it explicit.

The closure captures the cache dict. Every invocation of the inner function sees the same dict cell. That's the entire trick — a mutable container that persists across calls. Python's functools.lru_cache does this with fancier features (like max size and thread safety), but under the hood it's exactly this pattern: a dict in a closure.

Why not just use a class? Because a closure-based memoizer has zero public API surface. No one can accidentally clear the cache from outside. No one can inspect internals. That's encapsulation without the ceremony of private attributes. If the function is pure and the computation is expensive, this pattern saves you from writing a class that's nothing but __init__, __call__, and one private dict.

Performance note: the dict lookup is O(1) average. But the closure itself adds a tiny overhead per call — around 50-100ns in CPython. For memoization, that's noise compared to any real computation.

// io.thecodeforge — python tutorial

def memoize(func):
    cache = {}

    def wrapper(n):
        if n not in cache:
            cache[n] = func(n)
        return cache[n]

    return wrapper

@memoize
def fibonacci_closed(n):
    if n < 2:
        return n
    return fibonacci_closed(n-1) + fibonacci_closed(n-2)

# Manual equivalent, no decorator
# fib = memoize(fib)

print(fibonacci_closed(10))
print(fibonacci_closed(100))
# This would explode without memoization

Stop Using Closures As Crappy Classes

You already have classes. Use them. Closures capture state by accident, not by design. Every time you find yourself writing a closure that holds five variables and returns three different inner functions, you've built a class with extra steps and zero readability.

The production rule: if your closure has more than one captured variable, or if it returns more than one function, refactor to a class. Closures shine for single-responsibility factories — one input, one output, zero surprises. Classes are explicit. Closures are sneaky. Don't make your team debug captured state at 3 AM because someone forgot which scope a variable lives in.

Your senior engineer will thank you. Your future self will curse you for the alternative.

// io.thecodeforge — python tutorial

# Closure version — brittle, hard to extend
class CounterClosure:
    def make_counter():
        count = 0
        def inc():
            nonlocal count
            count += 1
            return count
        def reset():
            nonlocal count
            count = 0
        return {'inc': inc, 'reset': reset}

# Class version — obvious, testable, extendable
class CounterClass:
    def __init__(self):
        self._count = 0
    def inc(self):
        self._count += 1
        return self._count
    def reset(self):
        self._count = 0

c = CounterClass()
print(c.inc())
print(c.inc())
c.reset()
print(c.inc())

Partial Application: The Closure You Didn't Know You Had

functools.partial is a closure without the nonsense. You get the same variable capture, but it's readable, tested, and doesn't require you to manually nest functions. It's the closure pattern that landed in the standard library because people kept writing buggy versions of it.

The WHY: partial binds arguments without executing the function. That's closure behavior — capturing values — without the scope resolution headaches or nonlocal keyword. Your team reads it instantly. No nested defs. No wondering which frame a variable belongs to.

Real-world win: database query factories. You bind a connection once, then call the partial repeatedly. Performance identical to a hand-rolled closure. Maintenance cost: zero. Don't write what the standard library already gave you.

// io.thecodeforge — python tutorial

from functools import partial

# Closure way — manual, error-prone
def query_builder(conn_str):
    def query(sql):
        print(f"Querying {conn_str}: {sql}")
        return f"results for {sql}"
    return query

# Partial way — explicit, standard
class QueryBuilder:
    def __init__(self, conn_str):
        self.conn_str = conn_str
    def query(self, sql):
        print(f"Querying {self.conn_str}: {sql}")
        return f"results for {sql}"

db_query = partial(QueryBuilder("prod-db").query)
print(db_query("SELECT * FROM users"))

Closures in Decorators: Capturing State

Decorators are a powerful feature in Python that allow you to modify or enhance functions without changing their definition. Under the hood, decorators often rely on closures to capture state from the enclosing scope. When you define a decorator that takes arguments or maintains internal state, closures enable the inner wrapper function to access variables from the outer decorator function even after the decorator has returned.

Consider a simple retry decorator that retries a function a specified number of times on failure. The decorator function retry takes max_attempts as an argument and returns a wrapper that captures this variable via closure. The wrapper then calls the original function and retries on exceptions, decrementing a counter each time. The closure ensures that max_attempts is available to the wrapper each time the decorated function is called.

```python import functools

def retry(max_attempts): def decorator(func): @functools.wraps(func) def wrapper(args, kwargs): attempts = 0 while attempts < max_attempts: try: return func(args, **kwargs) except Exception as e: attempts += 1 if attempts == max_attempts: raise return None return wrapper return decorator

@retry(max_attempts=3) def unstable_network_call(): import random if random.random() < 0.7: raise ConnectionError("Network error") return "Success"

print(unstable_network_call()) ```

In this example, max_attempts is captured by the closure wrapper. Each time unstable_network_call is invoked, the wrapper accesses the captured max_attempts to control the retry loop. This pattern is common in real-world decorators like caching, rate limiting, and logging, where state must be preserved across multiple calls.

Key point: The closure captures the variable max_attempts from the enclosing scope of the retry function. Even after retry returns, the wrapper retains access to max_attempts. This is the essence of closures in decorators: they allow decorators to carry configuration or state without using global variables or classes.

import functools

def retry(max_attempts):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            attempts = 0
            while attempts < max_attempts:
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    attempts += 1
                    if attempts == max_attempts:
                        raise
            return None
        return wrapper
    return decorator

@retry(max_attempts=3)
def unstable_network_call():
    import random
    if random.random() < 0.7:
        raise ConnectionError("Network error")
    return "Success"

print(unstable_network_call())

nonlocal Statement: Modifying Captured Variables

In Python, closures can capture variables from the enclosing scope, but by default, you cannot reassign them. The nonlocal statement allows you to modify variables that are in an outer (but not global) scope. Without nonlocal, assigning to a variable inside a nested function creates a new local variable, shadowing the outer one. This is crucial when you need to update state across multiple calls to the inner function.

Consider a closure-based counter that increments a count each time it's called. Without nonlocal, the inner function would create a new local count variable, and the counter would never increment. With nonlocal, the inner function can modify the outer count variable, preserving state across calls.

```python def make_counter(): count = 0 def counter(): nonlocal count count += 1 return count return counter

counter_a = make_counter() print(counter_a()) # 1 print(counter_a()) # 2

counter_b = make_counter() print(counter_b()) # 1 (independent state) ```

In this example, nonlocal count tells Python that count is not local to counter but is defined in the enclosing scope of make_counter. Each call to counter_a modifies the same count variable, so the counter increments. Each call to make_counter creates a new closure with its own count, so counter_b starts at 1.

Without nonlocal, the code would raise an UnboundLocalError or silently create a local variable, breaking the closure's intended behavior. The nonlocal statement is essential for closures that need to maintain mutable state, such as accumulators, caches, or state machines.

Note: nonlocal works only for variables in enclosing function scopes, not global or module-level variables. For global variables, use the global statement.

def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

counter_a = make_counter()
print(counter_a())  # 1
print(counter_a())  # 2

counter_b = make_counter()
print(counter_b())  # 1 (independent state)

Closures vs Classes: When to Use Each

Both closures and classes can encapsulate state and behavior, but they have different strengths. Closures are lightweight, functional-style constructs that capture variables from an enclosing scope. Classes are more feature-rich, supporting inheritance, methods, and multiple instances with shared behavior. Choosing between them depends on the complexity of the state and the need for extensibility.

Use closures when: - You need a simple callable with minimal state (e.g., a counter, a multiplier). - You want to avoid defining a full class for a single function. - You are working in a functional programming style or need to pass stateful functions as arguments. - The state is small and unlikely to grow.

Use classes when: - You need multiple methods that operate on the same state. - You want to define a type with its own identity (e.g., for isinstance checks). - You need inheritance or polymorphism. - The state is complex or involves many attributes.

Consider a simple multiplier: a closure can capture a factor and return a function that multiplies its argument by that factor. A class would require defining a __call__ method. The closure is more concise.

```python # Closure approach def make_multiplier(factor): def multiply(x): return x * factor return multiply

times2 = make_multiplier(2) print(times2(5)) # 10

# Class approach class Multiplier: def __init__(self, factor): self.factor = factor def __call__(self, x): return x * self.factor

times2_class = Multiplier(2) print(times2_class(5)) # 10 ```

For a counter with multiple operations (increment, reset, get value), a class is more appropriate because it groups related methods. A closure would require returning multiple functions or a dictionary, which is less elegant.

In summary, closures are best for simple, single-method stateful functions, while classes excel when you need a full-fledged object with multiple behaviors and potential for extension.

# Closure approach
def make_multiplier(factor):
    def multiply(x):
        return x * factor
    return multiply

times2 = make_multiplier(2)
print(times2(5))  # 10

# Class approach
class Multiplier:
    def __init__(self, factor):
        self.factor = factor
    def __call__(self, x):
        return x * self.factor

times2_class = Multiplier(2)
print(times2_class(5))  # 10