How to Safely Use Global Variables in Python Best Practices Examples

 

 What Are Global Variables in Python?

Global variables are variables declared outside any function, making them accessible throughout the module.

 Example:

counter = 0  # global variable

def increment():
    global counter
    counter += 1

 Risks of Using Global Variables

•  Can lead to hard-to-track bugs
•  Not thread-safe
•  Reduces modularity and testability

 Best Practices for Using Global Variables Safely

1.  Use global Keyword Only When Necessary

Use global only when you need to modify a global variable inside a function.

status = "inactive"

def activate():
    global status
    status = "active"

2.  Wrap Globals in a Class or Config Object

Encapsulate global state in a dedicated class or namespace:

class AppState:
    counter = 0
    status = "idle"

def update():
    AppState.counter += 1

 Benefits:

• Cleaner namespace
• Grouped logically
• Easier to manage state

3.  Use a Singleton Object or Dictionary

app_state = {
    "counter": 0,
    "mode": "init"
}

def set_mode(new_mode):
    app_state["mode"] = new_mode

 Simple and dynamic alternative

4.  Use Module-Level Variables (Pythonic Way)

You can define global variables in one module (config.py), then import and use them elsewhere.

# config.py
DEBUG = True

# main.py
import config
if config.DEBUG:
    print("Debugging is ON")

 Easy to maintain, test, and mock in unit tests

5.  Thread Safety: Use Locks for Concurrent Access

When working with threads, wrap global updates with threading.Lock:

import threading

counter = 0
lock = threading.Lock()

def safe_increment():
    global counter
    with lock:
        counter += 1

 Summary Table

Approach	Safe?	Recommended Use
Direct global variables	⚠️	Only for simple scripts
global keyword inside fn	⚠️	Minimal use only
Encapsulation in class	✅	For grouped shared state
Dictionary (dict) wrapper	✅	Flexible, easy-to-debug state
Module import (config.py)	✅✅	Most Pythonic and testable
With threads: use Lock	✅✅	Required for safe concurrency

Tip: Avoid Overusing Globals

Where possible, prefer returning values from functions, using function arguments, or leveraging object-oriented design to maintain clarity and scalability.