Global Variables in Python
Python, one of the most popular programming languages, supports the use of global variables. Global variables in Python are used to declare variables that can be accessed and modified by any function or code block within a Python program.
This article provides a comprehensive guide on what global variables in Python are, how they are used in functions, and how to modify them using the global keyword. We will also explore how to use them across Python modules and understand the globals() function.
What are Global Variables?
In Python, a global variable is a variable that is declared at the top level of a Python module. Once declared, it can be accessed and modified by any function, method, or code block within the module.
Global variables in Python have no restrictions on the scope, meaning they can be accessed and modified from any part of the program.
Using Global Variables in Functions
When declaring a variable inside a function, it is considered a local variable. A local variable has a limited scope, meaning it can only be accessed and modified within the function it is declared in.
However, if you want to use a global variable in a function, you can simply call it by its name. Consider the following example:
x = 10
def print_number():
print(x)
print_number() # Output: 10In this example, a global variable x is declared at the top level of the module.
Inside the print_number() function, the global variable is accessed and printed to the console. The output of the program will be 10.
Using the Global Keyword to Modify Global Variables
If you want to modify a global variable inside a function, you can use the global keyword. The global keyword is used to declare that a variable is a global variable, even if it is declared inside a function.
Consider the following example:
x = 10
def modify_number():
global x
x = x + 1
print(x) # Output: 10
modify_number()
print(x) # Output: 11In this example, the modify_number() function modifies the global variable x by incrementing its value by 1. The global keyword is used to declare that x is a global variable, even though it is declared inside the function.
The output of the program will be 10 and 11.
Using Global Variables Across Python Modules/Files
If you have defined a global variable in one Python module, you can access it from another module by importing that module.
When you import a module, all the global variables defined in it become available to the importing module. Consider the following example:
#module1.py
x = 10
#module2.py
import module1
print(module1.x) # Output: 10In this example, the module1.py module defines a global variable x. The module2.py module imports module1, which gives it access to the global variable x.
The output of the program will be 10.
Understanding the Globals() Function
Python provides a built-in function, globals(), that can be used to view all the global variables declared in the current Python environment. The globals() function returns a dictionary containing all the global variables defined in the program.
Consider the following example:
x = 10
def print_globals():
print(globals())
print_globals()In this example, the print_globals() function calls the globals() function and prints all the global variables defined in the current Python environment. The output of the program will be a dictionary containing all the global variables, including x.
Using Global Variables Inside a Nested Function
In Python, a nested function is a function defined inside another function. If a global variable is defined outside the outer function, it can be accessed from both the outer and inner functions by using the global keyword.
However, if a global variable is defined inside the outer function, a nonlocal keyword must be used to make it accessible inside the inner function. Consider the following example:
def outer_function():
x = 10
def inner_function():
nonlocal x
x = x + 1
print(x)
inner_function()
print(x)
outer_function()In this example, the outer_function() defines a local variable x and an inner function inner_function(). Inside the inner function, the nonlocal keyword is used to access the value of x defined in the outer function’s scope.
The output of the program will be 11 and 11.
Examples
Example 1: Accessing a Global Variable Inside and Outside a Function
x = 10
def print_number():
print(x)
print(x) # Output: 10
print_number() # Output: 10In this example, a global variable x is declared at the top level of the module. Inside the print_number() function, the global variable is accessed and printed to the console.
The output of the program will be 10 and 10.
Example 2: Using Global Variables Across Multiple Functions
x = 10
def add_number():
global x
x = x + 1
def subtract_number():
global x
x = x - 1
print(x) # Output: 10
add_number()
print(x) # Output: 11
subtract_number()
print(x) # Output: 10In this example, the add_number() and subtract_number() functions modify the global variable x by incrementing or decrementing its value. The global keyword is used to declare that x is a global variable.
The output of the program will be 10, 11, and 10.
Example 3: Modifying a Global Variable Using the Global Keyword
x = 10
def modify_number():
global x
x = x + 1
print(x) # Output: 10
modify_number()
print(x) # Output: 11In this example, the modify_number() function modifies the global variable x by incrementing its value by 1. The global keyword is used to declare that x is a global variable.
The output of the program will be 10 and 11.
Example 4: Sharing Global Variables Across Python Modules/Files
#module1.py
x = 10
#module2.py
import module1
print(module1.x) # Output: 10In this example, the module1.py module defines a global variable x. The module2.py module imports module1, which gives it access to the global variable x.
The output of the program will be 10.
Example 5: Modifying a Global Variable Using the Globals() Function
x = 10
def print_globals():
print(globals())
print(x) # Output: 10
print_globals() # Output: {'__name__': '__main__', '__doc__': None, '__package__': None, ... }In this example, the print_globals() function calls the globals() function and prints all the global variables defined in the current Python environment.
The output of the program will be 10 and a dictionary containing all the global variables.
Example 6: Using a Global Variable in a Nested Function
def outer_function():
x = 10
def inner_function():
nonlocal x
x = x + 1
print(x)
inner_function()
print(x)
outer_function() # Output: 11, 11In this example, the outer_function() defines a local variable x and an inner function inner_function(). Inside the inner function, the nonlocal keyword is used to access the value of x defined in the outer function’s scope.
The output of the program will be 11 and 11.
Conclusion
In conclusion, global variables play an important role in Python programming, allowing us to share variables across multiple functions, modules, and files. It is crucial to use them properly to avoid naming conflicts and make the code more manageable.
By understanding how to declare global variables, access and modify them in functions, use them across modules, and manipulate them using the globals() function, you can write better, more efficient Python code that is easier to debug and maintain. To summarize, global variables in Python are important variables that can be accessed and modified by any function, method, or code block within a Python program.
They are declared at the top level of a Python module and have no restrictions on the scope. The global keyword is used to declare a variable as a global variable, even if it’s declared inside a function.
To use global variables across modules, we can import them, and the globals() function can be used to view all global variables defined in the current Python environment. The article has demonstrated examples and usage of global variables in Python programming and how they should be used carefully.
By using global variables correctly, you can create efficient and manageable Python code that is clear and easy to understand.