Python nonlocal Keyword

The nonlocal keyword in Python is used within nested functions to indicate that a variable refers to a previously bound variable in the nearest enclosing but non-global scope. This allows modification of variables in an outer function from within an inner function without making them global.

Example:

def outer():
    message = "Hello"
    
    def inner():
        nonlocal message  # Reference the enclosing variable
        message = "Hello, Python!"  # Modify it
        print("Inside inner:", message)
    
    inner()
    print("Inside outer:", message)

outer()

Inside inner: Hello, Python!
Inside outer: Hello, Python!

Explanation: Here, nonlocal message ensures that message inside inner() modifies the message variable from outer() instead of creating a new local variable.

Why use nonlocal ?

In Python, variables have different scopes:

• Local Scope: Variables defined inside a function.
• Enclosing Scope: Variables in an enclosing function but not global.
• Global Scope: Variables declared at the top level of the script.
• Built-in Scope: Names preassigned in Python.

When a variable is declared inside a function, it is local by default. The nonlocal keyword allows modifying an enclosing function's variable instead of creating a new local variable.

nonlocal vs global

While both nonlocal and global allow modifying variables from an outer scope, their scope is different:

Example:

a = "I am global"

def outer():
    b = "I am enclosing"
    
    def inner():
        global a
        nonlocal b
        a = "Modified global"
        b = "Modified enclosing"
    
    inner()
    print("Inside outer:", b)
    
outer()
print("Outside outer:", a)

Inside outer: Modified enclosing
Outside outer: Modified global

Explanation: Here, a is modified globally using global, while b is modified in the enclosing scope using nonlocal.

Rules and Restrictions of non local

• It cannot reference global or local variables; it only works within nested functions.
• The variable being referenced must exist in the nearest enclosing function scope.
• nonlocal cannot be used at the module level or in a function without an enclosing scope.

Example: Incorrect usage

# Global variable
global_a = 'geeksforgeeks'

def outer():
    def inner():
        nonlocal global_a # Attempting to reference global variable
        global_a = 'GeeksForGeeks'  # Modifying the variable
        print(global_a)
    inner()
outer()

Output:

Hangup (SIGHUP)
  File "/home/guest/sandbox/Solution.py", line 6
    nonlocal global_a # Attempting to reference global variable
    ^^^^^^^^^^^^^^^^^
SyntaxError: no binding for nonlocal 'global_a' found

Explanation: This will result in an error because nonlocal can only reference variables from an enclosing function, not from the global scope.

Scope resolution with nonlocal

When multiple nested functions have a variable with the same name, nonlocal references the nearest enclosing function’s variable, not the global one.

def fun1():
    name = "geek"
    
    def fun2():
        name = "Geek"
        
        def fun3():
            nonlocal name  
            name = 'GEEK'  # Modify before using
            print(name)  
        
        fun3()
        print(name)  # Modified value in fun2()
    
    fun2()
    print(name)  # Unchanged value in fun1()

fun1()

GEEK
GEEK
geek

Explanation: fun3() uses nonlocal to modify name in fun2() to "GEEK", which both fun3() and fun2() print. fun1() remains unaffected, printing "geek", showing nonlocal affects only the nearest enclosing scope.

Practical application of nonlocal

One common use case of nonlocal is maintaining state in closures, such as implementing a counter function.

def counter():
    count = 0  # Enclosed variable

    def increment():
        nonlocal count  # Reference count from the outer function
        count += 1
        return count

    return increment

# Create a counter instance
counter1 = counter()
print(counter1())  
print(counter1())  
print(counter1())  

1
2
3

Explanation: This code uses nonlocal in a closure to maintain count across calls, allowing increment() to update and return it.

Advantages of nonlocal

• Allows access to variables in an upper scope (excluding global scope).
• Saves memory by reusing the referenced variable’s memory address.
• Useful in closures where state persistence is needed.

Disadvantages of nonlocal

• Cannot be used for global or local scope variables.
• Only applicable within nested functions.