Variable Scope and Namespace

A Name Can Belong to Different Scopes

A variable name does not automatically refer to one universally shared place. Python organizes names through namespaces, and a function has its own local namespace while the program also has an outermost namespace. The important rule for this lesson is that Python localizes a variable by default when a function assigns to that name. This is why a function cannot modify a top-level variable through assignment unless it explicitly uses the global statement.

Trace an Assignment Without global

score = 10 def set_score(): score = 20 set_score()

Reading Versus Writing

Reading a global variable from inside a function works without global. Writing to that global variable requires the global statement. This distinction matters when a function both reads and writes a name: without global, Python treats the assigned name as local, so the function cannot use that same name as an outer-scope value in the intended way. The source identifies this mixed read-and-write situation as causing UnboundLocalError.

limit = 10

def show_limit():
    return limit

The function can read the outermost limit without declaring global.

count = 0

def increase_count():
    global count
    count = count + 1

The global statement makes the function's count name refer to the outermost count binding, so the assignment can modify it.

Declare the Shared Binding

The global statement creates an explicit binding between a local name and a global name. Place the statement inside the function before the assignment that must change the outermost variable. After that declaration, the function has both read and write access to the outer-scope variable.

visits = 0 def record_visit(): global visits visits = visits + 1 record_visit() record_visit()

Observe the State Change

This example shows the defining effect of global: the function is not merely creating a temporary local name. It is changing shared state in the outermost namespace, and later code that uses that outermost name can observe the new value.

Clarity and Safer Data Flow

A global variable can be convenient, but global state reduces code clarity and testability. A function that changes shared state has an effect that is not visible from its parameters or return value. This makes it harder to see where data comes from and where it changes. The recommended default is to pass data through parameters and return values, using global only when necessary.

total = 0

def add_to_total(amount):
    global total
    total = total + amount

def add_to_total(total, amount):
    return total + amount

The first version changes shared state through global. The second version makes the input and result explicit with a parameter and a return value. When the second design fits the task, it is usually easier to understand and test because the function's data flow is visible at the call site.

Mistakes with Global Names

• Expecting assignment inside a function to update the outermost variable automatically.

  Python localizes variables by default on assignment, so the assignment creates or updates a local binding.

  Fix: Use global score before the assignment if modifying the outermost score is genuinely required.

• Reading and writing a global name without declaring it global.

  The source identifies mixing reads and writes without global as causing UnboundLocalError.

  Fix: Declare global count before the assignment, or redesign the function to receive count as a parameter and return the new value.

• Using global for every value shared with a function.

  Global state reduces code clarity and testability.

  Fix: Prefer passing data through parameters and return values when that communicates the data flow clearly.

Practice the Binding Decision

Key Takeaways

1. Python localizes a name by default when a function assigns to it.
2. Reading a global variable works without global, but writing to it requires global.
3. The global statement explicitly binds the function's name to the outermost name, allowing reads and writes.
4. Mixing reads and writes without global causes UnboundLocalError.
5. Global state can reduce clarity and testability, so prefer parameters and return values when they make data flow explicit.