In Python, variables can be defined within a function or outside of it. Variables defined inside a function are known as local variables and are only accessible within that function. On the other hand, variables defined outside of any function are called global variables, which can be accessed from anywhere in the program.
However, when you want to modify a global variable within a function, Python treats it as a local variable by default unless explicitly declared as global using the global keyword. This behavior is due to how Python handles namespaces and assignment operations.
Understanding Namespaces
Python has several namespaces: built-in namespace (containing functions like len(), print()), module namespace (specific to each imported module), and local namespace (within a function). When you assign a value to a variable, Python first looks for that name in the current namespace. If it’s not found locally, Python then checks the enclosing namespaces until it reaches the global namespace.
Declaring Global Variables
To declare a variable as global within a function, use the global keyword followed by the variable name(s) you want to modify globally:
globvar = 0
def set_globvar_to_one():
global globvar # Needed to modify global copy of globvar
globvar = 1
def print_globvar():
print(globvar) # No need for global declaration to read value of globvar
set_globvar_to_one()
print_globvar() # Prints: 1
In this example, globvar is initially defined outside any function (making it a global variable). The set_globvar_to_one() function modifies globvar, requiring the global declaration. The print_globvar() function only reads globvar, so no global declaration is necessary.
Shadowing Global Variables
If you assign to a variable within a function without declaring it as global, Python creates a local variable with that name, which "shadows" or hides the global variable of the same name. This can lead to unexpected behavior if not understood:
_my_global = 5
def func1():
_my_global = 42 # Creates a local variable, does not modify the global one
def func2():
print(_my_global) # Prints: 5 (not 42)
func1()
func2()
To avoid this and ensure you’re modifying the global variable, use the global keyword:
_my_global = 5
def func1():
global _my_global
_my_global = 42 # Now modifies the global variable
def func2():
print(_my_global) # Prints: 42
func1()
func2()
Best Practices and Alternatives
While global variables have their uses, especially in small scripts or for configuration values across modules, they should be used judiciously. For larger applications or when following object-oriented principles, encapsulating data within classes can provide a cleaner and more maintainable structure.
For sharing data across modules without using global variables directly, you can create a separate module dedicated to holding shared data or configuration:
# config.py
x = 0 # Default value
# mod.py
import config
config.x = 1
# main.py
import config
print(config.x) # Prints: 1
This approach allows for controlled access and modification of shared variables without polluting the global namespace.
In summary, understanding how Python handles global variables within functions is crucial for avoiding common pitfalls like UnboundLocalError. By using the global keyword correctly and being mindful of variable scope, you can write more predictable and maintainable code.