Python Variable Scope

Spread the love

Variable scope, a fundamental concept in programming, governs the region of the code where a variable can be accessed and modified. Properly understanding and managing variable scope is essential for preventing bugs and writing maintainable code. In this in-depth article, we’ll explore the intricacies of variable scope in Python.

1. Introduction to Variable Scope

In Python, the scope of a variable determines its visibility throughout the code. Not all variables are accessible from all parts of a program. The scope ensures variables only exist where they’re needed, minimizing unintended interactions.

2. Types of Variable Scopes

Python primarily categorizes variable scope into four types:

  • Local Scope
  • Enclosing (or non-local) Scope
  • Global Scope
  • Built-in Scope

3. Local Scope in Python

In Python, each function defines what is known as a “namespace” or a “scope”, which can be thought of as a container for variables. When we declare a variable inside a function, it’s bound by the boundaries of that function. This means it exists only within the context of that function and can’t be accessed from outside it. Such a variable is said to have “local scope” or is termed as a “local variable.”

Characteristics of Local Scope

  • Lifespan: A local variable’s lifespan is limited to the duration of the function’s execution. Once the function completes its execution, the local variable is destroyed, and its memory is freed.
  • Accessibility: A local variable can only be accessed from inside the function in which it is defined.
  • Isolation: Variables with local scope in different functions, even if they have the same name, are treated as distinct variables. They don’t interfere with each other.

3.1. Example

Let’s consider a simple example to illustrate the concept of local scope:

def greet():
    # Declare a local variable inside the function
    message = "Hello, World!"

# Call the function
greet()  # Output: Hello, World!

# Try to access the local variable from outside the function
print(message)  # This would raise an error.

In this example:

  • The variable message is declared inside the greet() function, making it a local variable.
  • Inside the greet() function, we can access and manipulate the message variable without any issue.
  • However, attempting to access the message variable from outside the function, as shown, would raise a NameError. This is because the variable is not defined in that outer scope.

4. Enclosing (Non-local) Scope in Python


The concept of an enclosing scope comes into play when we have nested functions, i.e., a function defined inside another function. In such a scenario, the inner function can access variables of the outer function, thanks to the enclosing scope. However, these variables aren’t directly accessible from the global (module-level) scope or from other functions outside the enclosing function.

The term “non-local” often goes hand-in-hand with enclosing scope, especially when discussing the modification of enclosing scope variables within nested functions.

Characteristics of Enclosing Scope

  • Accessibility: Variables in the enclosing scope are accessible to inner functions but not outside the outer function.
  • Modification: To modify an enclosing scope variable within an inner function, the nonlocal keyword must be used.
  • Lifetime: The lifetime of an enclosing scope variable is tied to the lifetime of the outer function.

Example: Simple Bank Account Manager

Imagine you want to create a simple bank account manager where you can add or withdraw money. We’ll represent this using an outer function (the account) and a few nested functions (transactions).

def create_account(initial_balance):
    balance = initial_balance  # This is in the enclosing scope for the nested functions

    def deposit(amount):
        nonlocal balance  # We specify that we want to use the 'balance' from the enclosing scope
        balance += amount
        return balance

    def withdraw(amount):
        nonlocal balance  # We specify that we want to use the 'balance' from the enclosing scope
        if amount > balance:
            return "Insufficient funds"
        balance -= amount
        return balance

    # We return our nested functions as a dictionary for easy access
    return {"deposit": deposit, "withdraw": withdraw}

# Let's use our account manager
account = create_account(100)  # Start with an initial balance of 100

print(account["deposit"](50))   # Deposit 50; prints 150
print(account["withdraw"](30))  # Withdraw 30; prints 120
print(account["withdraw"](200)) # Try to withdraw too much; prints "Insufficient funds"

In this example:

  • create_account is our outer function, and it has a variable called balance.
  • deposit and withdraw are inner functions that can access and modify the balance.
  • The nonlocal keyword is crucial. It tells Python that the balance we’re referring to inside our inner functions is the same balance from our outer create_account function. Without nonlocal, any assignment to balance inside the nested functions would create a new local variable named balance, instead of modifying the outer one.

This example showcases the idea of the enclosing (non-local) scope: the deposit and withdraw functions have access to variables (in this case, balance) from their containing function, create_account.

5. Global Scope in Python

Variables in Python have different levels of accessibility, determined by where they’re defined. When a variable is declared outside of any function or class, it’s placed in the global scope of the module. This means it’s accessible from any function or class within that module. However, there are some nuances to understand, especially when trying to modify global variables from within functions.

Characteristics of Global Scope

  • Module-wide Accessibility: Global variables are available throughout the entire module where they’re defined.
  • Lifetime: The lifetime of a global variable spans the entire execution of the program. It’s created when its module is loaded and remains accessible until the program ends.
  • Modification: While you can freely read a global variable from within any function, modifying it requires the explicit use of the global keyword. This requirement is designed to prevent accidental changes to global variables, which can be a common source of bugs.


Let’s explore this with a concrete example:

# This variable is in the global scope
global_message = "I'm a global variable!"

def read_global():
    # We can directly read the global variable
    print(global_message)  # Outputs: I'm a global variable!

def modify_global():
    # This declaration tells Python we're referring to the global variable
    global global_message
    global_message = "I've been changed globally!"

# Calling the functions
read_global()  # Reads and prints the global variable

modify_global()  # Modifies the global variable

read_global()  # Now reads and prints the modified global variable


I'm a global variable!
I've been changed globally!

In this example:

  • global_message is a global variable. Any function in this module can access it.
  • The read_global function directly reads and prints the global_message.
  • The modify_global function first declares global_message as global using the global keyword. This declaration is necessary because the function intends to modify it. Without the global keyword, Python would create a new local variable named global_message within modify_global, leaving the actual global variable unchanged.

6. Built-in Scope

Python has a set of built-in functions and variables. Their scope spans the entire program, and they are available in any part of your code. Examples include print(), len(), and many more.

7. Scope Resolution: The LEGB Rule

When a variable is referenced, Python follows the LEGB rule for scope resolution:

  • L, Local: Check if the variable exists in the local scope.
  • E, Enclosing: In case of nested functions, move out and check the enclosing scope.
  • G, Global: Check the global scope.
  • B, Built-in: Finally, check the built-in scope.

8. Best Practices

  • Minimize Global Variables: Excessive use can make your code hard to debug and maintain.
  • Explicitly Declare Global Variables: When modifying global variables inside a function, always use the global keyword for clarity.
  • Avoid Shadowing: When a local variable has the same name as a global variable or another outer variable, it can lead to confusion.

9. Conclusion

Understanding variable scope in Python is crucial for writing bug-free, maintainable code. By effectively leveraging local, enclosing, global, and built-in scopes, and by adhering to best practices, you can ensure that your Python programs are both efficient and understandable.

Leave a Reply