Scopes & Nested Functions

Nested Functions

In Python, you can define functions inside other functions. These are known as nested or inner functions.

def outer_function(message):
    def inner_function():
        # Inner function has access to variables in outer_function!
        print(f"Message from inner: {message}")
        
    inner_function()

outer_function("Hello from Outer!")

Scope of Variables

The scope of a variable refers to the region of a program where a variable is recognized and can be accessed. Python defines three main scopes inside functions:

Local Scope: Variables created inside a function. They only exist while the function is running.
Enclosing (Nonlocal) Scope: Variables in the outer function of a nested function.
Global Scope: Variables defined at the top level of the file.

LEGB Rule

When you reference a variable name, Python searches for it in a strict order:

Local: First, it looks inside the current function.
Enclosing: Next, it looks at any outer (enclosing) functions.
Global: Then, it looks at variables defined at the top level of the script.
Built-in: Finally, it looks at Python’s pre-loaded built-in functions/constants (like len, print, None).

If the variable is not found in any scope, Python raises a NameError.

# Global variable
x = "global"

def outer():
    # Enclosing variable
    x = "enclosing"
    
    def inner():
        # Local variable
        x = "local"
        print(x) # Prints "local"
        
    inner()

outer()

The `global` Keyword

If you want to modify a global variable from inside a function, you must declare it using the global keyword. Without it, Python creates a new local variable instead.

counter = 0

def increment():
    global counter  # Tells Python to use the global 'counter'
    counter += 1

increment()
print(counter)  # 1

Precaution: Avoid overusing global variables. They make code harder to debug and maintain because any function can change them at any time.

The `nonlocal` Keyword

Similar to global, if you want to modify a variable in the enclosing (outer) function’s scope from inside an inner function, you must use the nonlocal keyword.

def outer_function():
    message = "Hello from Outer"  # Enclosing variable
    
    def inner_function():
        nonlocal message  # Tells Python to use 'message' from outer_function
        message = "Hello from Inner!"  # Modifies outer variable
        
    inner_function()
    print(message)  # Prints: Hello from Inner!

outer_function()

If you omit nonlocal message inside inner_function(), the change message = "Hello from Inner!" would only create a local variable named message inside the inner function, leaving the outer function’s variable unchanged.

What’s next?

Now that you know how variable scopes work, let’s look at Recursion — where a function calls itself to solve problems.

Recursion

Learn how functions call themselves

Functions

Classes

Error handling

Modules & Packages

Extending Python

Nested Functions

Scope of Variables

LEGB Rule

The `global` Keyword

The `nonlocal` Keyword

What’s next?

Recursion

​Nested Functions

​Scope of Variables

​LEGB Rule

​The global Keyword

​The nonlocal Keyword

​What’s next?

Recursion

Nested Functions

Scope of Variables

LEGB Rule

The `global` Keyword

The `nonlocal` Keyword

What’s next?