What is the use of the "global" keyword in Python?

Question

Jayant Kumar · Accepted Answer

Table of Contants
Introduction
The global keyword in Python allows a function to modify a variable that exists in the global scope, rather than creating a local variable. By default, variables assigned inside a function are local to that function. However, using global, you can access and modify variables defined outside of the function, allowing for shared state across different parts of your program.

How the Global Keyword Works
In Python, variables have different scopes, such as local, enclosing, and global. Normally, when a variable is assigned inside a function, it is treated as local to that function. However, if you want to modify a global variable inside a function, you must declare it as global.
Syntax:
global var_name

This tells Python that var_name refers to the global variable rather than creating a new local one.

Key Use Cases for Global in Python
1. Modifying Global Variables Inside a Function
Without the global keyword, variables assigned inside functions are treated as local to that function. However, with global, you can modify global variables.
Example:
count = 0  # Global variable

def increment():
    global count
    count += 1

increment()
print(count)  # Output: 1

In this example, without using global, the count inside the function would be treated as a local variable, and the global count would remain unchanged.
2. Sharing State Across Functions
Global variables allow different functions to share and modify the same state. This is useful when you need multiple functions to operate on the same data.
Example:
total = 0  # Global variable

def add_to_total(value):
    global total
    total += value

def reset_total():
    global total
    total = 0

add_to_total(5)
print(total)  # Output: 5

reset_total()
print(total)  # Output: 0

Here, both add_to_total and reset_total functions are modifying the same global total variable.

Practical Examples

Global for Configuration Variables:

Global variables can be used to store configuration values or flags that multiple functions in a program need to access.
debug_mode = False  # Global flag

def enable_debug():
    global debug_mode
    debug_mode = True

def print_debug_message(message):
    if debug_mode:
        print("DEBUG:", message)

enable_debug()
print_debug_message("This is a debug message.")  # Output: DEBUG: This is a debug message.

Game State Example:

In game development, global variables can store the state of the game that multiple functions need to access and modify.
game_score = 0  # Global variable

def increase_score(points):
    global game_score
    game_score += points

def show_score():
    print(f"Current score: {game_score}")

increase_score(10)
show_score()  # Output: Current score: 10

This approach allows the game score to be shared and updated across different game components.

Conclusion
The global keyword in Python is essential when you need to modify global variables inside a function. While it can simplify sharing data across functions, it should be used with care to avoid side effects and maintain code readability. By understanding the scope of variables and when to use global, you can manage state more effectively in your programs.

What is the use of the "global" keyword in Python?

Similar Questions