Scope of Variables in Python

The scope of a variable refers to the context in which a variable is defined and accessible. In Python, the scope determines the visibility and lifetime of a variable in your code. Understanding variable scope is essential for managing the visibility of variables in functions, classes, and modules.

There are four main types of variable scope in Python:

1. Local Scope
2. Enclosing Scope (Nonlocal)
3. Global Scope
4. Built-in Scope

Let's explore each type in detail.

1. Local Scope

• Definition: A variable defined within a function or a block of code has a local scope. It can only be accessed within that function or block.
• Lifetime: The variable exists only as long as the function is executing.

Example of Local Scope

def my_function():
    local_var = "I am local"  # local_var has a local scope
    print(local_var)

my_function()  # Output: I am local
# print(local_var)  # This will raise a NameError because local_var is not accessible here

In this example, local_var is only accessible within my_function(). Attempting to access it outside the function raises a NameError.

2. Enclosing Scope (Nonlocal)

• Definition: This scope applies to variables defined in a nested function. A variable in an outer (enclosing) function can be accessed from an inner (nested) function but not modified unless specified with the nonlocal keyword.
• Lifetime: The variable exists as long as the outer function is executing.

Example of Enclosing Scope

def outer_function():
    outer_var = "I am outer"

    def inner_function():
        print(outer_var)  # Accessing outer_var from the enclosing scope

    inner_function()  # Output: I am outer

outer_function()

In this example, outer_var is defined in outer_function() and is accessible inside inner_function(), demonstrating the concept of enclosing scope.

Modifying Variables in Enclosing Scope

To modify a variable from the enclosing scope within a nested function, you can use the nonlocal keyword:

def outer_function():
    counter = 0

    def inner_function():
        nonlocal counter  # Specify that we want to use the counter from outer_function
        counter += 1
        print(counter)

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

outer_function()

3. Global Scope

• Definition: A variable defined at the top level of a script or module has a global scope. It can be accessed from any function within the same module.
• Lifetime: The variable exists as long as the program runs.

Example of Global Scope

global_var = "I am global"  # global_var has a global scope

def my_function():
    print(global_var)  # Accessing the global variable

my_function()  # Output: I am global
print(global_var)  # Output: I am global

If you want to modify a global variable within a function, you must use the global keyword:

global_var = "I am global"

def modify_global():
    global global_var  # Specify that we want to use the global variable
    global_var = "I have been modified"

modify_global()
print(global_var)  # Output: I have been modified

4. Built-in Scope

• Definition: This scope contains built-in names that are always available in Python, such as functions like print(), len(), etc.
• Lifetime: These names are available as long as the Python interpreter is running.

Example of Built-in Scope

You can access built-in functions without needing to import them:

print(len("Hello"))  # Output: 5

Summary

• Local Scope: Variables defined within a function are local to that function.
• Enclosing Scope: Variables defined in an outer function can be accessed in a nested function; use nonlocal to modify them.
• Global Scope: Variables defined at the top level of a script/module are accessible from anywhere in the module; use global to modify them within functions.
• Built-in Scope: Contains names that are always available in Python.

Understanding variable scope helps you write more organized and error-free code by keeping track of where variables can be accessed and modified.