Code Mastery Centre
11 Aug, 2025

Python Variables: Local, Global, and global Keyword Tutorial

Understanding Python local and global variables is crucial for managing variable scope in your programs. Variable scope determines where variables can be accessed and modified, with local variables confined to functions and global variables accessible throughout the code. The Python global keyword allows functions to modify global variables. This comprehensive guide explores Python local global variables, the global keyword, scope rules, practical examples, and best practices to help you write effective Python code.

What Are Python Local and Global Variables?

Local Variables: Defined inside a function, these variables are only accessible within that function and are destroyed when the function exits.

Global Variables: Defined outside functions or at the module level, these variables are accessible (but not modifiable without global) throughout the code, unless shadowed by a local variable.

Example of Python Local and Global Variables:

# Global variable
x = 10

def my_function():
    # Local variable
    y = 5
    print(f"Inside function: x = {x}, y = {y}")

my_function()  # Output: Inside function: x = 10, y = 5
print(f"Outside function: x = {x}")  # Output: Outside function: x = 10
# print(y)  # Error: NameError: name 'y' is not defined

Here, x is a global variable accessible everywhere, while y is a local variable limited to my_function. Learn more about Python variables for a deeper understanding.

Python Variable Scope: The LEGB Rule

Python uses the LEGB rule to resolve variable names: Local, Enclosing, Global, and Built-in. When a variable is referenced, Python checks these scopes in order.

  • Local: Variables inside the current function.
  • Enclosing: Variables in outer functions (for nested functions).
  • Global: Variables at the module level.
  • Built-in: Python’s built-in names (e.g., print, len).

Example of Python Variable Scope:

x = 100  # Global variable

def outer():
    x = 50  # Enclosing variable
    def inner():
        x = 10  # Local variable
        print(f"Inner: x = {x}")
    inner()
    print(f"Outer: x = {x}")

outer()  # Output: Inner: x = 10
         # Output: Outer: x = 50
print(f"Global: x = {x}")  # Output: Global: x = 100

Each scope maintains its own x, with Python prioritizing the innermost scope. Explore Python functions for more on nested functions.

Using the Python Global Keyword

By default, assigning to a variable inside a function creates a local variable, even if a global variable with the same name exists. The Python global keyword allows a function to modify a global variable instead.

Example Without Global Keyword:

x = 20

def modify():
    x = 30  # Creates a local variable
    print(f"Inside function: x = {x}")

modify()  # Output: Inside function: x = 30
print(f"Outside function: x = {x}")  # Output: Outside function: x = 20

Example With Global Keyword:

x = 20

def modify():
    global x  # Declare x as global
    x = 30    # Modifies the global variable
    print(f"Inside function: x = {x}")

modify()  # Output: Inside function: x = 30
print(f"Outside function: x = {x}")  # Output: Outside function: x = 30

The global keyword ensures the function modifies the global x.

Common Pitfalls in Python Variable Scope

Shadowing Variables: A local variable with the same name as a global variable hides the global one unless global is used.

x = 50

def shadow():
    x = 10  # Local variable shadows global x
    print(f"Inside: x = {x}")

shadow()  # Output: Inside: x = 10
print(f"Outside: x = {x}")  # Output: Outside: x = 50

UnboundLocalError: Accessing and assigning to a variable in the same function without global causes an error, as Python assumes it’s local.

x = 100

def error():
    print(x)  # Error: UnboundLocalError
    x = 200   # Python assumes x is local due to assignment

# error()  # Raises UnboundLocalError: local variable 'x' referenced before assignment

Fix with Global Keyword:

x = 100

def fixed():
    global x
    print(x)  # Now works
    x = 200

fixed()  # Output: 100
print(x) # Output: 200

Best Practices for Python Local and Global Variables

Follow these best practices to manage Python local global variables effectively:

  • Minimize Global Variables: Limit global variables to avoid debugging and maintenance issues.
  • Use Global Keyword Sparingly: Prefer passing variables as function arguments over using global.
  • Use Descriptive Names: Choose clear names to distinguish local and global variables (e.g., global_counter vs. counter).
  • Avoid Shadowing: Ensure local variable names don’t conflict with globals to prevent confusion.
  • Encapsulate Logic: Use functions with local variables for modularity and reduced reliance on global scope.

Example Following Best Practices:

def update_score(current_score, points):
    new_score = current_score + points  # Local variable
    return new_score

score = 100  # Global variable
score = update_score(score, 50)
print(f"Updated score: {score}")  # Output: Updated score: 150

Practical Use Case: Tracking a Counter

Here’s an example using Python local and global variables with the global keyword to manage a click counter:

# Global counter
click_count = 0

def increment_click():
    global click_count
    click_count += 1
    print(f"Click {click_count}: Local count = {click_count}")

def reset_click():
    global click_count
    click_count = 0
    print(f"Reset: Count = {click_count}")

increment_click()  # Output: Click 1: Local count = 1
increment_click()  # Output: Click 2: Local count = 2
reset_click()      # Output: Reset: Count = 0

Frequently Asked Questions About Python Local and Global Variables

What’s the difference between local and global variables in Python?

Local variables are defined inside a function and are only accessible there, while global variables are defined at the module level and can be accessed throughout the code.

When should I use the global keyword?

Use the Python global keyword when a function needs to modify a global variable, but prefer passing arguments for better modularity.

Why do I get an UnboundLocalError?

An UnboundLocalError occurs when a function tries to access a variable it also assigns to, assuming it’s local. Use the global keyword to fix this.

How can I avoid shadowing variables?

Use distinct, descriptive names for local and global variables to prevent a local variable from hiding a global one.

Conclusion

Mastering Python local and global variables, along with the global keyword, is essential for effective variable scope management. Local variables promote modularity, while global variables enable shared state across a program. The Python global keyword allows controlled modifications but should be used sparingly. Practice with the provided examples and follow best practices to write clean, maintainable Python code. Explore related topics like Python functions or Python modules to deepen your skills!

Next Post Previous Post