Namespace and Scope Rules in Python

Description:
A Namespace is a system in Python that stores the mapping relationships between variable names and their corresponding objects. Scope determines the visibility range of names within code. Understanding namespaces and scope is crucial for mastering variable lookup and avoiding naming conflicts.

Detailed Explanation:

1. Types of Namespaces
Python has four types of namespaces, ordered by their lifecycle:

• Built-in Namespace: Contains Python's built-in functions and exceptions (e.g., print(), len). Created when the interpreter starts and never destroyed.
• Global Namespace: Created when a module is loaded, storing module-level variables, functions, and classes.
• Enclosing Namespace: Created within outer functions of nested functions, used for closure scenarios.
• Local Namespace: Created when a function is called, storing variables inside the function. Destroyed when the function returns.

2. Scope Rules (LEGB Rule)
When accessing a name, Python searches in the following order:

• Local: Inside the current function.
• Enclosing: In the outer function's scope (for nested functions).
• Global: In the module's global scope.
• Built-in: In Python's built-in scope.

3. Example Analysis

Example 1: Basic Scope Lookup

x = "global"  # Global scope

def test():
    y = "local"  # Local scope
    print(y)     # Finds local variable y
    print(x)     # Not found locally → finds global variable x
    print(len)   # Not found locally or globally → finds built-in function len

test()

Example 2: Scope in Nested Functions

def outer():
    z = "enclosing"  # Enclosing scope
    
    def inner():
        w = "local"  # Local scope
        print(w)      # Finds local variable w
        print(z)      # Not found locally → finds enclosing variable z
        
    inner()

outer()

4. Name Shadowing and the global/nonlocal Keywords

Problem Scenario:

count = 0  # Global variable

def increment():
    count = count + 1  # Error! Local variable 'count' referenced before assignment

increment()

Solution 1: global Keyword

count = 0

def increment():
    global count      # Declare use of global variable
    count = count + 1  # Now the global variable can be modified

increment()
print(count)  # Output: 1

Solution 2: nonlocal Keyword (for nested functions)

def counter():
    num = 0
    
    def increment():
        nonlocal num  # Declare use of enclosing scope variable
        num += 1
        return num
        
    return increment

c = counter()
print(c())  # Output: 1
print(c())  # Output: 2

5. Methods to Inspect Namespaces

Using built-in functions to inspect namespaces:

# Inspect global namespace
print(globals())

# Inspect local namespace
def example():
    x = 10
    print(locals())  # Output: {'x': 10}

example()

6. Important Notes

• Assignment operations create new variables in the local scope by default.
• Read operations follow the LEGB rule upward.
• global is used to modify global variables, nonlocal to modify enclosing scope variables.
• Module imports create new global namespaces.
• Class definitions create independent namespaces and do not follow the LEGB rule.

Understanding namespaces and scope helps in writing clearer, less error-prone code, especially when managing variable naming and module organization in large projects.