3.4. global and nonlocal Keywords

• global: Used to modify global variables inside a function.

The global keyword is used in Python functions to declare that a variable inside the function refers to a variable that exists outside of the function's scope. If you want to change the value of a global variable from within a function, you must specify that it is global using the keyword global. This informs Python to use the existing global variable instead of creating a new local variable with the same name.

Imagine you have a box (the global variable) that you store items (data) in, and you sometimes need to access this box from multiple rooms (functions) in your house (program). If you want to change the contents of the box from one of the rooms, you need to point specifically to the actual box in the living room rather than creating a new smaller box just for that room. Using 'global' is like saying, 'I want to refer to the box in the living room, not create my own smaller box here.'

Example:

x = 5
def change():
    global x
    x = 10
change()
print(x)  # Output: 10

In this example, we start with a global variable x initialized to 5. The function change() uses the global keyword to indicate that x refers to the global variable. Inside the function, x is set to 10, which changes the global variable's value. After calling change(), when we print x, it will output 10 instead of 5 because the global variable was modified inside the function.

Think of this as changing the number of cookies in a jar (global variable) located in the kitchen. By saying, 'I want to change the cookie count in the kitchen jar', you are ensuring that everyone accessing the kitchen jar will see the updated count of cookies instead of just a few cookies stored in a personal bag (local variable) in your room.

• nonlocal: Used in nested functions to modify a variable in the outer (non-global) scope.

The nonlocal keyword is used in nested functions to indicate that a variable should not be considered local to the inner function, but instead refers to a variable in the nearest enclosing scope that is not global. This is important when you want to modify a variable defined in an outer function's scope from within a nested function.

Imagine you have a multi-story house where you store items in different rooms (functions). If you want to access an item stored in a storage room (the outer function) from a bedroom (the nested function), you can use nonlocal to say, 'Please refer to the storage room for this item instead of thinking I’m putting it in this bedroom.'

Example:

def outer_function():
    x = 5
    def inner_function():
        nonlocal x
        x = 10
    inner_function()
    print(x)  # Output: 10
outer_function()

In this code, outer_function defines a variable x with the value 5. The inner_function, which is nested inside the outer function, uses the nonlocal keyword to indicate that the x it refers to is from the enclosing scope, i.e., outer_function. When inner_function is called, it modifies x to be 10. When we print x from the outer_function, it reflects the updated value of 10.

Think of this like a family decision-making process across multiple generations. If a grandparent (the outer function) wants to change something that affects the whole family but invites their children (the inner function) to help with the decision, using nonlocal ensures that any changes they discuss refer back to the original family agreement rather than creating a new rule just for the children.

--