Global Variables in Python: How to declare them while following best practices

Global variables can be a double-edged sword in programming.

While they can provide a convenient way to store data that needs to be accessed across functions, their misuse can lead to confusing bugs and unexpected behavior.

A couple of times, I have accidentally modified a global variable when I intend to modify a local variable. This happens when I forget to declare a local variable with the same name as a global variable, or when I inadvertently use the same variable name for both a global and a local variable.

Later I realize some unexpected behavior and difficult-to-debug issues arise, mainly if the global variable is used in multiple places throughout the codebase.

This is one of the many experiences I have ever had with global variables, especially when I started to learn how to program in Python.

If you are new to Python programming, it is possible to create a global variable that can be accessed anywhere in your Python code.

Let’s look at what a global variable is and how you can create one in your Python program and see if it is a fit choice to opt for when declaring values that are used anywhere in your code.

What is a global variable in Python?

A global variable in Python is a variable that can be accessed from anywhere in a program, whether inside or outside of your Python functions.

It is defined outside of any function and is not limited in scope to any specific function.

In Python, global variables are declared using the “global” keyword inside a function. This tells Python that the variable being defined should be a global variable, rather than a local variable that is only accessible within the function.

For example, let’s say we have a program that needs to keep track of the number of times a function has been called:

count = 0

def my_function():
    global count
    count += 1
    print("This function has been called", count, "times.")

my_function() # prints "This function has been called 1 times."
my_function() # prints "This function has been called 2 times."

In this example, we define a global variable count outside of the function my_function().

Inside the function, we declare count to be a global variable using the global keyword.

Then, every time the function is called, we increment the count variable and print out the current value.

Why do we use global variables in Python?

Global variables are a way to store data that can be accessed from anywhere in your Python program. This can be useful when you need to share information between multiple functions or modules.

For example, if you have a game that keeps track of the player’s score, you might use a global variable to store that score so that it can be accessed and updated by different functions throughout the game.

However, global variables should be used sparingly and only when necessary.

This is because they can make your code harder to understand and maintain, and can also lead to unexpected behavior if they are modified by multiple functions at the same time.

Here is an example Python code that demonstrates scenarios where the use of a global variable may be feasible:

score = 0  # global variable

def update_score():
    global score
    score += 1

update_score()
print(score)  # output: 1

In this example, we declare a global variable “score” with an initial value of 0. We then define a function “update_score()” that updates the score by 1 using the “global” keyword to indicate that we want to modify the global variable “score”. Finally, we call the function and print the updated score.

With that being said, global variables can be helpful when you want to achieve:

1. Ease of use: Global variables can be a convenient way to store and share data across different parts of your program without having to pass arguments or return values between functions.
2. Simplicity: Using global variables can help simplify your code by reducing the number of arguments and return values that need to be passed between functions.
3. Modularity: Global variables can help separate concerns by allowing you to define data that is relevant to the entire program in one place, rather than scattering it across different functions or modules.

It’s important to note that using global variables can make it harder to reason about the behavior of your code, particularly as your program grows larger and more complex.

It’s generally considered best practice to encapsulate data in objects and pass them between functions as arguments rather than relying on a global state.

This makes your code more modular and easier to test and debug.

Let’s look at couple of reasons why using global variables in Python can lead to potential downsides.

Disadvantages of global variables in Python

Here are the potential disadvantages that may arise when using global variables in Python:

1. Debugging difficulties: Global variables can make it harder to debug your code because any changes made to them can affect multiple parts of your program.
2. Maintainability issues: If you’re not careful, global variables can lead to code that is difficult to read and understand, particularly as your program grows larger and more complex.
3. Unexpected side effects: Using global variables can lead to unexpected side effects and bugs, particularly if the variable is modified by multiple functions or threads at the same time.
4. Dependency issues: Global variables can create dependencies between different parts of your program that may be difficult to manage or modify later on.
5. Security risks: Global variables can create security risks if sensitive data is stored in them and is accessed or modified by unauthorized users.
6. Thread-safety issues: Global variables can cause thread-safety issues if they are modified by multiple threads at the same time.
7. Testing difficulties: Global variables can make it harder to test your code, particularly if you need to test different parts of your program in isolation.
8. Code reusability: Global variables can make it harder to reuse code in different contexts because any code that relies on the global variable will need to be modified to work correctly in a different context.
9. Performance issues: In some cases, using global variables can be less efficient than passing arguments or returning values between functions, particularly if the global variable is accessed frequently.

Overall, while global variables can be a useful tool in certain situations, it’s generally considered best practice to use them sparingly and with care. Be mindful of these setbacks whenever you are thinking of implementing a solution that uses a global variable.

Let’s see how you can declare a global variable in Python in situations that it may seem fit to use it in your Python code.

How to declare a global variable in Python

To declare a global variable in Python, you need to use the “global” keyword followed by the name of the variable you want to declare as global.

Here’s how you can declare a global variable in Python:

Step 1: Define the global variable outside of any function.

For example, let’s say we want to declare a global variable “x” with a value of 5:

x = 5

Step 2: Use the global keyword inside any function

Use the “global” keyword inside any function where you want to access or modify the global variable.

For example, let’s say we have a function called “my_function” that needs to access the global variable “x”:

def my_function():
    global x
    print("The value of x is:", x)

Step 3: Call the function to access the global variable

For example, let’s call the “my_function” to print the value of “x”:

my_function()

This will output:

The value of x is: 5

Note that you only need to use the “global” keyword inside functions where you want to access or modify the global variable.

You don’t need to use it outside of functions when you’re defining the global variable.

Where should you declare global variables in Python?

Global variables are declared at the top of the file of a Python file, before any function definitions. It is considered a best practice, making it clear that the variable is intended to be a global variable that can be accessed from multiple places in the program.

After declaring your global variables, you will at one time need to use them inside or outside your Python functions. Let’s look at each scenario and see how you can assign or update values of a global variable in Python.

How to assign a value to a global variable outside a Python function

Assigning a value to a global variable outside a Python function is a simple task, and can be accomplished using the following steps:

1. Declare the global variable outside of any functions

Declare the global variable outside of any functions. This tells Python that the variable is global, meaning it can be accessed and modified from anywhere in the program.

For example, let’s say we want to create a global variable called “x” and assign it a value of 10. We can do this using the following code:

x = 10

2. Access the global variable from anywhere in your code

Since we declared “x” as a global variable in step 1, we can access and modify its value from anywhere in our program.

For example, if we want to modify the value of “x” to 20 later in our code, we can simply assign a new value to “x” like this:

x = 20

Once we’ve executed this code, the value of “x” will be 20 throughout the rest of our program.

How to change a global variable in a function in Python

In Python, a global variable is a variable that is defined outside of any function and can be accessed from any part of the program, including functions.

If you want to assign a value to a global variable inside a function, you need to use the “global” keyword to indicate that you are referring to the global variable, rather than a local variable with the same name.

Here’s a step-by-step process to assign a value to a global variable in a Python function:

Step #1: Define the global variable outside of any function

For example, if you want to create a global variable called “count”, you can define it like this:

count = 0

Step #2: Define a function that will modify the value of the global variable

For example:

def increment_count():
    global count
    count += 1

Note the use of the “global” keyword inside the function, which tells Python to use the global variable “count” instead of creating a new local variable.

Step #3: Call the function to modify the value of the global variable

For example:

increment_count()
print(count)  # Output: 1

This code will increment the value of the global variable “count” by 1 and print the new value, which is 1.

What happens when we modify a global variable inside a function in Python?

In Python, when you modify a global variable inside a function using the global keyword, you are telling Python to use the global variable instead of creating a new local variable with the same name.

Any modifications you make to the variable inside the function will affect the global variable.

If you want to modify a global variable inside a function, you can use the global keyword to indicate that you want to refer to the global variable, not create a new local variable with the same name.

Here’s an example:

x = 10 # global variable

def my_func():
    global x
    x = 5 # modify the global variable
    print("Local x:", x)

my_func()
print("Global x:", x)

In this example, we use the global keyword to indicate that we want to refer to the global variable x inside the function, not create a new local variable with the same name.

When we modify x inside the function, we are modifying the global variable, not creating a new local variable.

When we then print the value of the global variable x after calling the function, we see that it has been modified and now has a value of 5.

When you modify a global variable inside a function in Python, it creates a new local variable with the same name as the global variable, and this new local variable shadows the global variable within the function.

This means that any modifications you make to the variable inside the function only affect the local variable, not the global variable.

Here’s an example to illustrate this:

x = 10 # global variable

def my_func():
    x = 5 # local variable
    print("Local x:", x)

my_func()
print("Global x:", x)

In this example, we define a global variable x with a value of 10, and then define a function my_func that creates a new local variable x with a value of 5.

When we call my_func, it prints the value of the local variable x (which is 5).

When we then print the value of the global variable x, we see that it has not been modified by the function and still has a value of 10.

So, by default, modifying a global variable inside a function in Python creates a new local variable with the same name, but you can use the global keyword to modify the actual global variable instead.

Scenarios where you may need to declare global variables

Declaring a variable as global can be useful in some situations, but it’s generally recommended to use global variables sparingly.

Here are some scenarios where using global variables may be appropriate:

1) Declaring configuration variables that are used throughout your program

If you have configuration variables that are used throughout your program, such as database credentials or API keys, you may want to define them as global variables so they can be easily accessed by any function that needs them.

DB_HOST = 'localhost'
DB_PORT = 5432
DB_USER = 'myuser'
DB_PASSWORD = 'mypassword'

The values for your database credentials such as port number and host may remain entirely the same across your Python code. Thus, it would make sense to keep these credentials in a global variable.

2) Creating constants values

If you have constant values that are used throughout your program, such as mathematical constants or other fixed values, you may want to define them as global variables for easier access and readability.

PI = 3.14159
GRAVITY = 9.8

3) Storing cached results

If you have a function that performs a computationally expensive operation and you want to cache the result to improve performance, you may want to use a global variable to store the cached result.

Caching is a technique used to store the result of a computationally expensive operation so that it can be reused without having to recompute it.

Caching is particularly useful in situations where the same operation is performed repeatedly with the same input, such as in recursive functions or in loops.

Here’s an example factorial function that uses a global variable for caching in Python:

CACHE = {}  # Define a global cache dictionary

def factorial(n):
    if n == 0:
        return 1
    if n in CACHE:  # Check if the result is already cached
        return CACHE[n]
    result = n * factorial(n - 1)  # Compute the factorial recursively
    CACHE[n] = result  # Cache the result
    return result

print(factorial(5))  # Output: 120

In this example, we define a global variable called CACHE that is used to store the results of the factorial function.

The factorial function takes an integer n as input and recursively computes the factorial of n.

However, before it does so, it checks to see if the result for n is already cached in the CACHE dictionary.

If it is, it simply returns the cached result.

If not, it computes the factorial and caches the result in the CACHE dictionary for future use.

This caching technique can greatly improve the performance of the factorial function, particularly if it is called repeatedly with the same input values.

However, it’s important to note that caching is only appropriate for functions that have deterministic outputs (i.e., the same input always produces the same output), and that the cache should be cleared or reset if the input values change.

Additionally, the cache should be used judiciously, as it can consume memory and potentially lead to memory issues if the cache becomes too large.

4) When creating stateful programs such as games

In some cases, you may be writing a stateful program that maintains some global state, such as a game or simulation.

In this case, using global variables may be the most natural way to manage state.

PLAYER_SCORE = 0
PLAYER_LIVES = 3

def update_player_score(points):
    global PLAYER_SCORE
    PLAYER_SCORE += points
    if PLAYER_SCORE > 1000:
        PLAYER_LIVES += 1

Python global variables best practices

1. Use global variables sparingly: Global variables can make code more difficult to understand and maintain, particularly in large programs. As a general rule, you should try to limit the use of global variables and instead use local variables or function arguments to pass data between functions wherever possible.
2. Use descriptive variable names: When defining global variables, use descriptive names that indicate the purpose of the variable. This makes the code easier to understand and maintain.
3. Define global variables at the module level: Global variables should be defined at the top level of the module, outside of any function definitions. This makes them visible throughout the module.
4. Avoid using mutable global variables: Mutable objects like lists or dictionaries can cause issues with global variables, as multiple functions may be modifying the same object at the same time. If you need to use mutable objects as global variables, consider using immutable containers like tuples.
5. Don’t use global variables for temporary storage: Global variables should be used for values that are intended to persist throughout the program’s execution. If you need to store temporary data, consider using local variables instead.
6. Use global constants for fixed values: If you have fixed values that are used throughout your program, like mathematical constants or default settings, consider defining them as global constants rather than global variables.
7. Avoid name clashes: Be careful to avoid naming conflicts between global variables and local variables or other global variables. It’s a good practice to use a consistent naming convention for global variables to help avoid conflicts.
8. Consider alternative approaches: In some cases, it may be possible to achieve the same functionality as a global variable using alternative approaches, such as passing values between functions or using a singleton design pattern.
9. Document the use of global variables: If you do use global variables in your code, be sure to document their use and purpose to help other developers understand their role in the program.
10. Use thread-safe techniques for concurrent programming: If you’re writing concurrent or multithreaded programs, be sure to use thread-safe techniques when working with global variables to avoid race conditions and other concurrency issues.

FAQs

Can global variables be accessed from different files?

Global variables can be accessed from different files in Python as long as the global variables are defined in a module that is imported by the files that need to access them.

When you define a global variable in a module, it is visible throughout the module, and any other modules that import that module can access the global variable.

Here’s an example to illustrate this:

Suppose you have two Python files, file1.py and file2.py, and you want to define a global variable in file1.py and access it from file2.py.

Here’s how you could do it:

In file1.py, define a global variable:

# file1.py

global_var = 42

In file2.py, import the file1 module and access the global_var variable:

# file2.py

import file1

print(file1.global_var) # Output: 42

Note that when you import a module, its code is executed, including the code that defines its global variables.

This means that any modifications you make to a global variable in one file will be visible to any other files that import that module.

Can global and local variable have the same name in Python?

In Python, a local variable can have the same name as a global variable, but they are two distinct variables and can be accessed separately.

When you define a variable inside a function, it is a local variable, and it is only visible within the function.

If a local variable has the same name as a global variable, the local variable will “shadow” the global variable within the function, meaning that the local variable takes precedence over the global variable.

Here’s an example to illustrate this:

x = 10 # global variable

def my_func():
    x = 5 # local variable
    print("Local x:", x)

my_func()
print("Global x:", x)

In this example, we define a global variable x with a value of 10, and then define a function my_func that also defines a variable x with a value of 5.

When we call my_func, it prints the value of the local variable x (which is 5).

When we then print the value of the global variable x, we see that it has not been modified by the function and still has a value of 10.

So, a local variable and a global variable can have the same name in Python, but they are two separate variables, and any modifications made to one will not affect the other.

Are global variables thread safe in Python?

Global variables in Python are not inherently thread-safe.

If multiple threads access and modify the same global variable concurrently, it can lead to race conditions, where the order of execution of the threads affects the outcome of the program.

To make global variables thread-safe in Python, you can use synchronization mechanisms such as locks or semaphores to ensure that only one thread accesses the global variable at a time.

Here’s an example using a lock:

import threading

# global variable
x = 0

# lock to synchronize access to x
lock = threading.Lock()

# function to modify x
def modify_x():
    global x
    with lock:
        x += 1

# create multiple threads to modify x concurrently
threads = []
for i in range(10):
    t = threading.Thread(target=modify_x)
    threads.append(t)
    t.start()

# wait for all threads to finish
for t in threads:
    t.join()

# print the final value of x
print("x =", x)

In this example, we define a global variable x and a lock to synchronize access to it. We then define a function modify_x that modifies the global variable x by incrementing it by 1, using the lock to ensure that only one thread can access x at a time.

We then create 10 threads to call modify_x concurrently and wait for all threads to finish.

Finally, we print the final value of x to confirm that it has been modified correctly.

Why are global variables not recommended in Python?

Global variables are not recommended in Python for several reasons:

1. Readability and maintainability: Code that uses global variables can be harder to read and understand, especially in larger programs with many functions and modules. Global variables can also make it more difficult to maintain code over time, as changes to the global variable can have unintended side effects on other parts of the program.
2. Debugging: Global variables can make debugging more difficult, as it can be hard to track down where a global variable was modified and by which part of the program. This can make it harder to reproduce bugs and fix them.
3. Encapsulation and modularity: Global variables can make it harder to encapsulate and modularize code, which can make it harder to reuse and test code. By using local variables or passing data between functions explicitly, you can better encapsulate and modularize code, which can make it more flexible and easier to work with.
4. Thread safety: As mentioned earlier, global variables can be thread-unsafe if multiple threads access and modify the same variable concurrently, which can lead to race conditions and unpredictable behavior.

Overall, global variables should be used sparingly in Python and only when necessary. Instead, you should strive to encapsulate and modularize code as much as possible, and use local variables or function arguments to pass data between functions and modules.

This can make your code more readable, maintainable, and flexible, and reduce the risk of bugs and unexpected behavior.

What is the alternative for global variables in Python?

In Python, there are several alternatives to using global variables:

1. Local variables: Instead of using global variables, you can define variables inside a function or method as local variables. Local variables are only accessible within the function or method in which they are defined, and are not visible to other parts of the program. This can help improve encapsulation and modularity, as it makes it easier to reason about how data is being used within a specific function or method.
2. Function arguments: Another alternative to global variables is to pass data between functions using function arguments. By passing data as arguments, you can explicitly control how data is being used and modified within a function, and avoid the need for global variables altogether. This can make your code more modular and flexible, and reduce the risk of bugs and unexpected behavior.
3. Instance variables: If you’re working with object-oriented programming (OOP), you can use instance variables to store data that is specific to a particular instance of a class. Instance variables are accessible through the class instance, but are not visible to other parts of the program. This can help improve encapsulation and modularity, and make it easier to reason about how data is being used within a specific instance of a class.
4. Class variables: Class variables are another alternative to global variables in OOP. Class variables are defined within a class definition, and are accessible through the class itself, but are not visible to other parts of the program. This can help improve encapsulation and modularity, and make it easier to reason about how data is being used within a specific class.

Conclusion

Global variables can be a useful tool in certain situations, but they come with their own set of risks and limitations.

In Python, it’s generally recommended to avoid using global variables when possible, and instead use alternative approaches such as local variables, function arguments, instance variables, or class variables.

By adopting these best practices, you can make your code more modular, flexible, and easier to reason about, and reduce the risk of bugs and unexpected behavior.

Remember, good code is not just about solving problems, but also about making it easier for yourself and others to understand and maintain the code over time.