Python namespace

Python namespace is a mapping from names to objects. Every scope has its own namespace (global, local, built-in), and Python searches them in order using LEGB (Local, Enclosing, Global, Built-in) to find what a name refers to. Understanding scopes prevents variable shadowing bugs and clarifies how closure variables work.

Use locals() and globals() to inspect namespaces, and understand scope rules to debug mysterious variable references.

This example demonstrates namespace scope and variable shadowing.

# run: python3 namespace.py
# description: namespace scope and LEGB resolution
 
x = "global"
 
def outer():
    x = "enclosing"
 
    def inner():
        x = "local"
        print(f"Inner: {x}")
        print(f"Inner locals: {list(locals().keys())}")
 
    inner()
    print(f"Outer: {x}")
 
outer()
print(f"Global: {x}")
 
# Closure and nonlocal
def counter():
    count = 0  # enclosing scope
 
    def increment():
        nonlocal count  # access enclosing scope
        count += 1
        return count
 
    def get():
        return count
 
    return increment, get
 
inc, get = counter()
print(f"\nCounter: {inc()}, {inc()}, {inc()}")
print(f"Current: {get()}")
 
# globals() and locals()
print(f"\nGlobal 'x': {globals()['x']}")
 
def show_scopes():
    y = "local var"
    print(f"Local namespace keys: {list(locals().keys())}")
    print(f"y in locals: {'y' in locals()}")
    print(f"x in globals: {'x' in globals()}")
 
show_scopes()

LEGB lookup order:

• L: Local (function scope)
• E: Enclosing (outer function scope for nested functions)
• G: Global (module scope)
• B: Built-in (built-in functions like len, print)
• Python searches in this order; first match wins

Scope keywords:

• global var: access/modify global scope from function
• nonlocal var: access/modify enclosing scope from inner function
• Without these, assignment creates a new local variable

Closures:

• Inner function captures enclosing scope variables
• Variables must exist at function definition time
• Useful for factories, decorators, callbacks

Inspecting namespaces:

• locals(): dict of local namespace
• globals(): dict of global namespace
• vars(obj): object's attribute namespace (equivalent to obj.__dict__)
• dir(obj): list of accessible attributes

Common mistakes:

• Forgetting nonlocal and thinking you're modifying enclosing variable (creates local instead)
• Variable shadowing: local x hides global x invisibly
• Late binding in closures: inner function captures variable name, not value
• Mutable defaults: def f(x=[]): modifies same list on each call

Late binding example (common gotcha):

funcs = []
for i in range(3):
    def f():
        return i  # captures 'i' by reference, not value
    funcs.append(f)
 
print([f() for f in funcs])  # [2, 2, 2] not [0, 1, 2]!
# Fix: capture value with default arg: def f(i=i):