Returning Functions in Python: Closures and Factories
Learn how to return functions in Python, how closures capture state, when to use factory functions, and how to avoid common closure pitfalls.

In Python, functions are first-class objects: you can pass them as arguments, store them in data structures, and return them from other functions. A function that returns another function is a higher-order function. This pattern makes closures, factory functions, and decorators possible.
The Core Pattern
When a function returns another function, the returned function is usually defined inside the outer function. This gives the inner function access to the outer function's local variables, even after the outer function has finished executing. That behavior is known as a closure.
Here's a minimal example:
def make_multiplier(factor):
def multiplier(x):
return x * factor
return multiplier
times_two = make_multiplier(2)
print(times_two(5)) # 10The inner function multiplier captures factor from the enclosing scope. Each call to make_multiplier creates a new closure with its own factor value, so separate closures such as times_two = make_multiplier(2) and times_three = make_multiplier(3) behave independently.
How Closures Capture State
When you return a nested function, Python keeps the variables it references from the enclosing scope alive as long as the returned function exists. This is not a copy of the values; the closure references the variables themselves. If the outer function changes one of those variables after defining the inner function, the inner function sees the updated value when called.
Consider a counter:
def make_counter():
count = 0
def increment():
nonlocal count
count += 1
return count
return increment
counter = make_counter()
print(counter()) # 1
print(counter()) # 2The nonlocal keyword is required when you want to reassign a variable from the enclosing scope. Without it, Python treats count as a new local variable in increment, causing an UnboundLocalError. This is a common pitfall when first working with closures.
Practical Use Cases for Function Factories
Function factories are useful when you need to generate specialized functions based on configuration. For example, you can create a logger that prefixes messages with a level or a user ID:
def make_logger(prefix):
def log(message):
print(f"[{prefix}] {message}")
return log
info_logger = make_logger("INFO")
error_logger = make_logger("ERROR")
info_logger("Application started")
error_logger("File not found")This pattern avoids repeating the prefix logic at every call site and keeps configuration encapsulated. It is also common in data processing pipelines where transformations depend on runtime parameters.
Using Returned Functions in Decorators
Decorators are a direct application of functions returning functions. A decorator is a callable that takes a function and returns a new function, usually adding behavior around the original.
def uppercase_decorator(func):
def wrapper(*args, **kwargs):
result = func(*args, **kwargs)
return result.upper()
return wrapper
@uppercase_decorator
def greet(name):
return f"Hello, {name}"
print(greet("Alice")) # HELLO, ALICEHere, uppercase_decorator returns the wrapper function. The @ syntax is syntactic sugar for greet = uppercase_decorator(greet). Understanding how functions return functions helps when writing or debugging decorators, especially decorators that accept arguments.
Performance and Memory Considerations
Returning functions creates closures that hold references to captured variables. Each returned function keeps its own closure environment alive, so creating many functions with distinct captured state increases memory usage. For typical use, this overhead is small. If you are creating a large number of closures, measure the impact rather than guessing.
In CPython, reading a closure variable has a small lookup cost compared with reading a plain local variable, but the difference is rarely significant. If profiling shows that function-call overhead matters, a class with a __call__ method can be a clearer alternative because state is stored in explicit instance attributes.
When to Choose a Function Factory Over a Class
Both function factories and classes can encapsulate state. The choice depends on the complexity of the behavior. A function factory is simpler when you only need to maintain a small amount of state and expose a single callable. A class becomes clearer when you need multiple methods, properties, or inheritance.
For example, a counter with reset functionality is easier as a class:
class Counter:
def __init__(self):
self.count = 0
def increment(self):
self.count += 1
return self.count
def reset(self):
self.count = 0But if you only need the increment behavior, the factory version is more concise. Use a factory for lightweight, single-purpose callables; use a class when the object needs a richer interface.
Common Pitfalls and How to Avoid Them
One common mistake is forgetting nonlocal when modifying captured variables. Another is accidentally creating closures that capture a loop variable that changes. For example:
funcs = []
for i in range(3):
def f():
return i
funcs.append(f)
for f in funcs:
print(f()) # 2 2 2The closures all capture the same i variable, which ends up as 2. To fix this, pass i as a default argument or use a factory function:
def make_func(i):
def f():
return i
return f
funcs = [make_func(i) for i in range(3)]This is a classic Python gotcha. Understanding how closures capture variables is key to avoiding it. Another subtle issue is that closures capture variables by reference, not by value, so if the outer function's variable changes after the inner function is defined, the inner function sees the updated value. This can lead to surprising behavior if you create the closure in one context and call it after the captured variable has changed.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.