28. Nested Functions and Nonlocal variables

Quiz: 0/5

Nested functions and nonlocal variables are powerful concepts in Python that allow you to manage variable scope effectively. Mastering these concepts is essential for writing cleaner, modular, and more structured code.

Nested Functions

A nested function is a function defined inside another function. The inner function has access to variables from the outer function's scope but maintains its own local scope.

Example: Using nested functions

def outer_function():
    outer_variable = "I'm from the outer function!"

    def inner_function():
        print(outer_variable)  # Accessing the outer function's variable

    inner_function()  # Calling the inner function

outer_function()  # Output: I'm from the outer function!

Key points:

• inner_function() is defined inside outer_function().
• The inner function can access variables from the outer function's scope, such as outer_variable.
• However, variables defined in inner_function()are local to it and cannot be accessed by the outer function.

Nonlocal variables

Sometimes, you might need to modify a variable from an enclosing (outer) function's scope within a nested function. This is where the nonlocal keyword comes into play.

The nonlocal keyword tells Python to search for a variable in the nearest enclosing scope that is not global.

Example: Modifying outer variables with nonlocal

def outer_function():
    count = 0  # Variable in the outer function

    def inner_function():
        nonlocal count  # Declare that we want to modify the outer variable
        count += 1
        print(count)

    inner_function()  # Output: 1
    inner_function()  # Output: 2

outer_function()

Key points:

• count is defined in the outer_function().
• The nonlocal keyword allows the inner function to modify the count variable from the outer scope.
• Each time inner_function() is called, it increments the count variable.

Why use nested functions and nonlocal?

Nested functions and nonlocal variables are especially useful for:

• Encapsulation: Keeping helper functions private to their enclosing function.
• State Management: Preserving and modifying state across multiple calls to a nested function.
• Modular Code: Breaking down complex logic into smaller, manageable units.

Summary

• Nested Functions: Let you define a function inside another function, with access to variables in the outer scope.
• Nonlocal Variables: Allow you to modify variables from the outer function's scope within a nested function.

By using these features, you can write more modular and efficient code while maintaining proper control over variable scope. These concepts are particularly valuable in scenarios involving closures, decorators, or stateful functions.