Python Closures: How They Work, Examples and Use Cases

Common Mistakes With Closures

Python closures can be confusing when a nested function uses variables from an enclosing function. Beginners often make a few common mistakes that can prevent a closure from working as expected. Here are some common mistakes to watch for:

1. Forgetting to Return the Inner Function
2. Confusing Local and Enclosing Variables
3. Modifying an Enclosed Variable Without nonlocal

1. Forgetting to Return the Inner Function

A closure normally needs the outer function to return the inner function so you can call it after the outer function finishes.

A common mistake is calling the inner function inside the outer function instead of returning it:

Error Example: Forgetting to Return the Inner Function

def create_greeting(name):

    def greet():
        return f"Hello, {name}!"

    greet()

greeting = create_greeting("Alice")

print(greeting)


# Output
None

Explanation: The outer function calls greet(), but it does not return the function or its result. As a result, create_greeting() returns None.

Correct Example: Returning the Inner Function

Return the inner function when you want to use the closure later:

def create_greeting(name):

    def greet():
        return f"Hello, {name}!"

    return greet

greeting = create_greeting("Alice")

print(greeting())


# Output:
Hello, Alice!

↑ Move to Section Top

2. Confusing Local and Enclosing Variables

Note: This is not a coding error by itself, but beginners can sometimes confuse variables from the inner function with variables from the enclosing function.

An inner function can access a variable from its enclosing function, but a variable created inside the inner function belongs to the inner function.

Error Example: Using a Local Variable Outside Its Function

def create_greeting(name):

    def greet():
        message = f"Hello, {name}!"
        return message

    return greet

greeting = create_greeting("Alice")

print(message)


# Output:
NameError

Explanation: Here, name comes from the enclosing function, while message is local to greet(). The message variable exists only inside greet(), so trying to use it outside that function causes a NameError.

Correct Example: Accessing the Local Variable

def create_greeting(name):

    def greet():
        message = f"Hello, {name}!"
        return message

    return greet

greeting = create_greeting("Alice")

print(greeting())


# Output:
Hello, Alice!

Explanation: Here, message is used inside greet(), where it was created. The returned value can then be accessed through greeting().

Note: Always keep track of where each variable is created and which function owns it.

↑ Move to Section Top

3. Modifying an Enclosed Variable Without nonlocal

A closure can read an enclosed variable without nonlocal. However, assigning a new value to that variable inside the inner function requires nonlocal.

Error Example: Without nonlocal

def create_counter():
    count = 0

    def counter():
        count += 1
        return count

    return counter

Explanation: Python treats count as a local variable inside counter() because the function assigns a new value to it. The code therefore raises an UnboundLocalError.

Correct Example: With nonlocal

Use nonlocal to tell Python that count belongs to the enclosing function:

def create_counter():
    count = 0

    def counter():
        nonlocal count
        count += 1
        return count

    return counter

counter = create_counter()

print(counter())
print(counter())


# Output:
1
2

Explanation: The nonlocal statement lets counter() modify the count variable from create_counter() instead of creating a new local variable.

↑ Move to Section Top