Avoiding Global State in Functions

The Assignment Trap

A function can read a variable defined at the program's outermost level without a special declaration. Assignment is different. Python localizes a variable by default when a function assigns to that name, so the assignment does not modify the top-level variable unless the function uses the global statement.

Separate Bindings from One Name

Think of the top-level variable and the function's assigned variable as separate bindings. They may use the same name, but an assignment inside the function is localized by default. The function's assignment therefore does not change the value held by the top-level binding.

score = 5

def set_score():
    score = 10

set_score()

In this example, the function assigns to a localized score. The top-level score remains separate because the function did not declare score as global.

Reading Versus Writing

score = 5

def show_score():
    return score

def increase_score():
    global score
    score = score + 1

show_score reads the top-level score without global. increase_score writes to score, so it declares score as global before assigning to it. The declaration creates an explicit binding between the function's name and the outer-scope variable, allowing both read and write access.

Making a Global Update

visits = 0

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

record_visit()
record_visit()

visits is now 2

This is a practical use of global: the function intentionally changes a variable defined at the outermost level. The shared value persists between calls, which is why the second call can update the result of the first call.

Clarity Costs of Shared State

Although global can make an update possible, global state can make a program harder to understand. A function that reads or changes shared outer-scope data has data flow that is less visible at the function call. The caller may need to know which global variables the function reads or changes, even though those variables are not listed as parameters or return values.

visits = 0

def record_visit_with_global():
    global visits
    visits = visits + 1

def record_visit(visits):
    return visits + 1

The first function changes shared global state. The second function receives a value and returns an updated value instead. The second style makes the data entering and leaving the function explicit, which supports clearer code when shared state is not necessary.

Mistakes to Avoid

• Assuming that assignment inside a function automatically changes the top-level variable

  Python localizes variables by default on assignment inside a function.

  Fix: Use global score before the assignment if the function must modify the top-level score.

• Using global when the function only needs to read a top-level variable

  Reading a global variable works without global.

  Fix: Omit global when the function only reads the value.

• Reading and assigning to the same global name without declaring it

  Mixing reads and writes without global can cause UnboundLocalError.

  Fix: Declare the name as global before the read-and-write operation, or redesign the function to use a parameter and return value.

• Using global by default for ordinary data flow

  Global state reduces code clarity and testability.

  Fix: Prefer passing data through parameters and return values when that expresses the operation clearly.

Practice the Decision

• Situation 1 does not require global because the function only reads the top-level value.
• Situation 2 requires global if the function directly modifies the top-level counter.
• Situation 3 does not require global; parameters and a return value make the data flow explicit.

Working Rule

1. Assignment inside a function is localized by default, so it does not modify a top-level variable with the same name. Reading a top-level variable does not require global, but writing to it does. The global statement explicitly connects the function's name to the outer-scope variable and permits read and write access. Use global only when shared state is genuinely needed; otherwise, prefer parameters and return values because they make data flow clearer and support better testability.