How Does Python's `nonlocal` Keyword Work?

Understanding "nonlocal" in Python 3: A Deep Dive

Python 3 introduced the powerful "nonlocal" keyword, which allows you to modify variables in an outer scope from within nested functions. This question provides a comprehensive explanation of how "nonlocal" operates.

What is "nonlocal"?

"nonlocal" decouples a variable from the local scope of a nested function, allowing it to access the variable in an outer scope. This is useful when you need to modify a variable in an outer scope without using global variables or other convoluted methods.

How "nonlocal" Works

Consider the following code snippet without using "nonlocal":

x = 0
def outer():
    x = 1
    def inner():
        x = 2
        print("inner:", x)
    inner()
    print("outer:", x)
outer()
print("global:", x)

Output:

inner: 2
outer: 1
global: 0

Notice that modifying the value of x in the inner() function does not affect the value of x in the outer() function. This is because inner() creates a local variable named x that shadows the outer variable with the same name.

Now, let's modify the code using "nonlocal":

x = 0
def outer():
    x = 1
    def inner():
        nonlocal x
        x = 2
        print("inner:", x)
    inner()
    print("outer:", x)
outer()
print("global:", x)

Output:

inner: 2
outer: 2
global: 0

In this case, using "nonlocal" in the inner() function establishes a link to the x variable in the outer() scope. By modifying the variable within the inner function, we effectively modify the same variable in the outer scope.

Using "global" vs. "nonlocal"

The "global" keyword can also be used to access and modify global variables, but it behaves differently from "nonlocal." "global" binds the variable to the truly global scope, while "nonlocal" binds it to the closest enclosing scope.

Consider the following code snippet using "global":

x = 0
def outer():
    x = 1
    def inner():
        global x
        x = 2
        print("inner:", x)
    inner()
    print("outer:", x)
outer()
print("global:", x)

Output:

inner: 2
outer: 1
global: 2

As you can see, modifying the value of x in the inner function now affects the global variable x instead of the outer() scope.

Summary

"nonlocal" is an essential Python keyword that allows you to access and modify variables in outer scopes from nested functions without polluting the global namespace. It provides a clear and efficient way to work with data across multiple scopes, making code more readable and maintainable.

The above is the detailed content of How Does Python's `nonlocal` Keyword Work?. For more information, please follow other related articles on the PHP Chinese website!