Detailed Explanation of Global and Local Variable Scope in Python

Topic Description:
In Python, variable scope determines where in the program a specific variable can be accessed. Understanding the differences between global and local variables, their access rules, and modification methods is crucial for writing correct and maintainable code. This topic involves the LEGB rule and the usage scenarios of the global and nonlocal keywords.

Detailed Explanation:

1. Distinguishing Basic Concepts

Global Variable: Defined outside of functions, accessible throughout the module (file).
Local Variable: Defined inside a function, valid only within that function.

Example:

x = 10  # Global variable

def test():
    y = 20  # Local variable
    print(f"Local variable y: {y}")
    print(f"Global variable x: {x}")

test()
print(f"Global variable x: {x}")
# print(y)  # This will raise an error; y is a local variable and inaccessible outside

2. Detailed Explanation of the LEGB Rule

When accessing a variable, Python searches in the LEGB order:

• L (Local): Local scope
• E (Enclosing): Outer scope of nested functions
• G (Global): Module global scope
• B (Built-in): Built-in scope

x = "global"  # Global scope

def outer():
    x = "enclosing"  # Enclosing scope
    
    def inner():
        x = "local"  # Local scope
        print(x)  # Outputs "local", finds local variable first
        
    inner()
    print(x)  # Outputs "enclosing"

outer()
print(x)  # Outputs "global"

3. Reading and Modifying Global Variables

Case 1: Reading Without Modifying
Global variables can be accessed directly:

count = 0

def show_count():
    print(f"Current count: {count}")  # Can read global variable directly

show_count()

Case 2: Modifying Global Variables
Must declare using the global keyword:

count = 0

def increment():
    global count  # Declare use of global variable
    count += 1
    print(f"Count increased to: {count}")

def wrong_increment():
    # This creates a new local variable instead of modifying the global one
    count = 100  # This is a local variable!
    print(f"Local count: {count}")

increment()  # Output: Count increased to: 1
wrong_increment()  # Output: Local count: 100
print(f"Final count: {count}")  # Output: Final count: 1

4. The nonlocal Keyword

Used to modify variables from an outer function in nested functions:

def outer():
    x = 10
    
    def inner():
        nonlocal x  # Declare use of variable from outer function
        x = 20
        print(f"x in inner: {x}")
    
    inner()
    print(f"x in outer: {x}")

outer()

5. Common Pitfalls and Best Practices

Pitfall 1: Accidentally Creating Local Variables

value = 100

def problematic():
    print(value)  # This will raise an error!
    value = 200   # This line makes Python think value is local

# problematic()  # Execution error: UnboundLocalError

Pitfall 2: Modifying Mutable Objects

my_list = [1, 2, 3]  # Mutable object

def modify_list():
    my_list.append(4)  # Can modify directly, no global needed
    # my_list = [5, 6, 7]  # This would require global

modify_list()
print(my_list)  # Output: [1, 2, 3, 4]

Best Practices:

1. Minimize the use of global variables.
2. If global variables need modification, explicitly use the global keyword.
3. For modifying outer function variables in nested functions, use nonlocal.
4. Use meaningful variable names to distinguish variables in different scopes.

6. Practical Application Example

# Counter implementation
def create_counter():
    count = 0
    
    def increment():
        nonlocal count
        count += 1
        return count
    
    def get_count():
        return count
    
    return increment, get_count

inc, get = create_counter()
print(inc())  # 1
print(inc())  # 2
print(get())  # 2

Understanding these rules helps avoid common variable scope errors and write more robust Python code.