Python Closures: Common Use Cases and Examples

Getting to Know Closures in Python

A closure is a function that retains access to its lexical scope, even when the function is executed outside that scope. When the enclosing function returns the inner function, then you get a function object with an extended scope.

In other words, closures are functions that capture the objects defined in their enclosing scope, allowing you to use them in their body. This feature allows you to use closures when you need to retain state information between consecutive calls.

Closures are common in programming languages that are focused on functional programming, and Python supports closures as part of its wide variety of features.

In Python, a closure is a function that you define in and return from another function. This inner function can retain the objects defined in the non-local scope right before the inner function’s definition.

To better understand closures in Python, you’ll first look at inner functions because closures are also inner functions.

>>> def outer_func():
...     name = "Pythonista"
...     def inner_func():
...         print(f"Hello, {name}!")
...     inner_func()
...

>>> outer_func()
Hello, Pythonista!

>>> greeter = outer_func()
>>> print(greeter)
None

>>> def outer_func():
...     name = "Pythonista"
...     def inner_func():
...         print(f"Hello, {name}!")
...     return inner_func
...

>>> outer_func()
<function outer_func.<locals>.inner_func at 0x1066d16c0>

>>> greeter = outer_func()

>>> greeter()
Hello, Pythonista!

>>> def outer_func():
...     name = "Pythonista"
...     return lambda: print(f"Hello, {name}!")
...

>>> greeter = outer_func()
>>> greeter()
Hello, Pythonista!

>>> def outer_func(outer_arg):
...     local_var = "Outer local variable"
...     def closure():
...         print(outer_arg)
...         print(local_var)
...         print(another_local_var)
...     another_local_var = "Another outer local variable"
...     return closure
...

>>> closure = outer_func("Outer argument")

>>> closure()
Outer argument
Outer local variable
Another outer local variable

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

>>> counter = make_counter()

>>> counter()
1
>>> counter()
2
>>> counter()
3

>>> def make_appender():
...     items = []
...     def appender(new_item):
...         items.append(new_item)
...         return items
...     return appender
...

>>> appender = make_appender()

>>> appender("First item")
['First item']
>>> appender("Second item")
['First item', 'Second item']
>>> appender("Third item")
['First item', 'Second item', 'Third item']

Creating Closures to Retain State

In practice, you can use a Python closure in several different situations. In this section, you’ll explore how to use closures to create factory functions, maintain state across function calls, and implement callbacks, enabling more dynamic, flexible, and efficient code.

>>> def make_root_calculator(root_degree, precision=2):
...     def root_calculator(number):
...         return round(pow(number, 1 / root_degree), precision)
...     return root_calculator
...

>>> square_root = make_root_calculator(2, 4)
>>> square_root(42)
6.4807

>>> cubic_root = make_root_calculator(3)
>>> cubic_root(42)
3.48

>>> def cumulative_average():
...     data = []
...     def average(value):
...         data.append(value)
...         return sum(data) / len(data)
...     return average
...

>>> stream_average = cumulative_average()

>>> stream_average(12)
12.0
>>> stream_average(13)
12.5
>>> stream_average(11)
12.0
>>> stream_average(10)
11.5

import tkinter as tk

app = tk.Tk()
app.title("GUI App")
app.geometry("320x240")

label = tk.Label(
    app,
    font=("Helvetica", 16, "bold"),
)
label.pack()

def callback(text):
    def closure():
        label.config(text=text)

    return closure

button = tk.Button(
    app,
    text="Greet",
    command=callback("Hello, World!"),
)
button.pack()

app.mainloop()

Writing Decorators With Closures

Decorators are a powerful feature in Python. You can use decorators to modify a function’s behavior dynamically. In Python, you have two types of decorators:

1. Function-based decorators
2. Class-based decorators

A function-based decorator is a function that takes a function object as an argument and returns another function object with extended functionality. This latter function object is also a closure. So, to create function-based decorators, you use closures.

As you already learned, decorators allow you to modify the behavior of functions without altering their internal code. In practice, function-based decorators are closures. The distinguishing characteristic is that their main goal is to modify the behavior of the function that you pass as an argument to the closure-containing function.

Here’s an example of a minimal decorator that adds messages on top of the input function’s functionality:

>>> def decorator(function):
...     def closure():
...         print("Doing something before calling the function.")
...         function()
...         print("Doing something after calling the function.")
...     return closure
...

In this example, the outer function is the decorator. This function returns a closure object that modifies the original behavior of the input function object by adding extra features. The closure can act on the input function even after the decorator() function has returned.

Here’s how you can use the decorator syntax to dynamically modify the behavior of a regular Python function:

>>> @decorator
... def greet():
...     print("Hi, Pythonista!")
...

>>> greet()
Doing something before calling the function.
Hi, Pythonista!
Doing something after calling the function.

In this example, you use @decorator to modify the behavior of your greet() function. Note that now, when you call greet(), you get its original functionality plus the functionality added by the decorator.

Implementing Memoization With Closures

Caching can improve an algorithm’s performance by avoiding unnecessary recomputation. Memoization is a common caching technique that prevents a function from running more than once for the same input.

Memoization works by storing the result for a given set of input arguments in memory and then referencing it later when necessary. You can use closures to implement memoization.

In the following toy example, you take advantage of a decorator, which is also a closure, to cache values that result from a costly hypothetical computation:

>>> def memoize(function):
...     cache = {}
...     def closure(number):
...         if number not in cache:
...             cache[number] = function(number)
...         return cache[number]
...     return closure
...

Here, memoize() takes a function object as an argument and returns another closure object. The inner function runs the input function only for unprocessed numbers. The processed numbers are cached in the cache dictionary along with the input function’s result.

Now, say that you have the following toy function that mimics a costly computation:

>>> from time import sleep

>>> def slow_operation(number):
...     sleep(0.5)
...

This function holds the code’s execution for just half a second to mimic a costly operation. To do this, you use the sleep() function from the time module.

You can measure the function’s execution time using the following code:

>>> from timeit import timeit

>>> timeit(
...     "[slow_operation(number) for number in [2, 3, 4, 2, 3, 4]]",
...     globals=globals(),
...     number=1,
... )
3.02610950000053

In this code snippet, you use the timeit() function from the timeit module to find out the execution time of slow_operation() when you run this function with a list of values. To process the six input values, the code takes a bit more than three seconds. You can use memoization to make this computation more efficient by skipping the repeated input values.

Go ahead and decorate slow_operation() using @memoize as shown below. Then, run the timing code:

>>> @memoize
... def slow_operation(number):
...     sleep(0.5)
...

>>> timeit(
...     "[slow_operation(number) for number in [2, 3, 4, 2, 3, 4]]",
...     globals=globals(),
...     number=1,
... )
1.5151869590008573

Now the same code takes half the time because of the memoization technique. That’s because the slow_operation() function isn’t running for repeated input values.

Achieving Encapsulation With Closures

In object-oriented programming (OOP), classes provide a way to combine data and behavior in a single entity. A common requirement in OOP is data encapsulation, a principle that recommends protecting an object’s data from the outside world and preventing direct access.

In Python, achieving strong data encapsulation can be a difficult task because there’s no distinction between private and public attributes. Instead, Python uses a naming convention to communicate whether a given class member is public or non-public.

You can use Python closures to achieve stricter data encapsulation. Closures allow you to create a private scope for data, preventing users from accessing that data. This helps maintain data integrity and prevent unintended modifications.

To illustrate, say that you have the following Stack class:

class Stack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

This Stack class stores its data in a list object called ._items and implements common stack operations, such as push and pop.

Here’s how you can use this class:

>>> from stack_v1 import Stack

>>> stack = Stack()
>>> stack.push(1)
>>> stack.push(2)
>>> stack.push(3)

>>> stack.pop()
3

>>> stack._items
[1, 2]

Your class’s basic functionality works. However, even though the ._items attribute is non-public, you can access its values using dot notation as you’d do with a normal attribute. This behavior makes it difficult to encapsulate data to protect it from direct access.

Again, a closure provides a trick for achieving a stricter data encapsulation. Consider the following code:

def Stack():
    _items = []

    def push(item):
        _items.append(item)

    def pop():
        return _items.pop()

    def closure():
        pass

    closure.push = push
    closure.pop = pop
    return closure

In this example, you write a function to create a closure object instead of defining a class. Inside the function, you define a local variable called _items, which will be part of your closure object. You’ll use this variable to store the stack’s data. Then, you define two inner functions that implement the stack operations.

The closure() inner function is a placeholder for your closure. On top of this function, you add the push() and pop() functions. Finally, you return the resulting closure.

You can use the Stack() function mostly in the same way you used the Stack class. One significant difference is that now you don’t have access to ._items:

>>> from stack_v2 import Stack

>>> stack = Stack()
>>> stack.push(1)
>>> stack.push(2)
>>> stack.push(3)

>>> stack.pop()
3

>>> stack._items
Traceback (most recent call last):
    ...
AttributeError: 'function' object has no attribute '_items'

The Stack() function allows you to create closures that work as if they were instances of the Stack class. However, you don’t have direct access to ._items, improving your data encapsulation.

If you get really picky, you can use an advanced trick to access the content of ._items:

>>> stack.push.__closure__[0].cell_contents
[1, 2]

The .__closure__ attribute returns a tuple of cells that contain bindings for the closure’s variables. A cell object has an attribute called cell_contents, which you can use to get the value of the cell.

Even though this trick allows you to access grabbed variables, it’s not typically used in Python code. In the end, if you’re trying to achieve encapsulation, why would you break it?

Exploring Alternatives to Closures

So far, you’ve learned that Python closures can help solve several problems. However, it can be challenging to grasp how they work under the hood, so using an alternative tool can make your code easier to reason about.

You can replace a closure with a class that produces callable instances by implementing the .__call__() special method. Callable instances are objects that you can call as you’d call a function.

To illustrate, get back to the make_root_calculator() factory function:

>>> def make_root_calculator(root_degree, precision=2):
...     def root_calculator(number):
...         return round(pow(number, 1 / root_degree), precision)
...     return root_calculator
...

>>> square_root = make_root_calculator(2, 4)
>>> square_root(42)
6.4807

>>> cubic_root = make_root_calculator(3)
>>> cubic_root(42)
3.48

The function returns closures that retain the root_degree and precision arguments in its extended scope. You can replace this factory function with the following class:

class RootCalculator:
    def __init__(self, root_degree, precision=2):
        self.root_degree = root_degree
        self.precision = precision

    def __call__(self, number):
        return round(pow(number, 1 / self.root_degree), self.precision)

This class takes the same two arguments as make_root_calculator() and turns them into instance attributes.

By providing the .__call__() method, you transform your class instances into callable objects that you can call as regular functions. Here’s how you can use this class to build root calculator function-like objects:

>>> from roots import RootCalculator

>>> square_root = RootCalculator(2, 4)
>>> square_root(42)
6.4807

>>> cubic_root = RootCalculator(3)
>>> cubic_root(42)
3.48

>>> cubic_root.root_degree
3

As you can conclude, the RootCalculator works pretty much the same as the make_root_calculator() function. As a plus, you now have access to configuration arguments like root_degree.

Conclusion

Now you know that a closure is a function object typically defined inside another function in Python. Closures grab the objects defined in their enclosing scope and combine them with the inner function object to create a callable object with an extended scope.

You can use closures in multiple scenarios, especially when you need to retain the state between consecutive function calls or write a decorator. So, knowing how to use closures can be an excellent skill for a Python developer.

In this tutorial, you’ve learned:

• What closures are and how they work in Python
• When closures can be used in practice
• How callable instances can replace closures

With this knowledge, you can start creating and using Python closures in your code, especially if you’re interested in functional programming tools.

Take the Quiz: Test your knowledge with our interactive “Python Closures: Common Use Cases and Examples” quiz. You’ll receive a score upon completion to help you track your learning progress:

---

Interactive Quiz

Python Closures: Common Use Cases and Examples

In this quiz, you'll test your understanding of Python closures. Closures are a common feature in functional programming languages and are particularly popular in Python because they allow you to create function-based decorators.