Using global variables in a function

python

global-variables

scope-management

variable-binding

byNikita Barsukov·Mar 9, 2025

# Define a global variable
global_var = 10

def modify_global():
    global global_var  # "global" keyword is mightier than local scope!
    global_var = 20

# Usage
modify_global()
print(global_var)  # Surprise! It's 20 now.

The global keyword makes a global variable accessible in your function scope, enabling you to modify its value. The change will be reflected globally in your code.

Dive into Python global variables

Global variables are Python's own public property. Accessing them inside a function can be tricky if you're not familiar with their behavior. While you can read their value freely, modifications without the global keyword create a new local variable. Heed these examples for clarity:

Reading globals without the keyword

# Global variable
config_option = 'default'

def print_option():
    print(config_option)  # Access granted without "global" keyword!

print_option()  # Prints: default

Escaping the UnboundLocalError trap

# Global variable
counter = 0

def increment():
    global counter  # I solemnly swear that I am up to global modification.
    counter += 1

try:
    increment()
except UnboundLocalError as e:
    print(f"Error: {e}")

Locals vs globals: Dawn of Variable Name Confusion

# Global variable
score = 0

def update_score():
    score = 3  # This creates a local "score", but our global one is safe!
    global score  # This line is a party crasher. It causes SyntaxError due to local assignment above.  
    score = 3  # This could've changed the global "score", the universe had other plans.

update_score()

Global variables are perfect for sharing data across multiple functions or even multiple python files or modules. Sit back and watch how to handle such global goodness:

Share a global variable across functions by declaring it as global in each function, and remember, sharing is caring!
When you need to share your globals across modules, define the variable in one module, and import it into other modules. Being globally renowned was never this easy!

Maintaining a consistent global state

Use a config.py script to hold all your settings:

# In config.py
some_setting = 'Initial'

Other modules can then import and mutate it:

# In app.py
from config import some_setting
some_setting = 'Updated'  # Keep things consistent, like your coffee orders.

Making peace with global variables and their alternatives

Using global variables is like spicy food — amazing in moderation but can cause chaos when overused. Let's navigate these spicy waters:

Leaning towards structured programming

Chaining classes and objects(Object-oriented programming) can keep global variables use in check, allowing the panda of encapsulation to roam freely in your code.

Global variable discipline

If you decide to use global variables, make your declare your intentions at the top of your module and consistently use the global keyword in functions where they are modified. This clarity can help avoid the whirlpool of confusion between scopes.

The universe of Namespaces

Understanding namespaces and the LEGB(Local, Enclosed, Global, Built-in) rule is like understanding the force. It's crucial for effective scope and variable binding management.

Shadowing: A variable's nightmare

Choosing unique names for local and global variables can be a lifesaver. It avoids shadowing, where a local variable overshadows a global one, triggering a whodunit in your code!

Global state with Singleton pattern

If managing a global state is your aim, consider using the Singleton design pattern. This limits the instance of a class to a single one, avoiding numerous global variables running wild.

Scope survival post function execution

Unlike the Avengers, global variables survive beyond the function execution, unlike locals!

Beam me up, Python!

Beam into Python's inner workings using the dis module. It helps you understand how Python accesses and assigns variables using the LOAD_GLOBAL and LOAD_FAST commands.

import dis
def use_globals():
    global some_global  # You are now captain of USS GlobalVariable
    some_global = 10
dis.dis(use_globals)   # Welcome to the Python internals!