Scope, Global, and Local Variables

The Local Scope Lifecycle

When you define a variable inside a function, Python assigns it a 'local scope'. This means the name exists only within that function's execution frame. When the function begins, the local namespace is initialized; when the function returns or finishes, that namespace is destroyed, and the local variables are cleaned up from memory. This behavior is crucial because it allows you to use common variable names like 'count' or 'result' in multiple functions without them overwriting each other. The interpreter resolves local names first when it encounters a variable inside a function. If it finds the name there, it stops looking, effectively hiding any variables with the same name that might exist at higher levels of the program. This isolation ensures that your functions act like black boxes, receiving input and providing output without being inadvertently influenced by external data structures that might change during runtime.

# Variables created inside functions only exist while the function is running.
def calculate_area(radius):
    pi = 3.14159  # 'pi' is local to this function
    area = pi * (radius ** 2)
    return area

print(calculate_area(5))
# print(pi)  # This would raise a NameError because 'pi' is gone.

Accessing Global Scope

Variables defined at the top level of a script reside in the global scope. Because global variables are defined at the outermost layer, they are accessible from anywhere in your code, including inside functions. When you reference a variable name inside a function, the interpreter follows a specific lookup rule: it checks the local scope first, and if the name isn't found, it bubbles up to the global scope. This design pattern is useful for constants or configuration settings that need to be read by various parts of an application, such as an API base URL or a timeout value. However, while you can read global variables easily, you must be careful. Treating functions as if they can freely read global state is generally acceptable, but relying on them too heavily can make your code difficult to debug because the function's output depends on external data that might be modified elsewhere in the program unexpectedly.

# Global variables can be read inside functions.
BASE_URL = "https://api.example.com"

def get_endpoint(path):
    # The function looks for BASE_URL in local, doesn't find it, then looks globally
    return BASE_URL + path

print(get_endpoint("/users"))

Modifying Global Variables

A common point of confusion occurs when attempting to modify a global variable from inside a function. By default, if you assign a value to a name inside a function, Python creates a new local variable, leaving the global variable untouched. To explicitly signal to the interpreter that you intend to modify the global variable rather than create a local one, you must use the 'global' keyword. Using this keyword tells Python to bind the variable name to the global scope for the duration of that function. While this provides a way to persist state across multiple function calls, it should be used sparingly. Excessive use of global state makes unit testing difficult and increases the risk of 'spooky action at a distance,' where a variable changes in one function and breaks logic in a completely unrelated part of your application. Prefer passing data as arguments and returning new values whenever possible.

total_requests = 0

def increment_counter():
    global total_requests  # Required to modify the global variable
    total_requests += 1

increment_counter()
print(total_requests)  # Output is 1

The LEGB Lookup Rule

Python resolves variable names using the LEGB rule: Local, Enclosing, Global, and Built-in. The search starts at the local level. If not found, it moves to the Enclosing scope (which applies to nested functions, known as closures). If still not found, it checks the Global scope. Finally, if the name remains unresolved, it checks the Built-in scope, which contains names like 'print' or 'len'. Understanding this hierarchy explains why you can use built-in functions inside your code without defining them yourself, and why local variables shadow global variables. It is a systematic, hierarchical approach that ensures the interpreter always knows which specific object a name refers to. When debugging, if your code is not using the value you expect, checking where the variable is being defined in the LEGB chain is usually the first step to identifying the shadowing conflict or scope error preventing the correct execution of your logic.

import builtins

def check_scope():
    # Local scope
    x = "local"
    def inner():
        # Enclosing scope
        return x
    return inner()

print(check_scope()) # Prints 'local'

Avoiding Scope Pollution

To write clean and maintainable software, one must avoid 'scope pollution,' which occurs when too many variables are defined at the global level. When variables are global, they stay in memory for the life of the program and can be modified by any function, leading to unpredictable bugs. Instead, keep variables as localized as possible. Pass necessary data into functions as parameters and return the results as output. If you need to maintain state, encapsulate that state within a class instance where variables belong to 'self' rather than the global namespace. This strategy makes functions modular, predictable, and easier to test because you can pass different inputs and expect consistent outputs without worrying about global state interference. By limiting the visibility of your variables, you essentially reduce the 'surface area' of potential errors, leading to codebases that are significantly easier to refactor, maintain, and understand over time.

# Better: pass variables as arguments instead of relying on global state
def calculate_discount(price, rate):
    # Both arguments are local to this function
    return price * (1 - rate)

final_price = calculate_discount(100.0, 0.2)
print(final_price)

Interview questions

All Python interview questions →

Check yourself

Take the full Python quiz →