Variable Scope in Python

Variable scope refers to the context in which a variable is accessible within a program. It determines where a variable can be defined, modified, or accessed.

Types of Variable Scope

1. Local Scope

• A variable declared inside a function belongs to the local scope of that function.
• It can only be accessed within the function where it is defined.

2. Enclosing Scope

• This applies to variables in nested functions.
• A variable in the enclosing scope of a nested function is accessible inside the nested function but not outside its enclosing function.

3. Global Scope

• A variable defined outside of any function belongs to the global scope and is accessible anywhere in the program.
• Use the global keyword to modify a global variable inside a function.

4. Built-in Scope

• This is the scope of Python’s built-in functions and keywords.
• These are accessible anywhere in the code unless overridden.

LEGB Rule

Python resolves variable names using the LEGB Rule, which stands for:

1. Local: Variables defined within a function.
2. Enclosing: Variables in enclosing functions (for nested functions).
3. Global: Variables defined at the top level of a script or module.
4. Built-in: Names in Python’s built-in namespace (e.g., len, print).

Key Points to Remember

• Local variables are temporary and exist only during the function’s execution.
• Global variables persist for the program’s duration but should be used sparingly to avoid conflicts.
• Use the nonlocal keyword to modify variables in the enclosing scope.

def my_function():
    local_var = 10  # Local scope
    print(local_var)

my_function()
# This will raise an error (NameError)
# print(local_var)

def outer_function():
    enclosing_var = "Enclosing Scope"

    def inner_function():
        # Accessible inside the inner function
        print(enclosing_var)

    inner_function()

outer_function()

global_var = "Global Scope"

def access_global():
    print(global_var)  # Accessible globally

def modify_global():
    global global_var
    global_var = "Modified Global Scope"

access_global()
modify_global()
print(global_var)  # Output: "Modified Global Scope"

print(len("Python"))  # Built-in function len

def outer_function():
    x = "outer"

    def inner_function():
        nonlocal x
        x = "modified outer"
        print(x)

    inner_function()
    print(x)

outer_function()