Python Closures

Last Updated : 11 Dec, 2024

In Python, a closure is a powerful concept that allows a function to remember and access variables from its lexical scope, even when the function is executed outside that scope. Closures are closely related to nested functions and are commonly used in functional programming, event handling and callbacks.

A closure is created when a function (the inner function) is defined within another function (the outer function) and the inner function references variables from the outer function. Closures are useful when you need a function to retain state across multiple calls, without using global variables.

A Basic Example of Python Closures

Let's break down a simple example to understand how closures work.

Python

def fun1(x):
  
    # This is the outer function that takes an argument 'x'
    def fun2(y):
      
        # This is the inner function that takes an argument 'y'
        return x + y  # 'x' is captured from the outer function
    
    return fun2  # Returning the inner function as a closure

# Create a closure by calling outer_function
closure = fun1(10)

# Now, we can use the closure, which "remembers" the value of 'x' as 10
print(closure(5))

Output

Explanation:

Outer Function (fun1): Takes an argument x and defines the fun2. The fun2 uses x and another argument y to perform a calculation.
Inner Function (fun2): This function is returned by fun1 and is thus a closure. It "remembers" the value of x even after fun1has finished executing.
Creating and Using the Closure: When you call fun1(10), it returns fun2 with x set to 10. The returned fun2(closure) is stored in the variable closure. When you call closure(5), it uses the remembered value of x (which is 10) and the passed argument y (which is 5), calculating the sum 10 + 5 = 15.

Let's take a look at python closure in detail:

Example of Python closure:

Python

def fun(a):
    # Outer function that remembers the value of 'a'
    def adder(b):
        # Inner function that adds 'b' to 'a'
        return a + b
    return adder  # Returns the closure

# Create a closure that adds 10 to any number
val = fun(10)

# Use the closure
print(val(5))  
print(val(20))

Output

15
30

In this example:

fun(10) creates a closure that remembers the value 10 and adds it to any number passed to the closure.

How Closures Work Internally?

When a closure is created, Python internally stores a reference to the environment (variables in the enclosing scope) where the closure was defined. This allows the inner function to access those variables even after the outer function has completed.

In simple terms, a closure "captures" the values from its surrounding scope and retains them for later use. This is what allows closures to remember values from their environment.

Use of Closures

Encapsulation: Closures help encapsulate functionality. The inner function can access variables from the outer function, but those variables remain hidden from the outside world.
State Retention: Closures can retain state across multiple function calls. This is especially useful in situations like counters, accumulators, or when you want to create a function factory that generates functions with different behaviors.
Functional Programming: Closures are a core feature of functional programming. They allow you to create more flexible and modular code by generating new behavior dynamically.