How to declare a global variable in Python

Python is an object-oriented programming language that allows for efficient coding and is widely used in data science, web development, and automation. Variables are a crucial element in programming, and sometimes, you need to define a variable that has a global scope. Variables with global scope can be accessed by all functions in a program, regardless of where they were defined. In this article, we will explore how to declare global variables in Python.

Defining a global variable

To declare a variable with global scope in Python, you need to use the `global` keyword followed by the variable’s name. For example:

global_var = 10
def my_func():
global global_var
print(global_var)
my_func() # output: 10

In the above example, we defined a variable named `global_var` outside any function, giving it a global scope. The function `my_func()` does not have access to `global_var` by default. Therefore, we used the `global` keyword followed by the variable’s name within the function to have access to `global_var`.

Changing the value of a global variable

You can also change the value of a global variable from within a function. To do so, you need to use the `global` keyword followed by the variable’s name, then assign the new value. For example:

global_var = 10
def my_func():
global global_var
global_var = 20
print(global_var)
my_func() # output: 20
print(global_var) # output: 20

In the above example, we redefine `global_var` inside the `my_func()` function by using the `global` keyword followed by the variable’s name and assigning the new value `20`. After calling `my_func()`, we print `global_var`, which now returns `20`.

Global variables in nested functions

If you have nested functions, the `global` keyword only defines the variable globally within the current function. To access and modify a global variable from inside nested functions, you need to use the same process of defining a global variable within each nested function. For example:

global_var = 10

def outer():
global global_var
global_var = 20
def inner():
global global_var
global_var = 30
print(global_var)
inner()
print(global_var)

outer() # output: 30 30
print(global_var) # output: 30

In the above example, we define a variable named `global_var` with a global scope outside the `outer()` function. We then define it globally again inside `outer()` and modify its value. Inside the `inner()` function, which is nested inside `outer()`, we define `global_var` again globally and assign a new value. After calling `inner()`, `global_var` equals `30`. We then have the `outer()` function and print the `global_var` again, which remains `30`. Lastly, we print `global_var` outside of `outer()`, which still equals `30`.

FAQs

Can you change the value of a global variable from inside a nested function without using the `global` keyword?

No, you cannot modify the value of a global variable from within a nested function without using the `global` keyword. Without the `global` keyword, the nested function will create a new variable with the same name as the global variable, rather than modifying the value of the global variable.

What is the difference between a local variable and a global variable?

Local variables are defined within a function and have a local scope, meaning they can only be accessed within that function. Global variables, on the other hand, are defined outside of a function and can be accessed by all functions in a program, regardless of where they were defined.

Why should you use global variables?

Global variables are useful in situations where multiple functions need to access the same data or value. It can be more efficient to define a variable once with a global scope than to redefine it multiple times within separate functions. However, global variables can also lead to unintended changes and make code harder to debug, so they should be used with caution.