In this tutorial, we will learn more about the global keyword and learn where and when to use the global keyword

Table of Content

  • Python global keyword
  • Global variable across python modules
  • Global keyword in nested function

Global Keyword

The global keyword in python helps to grab a variable from global scope to the local scope and allow the function user-defined function to alter its values. With the help of the global keyword, we can create a global variable and alter it in a local scope that will reflect outside the local scope.

How to make a global variable using global keywords:

  • if we use a global keyword inside the function it will grab that variable if it’s already defined or create a new variable.
  • The changes made on the global variable will reflect outside the function too

Let’s understand it with some examples:

Example 1:

x = 20                  #gobal variable

def local():
      print(x)          #printing a global variabel

local()
print(x)

#Output

20
20

Example 2:

What if we create a local variable having the same name as a global variable?

x = 20                     #gobal variable

def local():
    x = 10                      # create local variable same name as global variable
    print("inside local",x)     #printing a local variable variabel

local()
print("outside local", x)

#Output

inside local 10
outside local 20

Example 3:

What if we try to alter the value of global variable inside a function?

x = 20

def local():
    x = x+30
    print(x)

local()

#Output:

UnboundLocalError: local variable 'x' referenced before assignment

Example 4

Use a global keyword to grab the global variable and create a new global variable:

x = 30

def local():
    global x        #grab the global variable x
    global y        #create a new global variable y inside a local scope

    x = x + 10      #alter the value of x
    y = 60          #assign a value to variable y

    print("the value of x inside the function is "+ str(x))
    print("the value of y inside the function is "+ str(y))

local()
print("the value of x outside the function is "+ str(x))
print("the value of y outside the function is "+ str(y))    # calling a variable which is defined inside a function

#Output

the value of x inside the function is 40
the value of y inside the function is 60
the value of x outside the function is 40
the value of y outside the function is 60

Global Variable Across the Python module

For now, think that Modules are the different python files containing python code. Now, create a module or create a new python file by name new.py and it should be on the same folder on which your main.py file.

Now we will declare some variables in new.py file as global variables and then use a file change.py to change the values of new.py file and then call the new.py file variable in our main.py file and check whether the change.py file make changes in the new.py file variable or not

Let’s understand it with an example:

###################### new.py########################################

x    =  30
y    =  "Hello world"

####################### change.py##################################

import new
new.x  =  200
new.y  =  "Hey"

######################### main.py ##################################

import change
import new

print(new.x)
print(new.y)

#Output

200
Hey

Behind the code:

In the above example, we created three files new.py, change.py, main.py. In new.py we declared two variables x and y then in change.py file we alter the values of new.py file variable x and y which we could see at our main.py file output.

you can see that in our main.py file we import both new.py and change.py file if we only import new.py file so there would be no changes occur in the x and y values of the new.py file.

Global keyword in the nested loop

Let’s see how to make a global keyword acts inside a nested loop.

Example:

 def local():
    x = 40  #local variable
    
    def in_local():
        global x        #create a global variable x having same name as the local variable of function local()
        x = 30          #assigning a new value to the global variable x
        print("the value of x inside in_local function is: ",x)

    in_local()          #calling the function in_local
    print("value of x inside the local function is: ", x)

local()
print("the value of x outside the function is:",x )

#Output

the value of x inside in_local function is:  30
value of x inside the local function is:  40
the value of x outside the function is: 30

Behind the scene:

In the above example, we can see that when we write global x inside the in_local() function it did not grab the local()  function x variable instead it created a new global variable x has nothing to do with variable x of the local() function.

Python Tutorials:

Introduction

Flow Control

Function

Leave a Reply

Your email address will not be published. Required fields are marked *