Why Nonlocal keyword in Python? - Purpose & Use Cases

The Big Idea

What if you could fix tricky bugs by simply telling Python which variable to change inside nested functions?

The Scenario

Imagine you have a small box inside a bigger box, and you want to change something inside the smaller box from outside it. Without a special way, you can only change things in the smallest box or the biggest box, but not the middle one. This is like trying to change a variable inside a nested function without a special keyword.

The Problem

Without the nonlocal keyword, changing a variable inside a nested function creates a new local copy instead of updating the variable in the outer function. This leads to confusion and bugs because the outer variable stays unchanged, making your code behave unexpectedly and harder to fix.

The Solution

The nonlocal keyword lets you tell Python to use the variable from the nearest outer function, not create a new one. This way, you can easily update variables in nested functions, keeping your code clear and working as you expect.

Before vs After

✗ Before

def outer():
    x = 5
    def inner():
        x = 10  # This creates a new local x, outer x stays 5
    inner()
    print(x)  # prints 5

✓ After

def outer():
    x = 5
    def inner():
        nonlocal x
        x = 10  # updates outer x
    inner()
    print(x)  # prints 10

What It Enables

It enables you to cleanly and safely modify variables in outer functions from inside nested functions, making your code easier to write and understand.

Real Life Example

Think of a game where you have a score counter inside a main game function, and a smaller function inside it updates the score. Using nonlocal lets the smaller function change the main score directly without confusion.

Key Takeaways

Without nonlocal, nested functions can't change outer variables properly.

nonlocal tells Python to use the nearest outer variable, not create a new one.

This makes nested function code clearer and less error-prone.