Python Closures

What Are Python Closures?

A closure in Python is when a function is created inside another function, and the inner function remembers the values from the outer function, even after the outer function is done. This is helpful when you want to create a function that remembers some information.

Basic Structure of a Closure

The basic structure of a closure involves two main components:

1. The outer function that defines the environment (the variable(s) you want to "close over").
2. The inner function that uses variables from the outer function and is returned by the outer function.

Here's the general structure of a closure:

def outer_function(outer_variable):
    def inner_function(inner_variable):
        # Inner function uses outer_variable
        return outer_variable + inner_variable
    return inner_function

def outer_function(outer_variable):
    def inner_function(inner_variable):
        # Inner function uses outer_variable
        return outer_variable + inner_variable
    return inner_function

Here's a simple example:

def greet(name):
    def say_hello():
        return "Hello, " + name
    return say_hello

greeting = greet("Tom")
print(greeting())  # Output: Hello, Tom

def greet(name):
    def say_hello():
        return "Hello, " + name
    return say_hello

greeting = greet("Tom")
print(greeting())  # Output: Hello, Tom

How It Works:

• def greet(name): : defines a function called greet that takes a parameter name.
• def say_hello(): : defines a nested function say_hello that returns a personalized greeting.
• return say_hello : returns the say_hello function when greet is called.
• greeting = greet("Tom") : calls the greet function with "Tom" as an argument, and stores the returned function in greeting. The inner function say_hello has access to the outer function's variable name, which is why it can use it to return a personalized greeting.
• print(greeting()) : calls the returned say_hello function and prints its result: "Hello, Tom".

Output:

Hello, Tom

Hello, Tom

Closures with Multiple Variables

A closure can also work with multiple variables. This means the inner function can access several variables from the outer function, not just one.

Here's an example of a closure with multiple variables:

def outer_function(x, y):
    def inner_function(z):
        return x + y + z
    return inner_function

closure = outer_function(5, 10)
print(closure(3))  # Output: 18

def outer_function(x, y):
    def inner_function(z):
        return x + y + z
    return inner_function

closure = outer_function(5, 10)
print(closure(3))  # Output: 18

How It Works:

• def outer_function(x, y): : defines a function called outer_function that takes two parameters x and y.
• def inner_function(z): : defines a nested function inner_function that takes a parameter z.
• return x + y + z : adds x, y, and z together in the inner function.
• closure = outer_function(5, 10) : calls the outer_function with 5 and 10 as arguments, and stores the returned inner function in closure.
• print(closure(3)) : calls the inner function with 3 as an argument and prints the result. The total is 5 + 10 + 3 = 18.

Output:

18

18

Frequently Asked Questions

What's Next?

Up next, you'll explore Python decorators—an advanced use of closures that lets you wrap, enhance, and control functions for logging, validation, and performance timing.