Closures Explained – Python

Introduction

Closures in Python are a powerful concept that allows functions to retain access to variables from their enclosing scopes. In this article, we will explore the importance of closures, beginning with local functions, and delve into how Python stores closures.

We will illustrate these concepts using a real-world example to demonstrate their practical application.

The Need for Closures: Local Functions

Functions defined within the scope of another function. They provide encapsulation, allowing us to create helper functions that are only accessible within the enclosing function.

However, local functions alone may not retain access to variables from their enclosing scopes once the enclosing function has finished executing. This is where closures come into play.

Understanding Closures and Variable Retention:

Closures allow local functions to retain access to variables from their enclosing scopes, even after the enclosing function has completed its execution. This behavior is made possible by the way Python stores closures.

Python’s Storage of Closures:

When a local function becomes a closure, Python stores it as a function object along with an associated __closure__ attribute.

This attribute holds references to the variables captured from the enclosing scope, ensuring that the closure retains access to those variables.

If we are trying to refer a variable from enclosing namespace which is not present, then python raises NameError exception.

Real-World Example: Building a Tax Calculator

Let’s explore a real-world example that demonstrates the need for closures and how Python stores closures:

def tax_calculator(tax_rate):
    def calculate_tax(amount):
        tax = (amount * tax_rate) / 100
        total_amount = amount + tax
        print(f"The total amount with tax is: {total_amount}")
    return calculate_tax

calculate_vat = tax_calculator(20)  # Closure for VAT calculation
calculate_sales_tax = tax_calculator(10)  # Closure for sales tax calculation

calculate_vat.__closure__ # This holds references of variables from enclosing scope.
(<cell at 0x04D8599B0: int object at 0x5FA52A1V>,) # Output: reference object

calculate_vat(1000)  # Output: The total amount with tax is: 1200.0
calculate_sales_tax(500)  # Output: The total amount with tax is: 550.0

In this example, we define the tax_calculator function, which takes a tax_rate as an argument and returns the closure calculate_tax. The closure calculate_tax calculates the tax amount and the total amount by applying the tax rate to the provided amount.

By invoking tax_calculator with different tax rates, we create two closures: calculate_vat and calculate_sales_tax. Each closure retains access to its specific tax_rate captured from the enclosing scope.

When we call calculate_vat(1000) and calculate_sales_tax(500), the closures use their respective tax rates to perform the calculations and print the total amount with tax which means that both calls are independent of each other.

Conclusion:

Closures in Python provide a powerful mechanism for functions to retain access to variables from enclosing scopes. By understanding the need for closures and how Python stores them, developers gain the ability to create versatile and specialized functions that encapsulate data and maintain state.

The real-world example of a tax calculator showcases how to use closures to create reusable and customizable functions for different tax scenarios. Embrace the potential of closures in your Python programming to enhance code modularity, encapsulation, and flexibility.