Variable Scope

Intermediate ~25 min read

Understanding scope is essential for writing bug-free Python code. Scope determines where variables can be accessed and modified. Python follows the LEGB rule - Local, Enclosing, Global, Built-in - to look up variable names. Master scope and you'll avoid one of the most common sources of confusion in programming!

Local Scope

Variables created inside a function are local to that function. They're created when the function is called and destroyed when it returns. Local variables cannot be accessed from outside the function, and each function call gets fresh local variables.

# Local Scope in Python

# 1. Variables inside functions are local
print("=== Local Variables ===")
def greet():
    message = "Hello!"  # Local to this function
    print(message)

greet()
# print(message)  # NameError: message is not defined
print()

# 2. Parameters are local too
print("=== Parameters Are Local ===")
def add(a, b):
    result = a + b  # result is local
    return result

print(add(3, 5))
# print(a)  # NameError: a is not defined
# print(result)  # NameError: result is not defined
print()

# 3. Local variables shadow global ones
print("=== Local Shadows Global ===")
x = 100  # Global

def show_x():
    x = 50  # Local - shadows the global x
    print(f"Inside function: x = {x}")

show_x()
print(f"Outside function: x = {x}")  # Global unchanged
print()

# 4. Each function call creates new locals
print("=== Fresh Locals Each Call ===")
def counter():
    count = 0  # Fresh local each time
    count += 1
    return count

print(f"First call: {counter()}")
print(f"Second call: {counter()}")
print(f"Third call: {counter()}")
print()

# 5. Local variables exist only during function execution
print("=== Lifetime of Locals ===")
def temp_data():
    data = [1, 2, 3, 4, 5]  # Created
    total = sum(data)
    return total
    # data and total are destroyed after return

result = temp_data()
print(f"Result: {result}")
# data is gone - can't access it here

Output

Click Run to execute your code

Why Local Scope Exists: Local scope protects you from accidentally modifying variables elsewhere in your program. When a function has its own private variables, you can understand and test it in isolation. This is a key principle of good software design called encapsulation.

Global Scope and the global Keyword

Variables defined at the module level (outside any function) are global. Functions can read global variables freely, but to modify them, you must use the global keyword. However, overusing global variables is generally considered bad practice.

# Global Scope and the global Keyword

# 1. Global variables
print("=== Global Variables ===")
APP_NAME = "MyApp"  # Global - accessible everywhere
version = "1.0"

def show_app_info():
    # Can READ global variables without special syntax
    print(f"App: {APP_NAME} v{version}")

show_app_info()
print()

# 2. Can't modify globals without 'global' keyword
print("=== The Problem ===")
counter = 0

def increment_wrong():
    # This creates a NEW local variable, doesn't modify global!
    counter = counter + 1  # UnboundLocalError!

# increment_wrong()  # Would raise UnboundLocalError
print()

# 3. Using the global keyword
print("=== Using 'global' ===")
counter = 0

def increment_right():
    global counter  # Now we're modifying the global
    counter += 1

print(f"Before: {counter}")
increment_right()
increment_right()
increment_right()
print(f"After: {counter}")
print()

# 4. Creating globals from functions
print("=== Creating Globals ===")
def create_global():
    global new_var
    new_var = "I was created inside a function!"

create_global()
print(new_var)  # Works - it's now a global
print()

# 5. Why global is often discouraged
print("=== Better Alternatives ===")
# Instead of global state:
def get_incremented(current):
    """Return incremented value - no global state."""
    return current + 1

value = 0
value = get_incremented(value)
value = get_incremented(value)
print(f"Value: {value}")

# Or use a class to encapsulate state
class Counter:
    def __init__(self):
        self.count = 0

def increment(self):
        self.count += 1
        return self.count

c = Counter()
print(f"Counter: {c.increment()}, {c.increment()}, {c.increment()}")

Output

Click Run to execute your code

Avoid Global Variables: Global state makes code harder to understand, test, and debug. Functions that modify globals have "hidden" dependencies. Instead, pass values as arguments and return results. Use globals only for true constants (like PI = 3.14159) or configuration that genuinely needs to be module-wide.

The LEGB Rule

When Python encounters a variable name, it searches for it in a specific order: Local, Enclosing, Global, Built-in. This is the LEGB rule. Understanding it helps you predict which variable Python will find when names overlap.

# The LEGB Rule - Python's Scope Resolution

# LEGB = Local, Enclosing, Global, Built-in

# 1. The LEGB lookup order
print("=== LEGB Lookup Order ===")
x = "global"  # Global

def outer():
    x = "enclosing"  # Enclosing (for inner function)

def inner():
        x = "local"  # Local
        print(f"Inside inner: {x}")  # Finds local

inner()
    print(f"Inside outer: {x}")  # Finds enclosing

outer()
print(f"Outside: {x}")  # Finds global
print()

# 2. Without local, uses enclosing
print("=== Enclosing Scope ===")
def outer2():
    message = "from outer"

def inner2():
        # No local 'message', so uses enclosing
        print(f"Inner sees: {message}")

inner2()

outer2()
print()

# 3. Built-in scope
print("=== Built-in Scope ===")
# Built-ins are always available
print(f"len([1,2,3]) = {len([1, 2, 3])}")
print(f"max(5, 10) = {max(5, 10)}")
print(f"type('hello') = {type('hello')}")

# But can be shadowed (usually by accident!)
# Don't do this:
# list = [1, 2, 3]  # Shadows built-in list()
# print(list([1, 2]))  # TypeError!
print()

# 4. Demonstrating full LEGB
print("=== Full LEGB Demo ===")
name = "Global Name"  # G

def outer_func():
    name = "Enclosing Name"  # E

def inner_func():
        name = "Local Name"  # L
        # Also available: len, print, etc. (B)
        print(f"Inner: {name}")
        print(f"Built-in len: {len(name)}")

inner_func()
    print(f"Outer: {name}")

outer_func()
print(f"Module: {name}")

Output

Click Run to execute your code

LEGB Memory Aid: Local (inside current function) → Enclosing (outer function if nested) → Global (module level) → Built-in (Python's built-in names like len, print). Python stops at the first match it finds.

The nonlocal Keyword

When you have nested functions and need to modify a variable from an enclosing (but not global) scope, use nonlocal. This is especially useful for creating closures - functions that "remember" state from their enclosing scope.

# The nonlocal Keyword - Modifying Enclosing Scope

# 1. The problem: can't modify enclosing by default
print("=== The Problem ===")
def make_counter_wrong():
    count = 0

def increment():
        count += 1  # UnboundLocalError!
        return count

return increment

# counter = make_counter_wrong()
# counter()  # Would fail
print()

# 2. Solution: nonlocal keyword
print("=== Using nonlocal ===")
def make_counter():
    count = 0

def increment():
        nonlocal count  # Modify the enclosing variable
        count += 1
        return count

return increment

counter = make_counter()
print(f"First: {counter()}")
print(f"Second: {counter()}")
print(f"Third: {counter()}")
print()

# 3. nonlocal vs global
print("=== nonlocal vs global ===")
level = "module"

def outer():
    level = "outer"

def inner_nonlocal():
        nonlocal level  # Modifies outer's level
        level = "inner changed outer"

def inner_global():
        global level  # Modifies module's level
        level = "inner changed global"

print(f"Before nonlocal: outer={level}")
    inner_nonlocal()
    print(f"After nonlocal: outer={level}")

outer()
print(f"Module level: {level}")
print()

# 4. Practical use: closures with state
print("=== Closure with State ===")
def make_multiplier(factor):
    """Create a function that multiplies by factor."""
    def multiply(n):
        return n * factor  # Reads from enclosing (no nonlocal needed for read)
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)

print(f"double(5) = {double(5)}")
print(f"triple(5) = {triple(5)}")
print()

# 5. State in closures (needs nonlocal for modification)
print("=== Stateful Closure ===")
def make_accumulator():
    """Create a function that accumulates values."""
    total = 0

def add(value):
        nonlocal total
        total += value
        return total

return add

acc = make_accumulator()
print(f"Add 10: {acc(10)}")
print(f"Add 5: {acc(5)}")
print(f"Add 3: {acc(3)}")

Output

Click Run to execute your code

Common Mistakes

1. UnboundLocalError when modifying globals

count = 0

def increment():
    count += 1  # UnboundLocalError!
    # Python sees assignment, creates local 'count'
    # But tries to read count before it's assigned

# Fix: use global keyword
def increment():
    global count
    count += 1

2. Shadowing built-in names

# Bad - shadows built-in list()
list = [1, 2, 3]
# Later...
new_list = list("hello")  # TypeError: 'list' object is not callable

# Fix: use different variable names
items = [1, 2, 3]
new_list = list("hello")  # Works: ['h', 'e', 'l', 'l', 'o']

3. Thinking assignment creates reference to global

data = [1, 2, 3]

def modify():
    data = [4, 5, 6]  # Creates LOCAL data!
    # Global data is unchanged

modify()
print(data)  # [1, 2, 3] - surprised?

# If you want to modify the global:
def modify():
    global data
    data = [4, 5, 6]

4. Using global when nonlocal is needed

def outer():
    x = 10

    def inner():
        global x  # Wrong! Looks for module-level x
        x += 1

    inner()
    print(x)  # Still 10 - inner modified a different x

# Fix: use nonlocal for enclosing scope
def outer():
    x = 10

    def inner():
        nonlocal x  # Correct!
        x += 1

    inner()
    print(x)  # 11

5. Mutable globals can be modified without 'global'

# Surprising: this works without 'global'
items = []

def add_item(item):
    items.append(item)  # Modifying, not reassigning!

add_item("apple")
print(items)  # ['apple']

# But this needs 'global':
def reset_items():
    global items
    items = []  # Reassignment needs global

Exercise: Counter Factory

Task: Create a function that returns a counter function using closures.

Requirements:

Create make_counter(start=0)
Returns a function that increments and returns the count
Use nonlocal to maintain state

Output

Click Run to execute your code

Show Solution

def make_counter(start=0):
    """Create a counter function starting at 'start'."""
    count = start

    def counter():
        nonlocal count
        count += 1
        return count

    return counter

# Test it
counter1 = make_counter()
counter2 = make_counter(100)

print(f"Counter 1: {counter1()}, {counter1()}, {counter1()}")
print(f"Counter 2: {counter2()}, {counter2()}")

Summary

Local: Variables inside functions - created on call, destroyed on return
Global: Variables at module level - use global keyword to modify
LEGB: Lookup order: Local → Enclosing → Global → Built-in
nonlocal: Modify enclosing (not global) scope in nested functions
Shadowing: Local variables can shadow global/built-in names
Best practice: Avoid global state; prefer passing values and returning results
Closures: Functions that capture and remember enclosing scope

What's Next?

Now that you understand scope, let's learn about Lambda Functions - small, anonymous functions perfect for short operations. Lambdas are widely used with functions like map(), filter(), and sorted()!

Previous Return Values

Next Lambda Functions

Local Scope

Global Scope and the global Keyword

The LEGB Rule

The nonlocal Keyword

Common Mistakes

1. UnboundLocalError when modifying globals

2. Shadowing built-in names

3. Thinking assignment creates reference to global

4. Using global when nonlocal is needed

5. Mutable globals can be modified without 'global'

Exercise: Counter Factory

Summary

What's Next?

Enjoying these tutorials?