Welcome to the TGB Python tutorials. In this tutorial, we will discuss the variable used in Python and how a variable is categorized into global, local, and non-local categories. Also, we will discuss the global keyword. So let us get started!
Python Global Local Nonlocal Variables
Python has three types of variables:
- Global variables,
- Local variables, and
- Nonlocal variables
1. Python Global Variables
All those variables in Python that are declared outside the function in a global scope are known as global variables. In simple words, any statement of the program can access a global variable.
Let’s understand it with an example:
global_variable = 20 #Global Variable
def func(): #defining a function
print("the value of global_variable is " + str(global_variable))
func() #function calling
#Output
the value of global_variable is 20
Behind the code:
In the above example, we first declared a variable with the name global_variable and assigned value 20 to it, and then we defined a function func(), which is printing the output value of global_variable.
When we are calling the function func(), it starts execution, and it reaches the print statement and at the print() statement, first the function looks for the globlal_variable inside itself, but when it could not find it inside func(), then it starts looking for it outside the function and then prints the value.
2. Python Local Variables
All those variables that we define inside the function are known as local variables. Also, you cannot access them outside the function.
Let’s understand it with an example:
g = "global variable" def local(): l = "local variable" print(g) # printing global variable print(l) # print local variable local()
#Output
global variable local variable
Behind the code:
In the above example, g is a global variable, and l is a local variable. You can see that we can access g inside the function local, and we can access it outside the function, but if you try to access the variable l outside the function, it will throw an error.
Let’s call a local variable outside the function:
def local(): l = "local variable" # l is a local variable local() print(l) # Accessing local variable outside the function
#Output
NameError: name 'l' is not defined
Behind the code:
As evident from the output, we cannot access the local variable outside the function. If we try to access it, we will get an error, such as “variable not defined.”
3. Python Nonlocal Variables
The nonlocal is a keyword that acts as a global keyword for the nested function (function inside another function). We use the nonlocal keyword when a variable is in local scope but acts as a global scope for another function.
Let’s understand it with an example:
def local():
x = 70
def in_local():
nonlocal x #here we grab the actual x variable which is a local variable
x = 70000
print("value of x inside the in_local function is", x)
in_local() #calling function in_local
print("the value of x inside the function local has become", x)
local()
#Output
value of x inside the in_local function is 70000 the value of x inside the function local has become 70000
Behind the function:
Though variable x of the local() function is a local variable, it act as global variable for the function in_local(). When we use the keyword nonlocal to grab the variable x and use it inside the nested function, i.e., in_local(), every change we make inside the in_local function on variable x reflects back on the original value of x.
Global Keyword in Python
global is a keyword in Python which helps to access the actual global variable from outside the function. Until now, we know that we can access the global variable from outside the function, but if you alter the global variable or assign a new object or value to it inside the function, it will become a local variable, and this has no impact on the actual global variable that is present outside the function.
If you want to grab a variable that is outside the function and want to make changes there, we need the global keyword. It can grab the global variable, and we can alter them inside the function.
Let’s understand it with an example.
global_variable_1 = 20
global_variable_2 = 30
def local():
global global_variable_1 #here we have access the actual global_variable_1 which is present outside the function
global_variable_2 = 70 #it is a local variable having the same name as the global variable
global_variable_1 = 80 #here we have changed the value of globle_variable_1 which will reflect outside the function too
local()
print("the value of global_variable_1 has become", global_variable_1)
print("the value of global_variable_2 did not change" , global_variable_2)
#Output
the value of global_variable_1 has become 80 the value of global_variable_2 did not change 30
Behind the code:
In the above example, we have used the global keyword to access the global_variable_1 inside the local() function. Inside the local() function, we have two variables, namely global_variable_1 and global_variable_2.
global_variable_1 is the same variable that is defined outside the local() function, and the global_variable_2 is the newly created local variable for the local() function. When we changed the values of both the variables inside the function only the value of global_variable_1 showed the changes, because it was accessed and changed by the local() function.
Let’s take another example, but here we do not use the global keyword:
var = 30 # global variable
def local():
var = 30 #local variable
var = var +40
print("var inside the local function",var)
local()
print("var outside the function", var)
#Output:
var inside the local function 70 var outside the function 30
Same example with global keyword
var = 30 # global variable
def local():
global var #global variable
var =var+ 40
print("var inside the local function ",var)
local()
print("var outside the function", var)
#Output
var inside the function local 70 var outside the function 70
Conclusion
That sums up this Python tutorial on Python global local nonlocal variables. As you can see, the distinction between whether a Python variable is global, local, or nonlocal depends on its scope, i.e., where it can be used throughout the program.
perfect one … i loved it ..