Variable Scope

Introduction

Every variable in Python lives inside a scope — a region of code where that variable is visible and usable. A variable created inside a function is not automatically available outside of it, and understanding exactly why is essential for avoiding some of the most confusing bugs beginners run into.

This lesson covers local and global scope, the global and nonlocal keywords, and the LEGB rule Python uses to figure out which variable a name actually refers to.

Local Scope

A variable created inside a function belongs to that function's local scope. It only exists while the function is running, and it cannot be accessed from outside the function at all.

def calculate_total():
    total = 100  # local variable
    print("Inside function:", total)

calculate_total()
print(total)

Inside function: 100
Traceback (most recent call last):
  ...
NameError: name 'total' is not defined

total only exists inside calculate_total. Once the function finishes running, that variable is gone — trying to print it outside the function raises a NameError.

Global Scope

A variable created at the top level of a script — outside any function — belongs to the global scope. It can be read from anywhere in the file, including from inside functions.

app_name = "PrograMinds"  # global variable

def show_app_name():
    print("Running:", app_name)

show_app_name()
print("Still accessible:", app_name)

Running: PrograMinds
Still accessible: PrograMinds

Functions can freely read global variables. The tricky part, as you will see next, is reassigning a global variable from inside a function.

The global Keyword

By default, assigning to a variable name inside a function creates a new local variable, even if a global variable with the same name already exists. The global keyword tells Python that a name inside the function refers to the global variable, so assignment actually updates it.

counter = 0

def increment():
    counter = counter + 1  # tries to use counter before assigning locally
    print(counter)

increment()

Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'counter' referenced before assignment

Because increment() assigns to counter, Python treats counter as local to that function for its entire body — so reading counter before that assignment fails.

counter = 0

def increment():
    global counter
    counter = counter + 1
    print("Inside function:", counter)

increment()
increment()
print("Outside function:", counter)

Inside function: 1
Inside function: 2
Outside function: 2

The global counter line tells Python explicitly: "counter refers to the global variable, not a new local one." Now each call updates the same shared variable.

Enclosing Scope & nonlocal

When you define a function inside another function, the inner function can read variables from the outer function's scope — this is called the enclosing scope. Just like with global variables, assigning to that name inside the inner function creates a new local variable instead, unless you use nonlocal.

def outer():
    message = "Hello"

    def inner():
        print("Inner sees:", message)  # reading works fine

    inner()

outer()

Inner sees: Hello

def make_counter():
    count = 0

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

    return increment

counter = make_counter()
print(counter())
print(counter())
print(counter())

1
2
3

nonlocal tells Python that count inside increment refers to the count variable in the enclosing make_counter function, not a brand-new local variable. Each call to counter() updates and remembers that same enclosing count.

The LEGB Rule

Whenever Python looks up a name, it searches through scopes in a specific order known as LEGB: Local, then Enclosing, then Global, then Built-in. It stops and uses the first match it finds.

value = "global value"

def outer():
    value = "enclosing value"

    def inner():
        value = "local value"
        print(value)  # Local wins

    inner()
    print(value)  # Enclosing wins here

outer()
print(value)  # Global wins here
print(len)  # Built-in name, found in the Built-in scope

local value
enclosing value
global value
<built-in function len>

Each print() call resolves value using the closest scope available at that point: inner() finds its own local value first, outer() falls back to its own enclosing value, and the final print at module level finds the global value.

The Danger of Shadowing

Shadowing happens when a local variable uses the same name as a global (or enclosing) variable, hiding it inside that scope. This can cause confusing bugs where code appears to "lose track" of a value.

total = 1000  # global "total"

def apply_discount(price):
    total = price * 0.9  # this creates a NEW local "total", shadowing the global one
    return total

discounted = apply_discount(500)
print("Discounted price:", discounted)
print("Global total is unchanged:", total)

Discounted price: 450.0
Global total is unchanged: 1000

Inside apply_discount, total is a brand-new local variable — it never touches the global total. This is usually fine here, but if the programmer expected the function to update the global total, this shadowing would be a real bug.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Variable scope determines where a name can be seen and used in your code. Local variables live and die inside their function, global variables are visible throughout a file, and the global and nonlocal keywords let you deliberately reach outside the current scope to modify a variable.

The LEGB rule ties all of this together, explaining exactly how Python decides which variable a name refers to. Next, you will learn about lambda functions — a compact way to write small, throwaway functions.