Variable Scope in Python

Variables in Python language serve as the storage units for the various data values and data structures. When a variable is assigned to any Python object, it then points toward that object since they are reference, or a pointer, to that particular object in the memory location. Python programming language is not "statically typed," unlike other languages like C/C++/JAVA. Variables do not have to have their types or initial values declared before use. When a variable is initially given a value, it is considered to have been formed.

Code

# Python program to show how variables are assigned to the data values
   
# Assigning a variable name to an integer
integer = 45                     
   
# Assigning a variable name to a floating point number
floating = 1456.8           
   
# Assigning a variable name to a string
string = "John"             
   
print("This value is stored in the variable 'integer':- ", integer)
print("This value is stored in the variable 'floating':- ", floating)
print("This value is stored in the variable 'string':- ", string)

Output:

This value is stored in the variable 'integer':-  45
This value is stored in the variable 'floating':-  1456.8
This value is stored in the variable 'string':-  John

Scope of a Variable

The scope of a Python variable refers to the area where we may locate it and, if necessary, access it.

Global and Local Variables

Global variables are those we declare and define outside of any functions but not specific to any of them. Any section of the program can make use of them.

Code

# Python program to show how any function can use global variables

# Declaring a global variable
a = 2

# Accessing the global variable in the main function
print("This is in the main function:- ", a)

# Defining a function that uses the global variable
def f1():
    print("This is in function 'f1()':- ", a)

# Defining another function that uses the global variable
def f2():
    print("This is in function 'f2()':- ", a)

# Calling the functions
f1()
f2()

Output:

This is in the main function:- 
2
This is in function 'f1()':- 
2
This is in function 'f2()':- 
2

Suppose a variable is defined within the local scope of that function and has the same name as the global variable. In that case, it will only display the value supplied to the variable inside that particular function and not the value assigned in the global scope.

Code

# Python program to show function accesses the variable value that is in the function's scope

# Declaring a global variable
a = "This is assigned in the global scope."

# Defining a function that has a variable having the name same as the global variable
def func():
    a = "This is defined inside the function."
    print(a)
   
# Calling the function
func()

Output:

This is defined inside the function.

Before defining the function func(), the variable 'a' is assigned to a string that states, "This is assigned in the global scope.". The print(a) statement of the function func() will first search for variable 'a' in its local scope. Since there is already a variable 'a' assigned to a different string, the function will print the value of this variable and will not go in the global scope. The function, in this case, will not use the value of variable 'a' from the global scope.

What will be the result of modifying the value of variable 'a' inside the function 'func()' is the next question. Will it also have an impact on the global variable 'a'? The following snippet of code is used to test it:

Code

# Python program to show function accesses the variable value that is in the function's scope

# Declaring a global variable
a = "This is assigned in the global scope."

# Defining a function that has a variable having the name same as the global variable
def func():
    a = "This is defined inside the function."
    print("Accessed in the local scope of function:- ", a)
   
# Calling the function
func()

# Accessing the variable a in the global scope after changing its value inside the function
print("Accessed in the global scope:- ", a)

Output:

Accessed in the local scope of function:-  This is defined inside the function.
Accessed in the global scope:-  This is assigned in the global scope.

We must use the Python global keyword to make the preceding program function. Only when making assignments or changing the variable value do we need to use the Python global keyword inside a function. The global keyword is not necessary for displaying and accessing a variable present in the global scope. Why? Since the assignment to the variable 'a' inside of func(), Python "presumes" that we desire to access the local variable, which is why the initial print command returns the variable's value in the local scope. If a variable is modified or assigned inside a function without being defined as a global variable, it is considered a local variable. The following example demonstrates how to use the global keyword to instruct the Python interpreter that we wish to modify the global variable:

Code

# Python program to show function accesses the variable value that is in the function's scope

# Declaring a global variable
a = "This is assigned in the global scope."

# Defining a function that uses the global keyword before assigning a new value to the global variable
def func():
    global a
    a = "This is defined inside the function."
   
print("Accessed in the local scope of function:- ", a)
   
# Calling the function
func()

# Accessing the variable a in the global scope after changing its value inside the function
print("Accessed in the global scope:- ", a)

Output:

Accessed in the local scope of function:-  This is defined inside the function.
Accessed in the global scope:-  This is defined inside the function.

Summarising the Global Local Variable Scope.

Code

# Python program to summarise the global and local variable scope.

# Defining a variable in the global scope
a = 'in the global scope'
   
# This function will print the global variable because there does not exist any local variable 'a'
def func():
    print('Inside func(): ', a)
   
# This function will print the value assigned to the local variable 'a'
# Because we are not using the global keyword
def local():    
    a = 'inside function local()'
    print('Inside local(): ', a)
   
# This function will modify the global variable because we are using the global keyword
def global_():    
    global a
    a = 'changed inside function global_()'
    print('Inside global_() : ', a)
   
# Calling the functions
# Value of 'a' in global scope after each function call
print('global: ', a)
func()
print('global: ', a)
local()
print('global: ', a)
global_()
print('global: ', a)

Output:

global:  in the global scope
Inside func():  in the global scope
global:  in the global scope
Inside local(): 
inside function local()
global:  in the global scope
Inside global_() : 
changed inside function global_()
global:  changed inside function global_()

Nonlocal Keyword

In Python, the nested functions are handled with the Python nonlocal keyword. This keyword acts similarly global keyword, except that in the case of nested functions, it defines a variable to refer to the variable assigned in the outer enclosing function rather than the global variable.

Code

# Python program to show how the nonlocal keyword works

print ("Using the nonlocal keyword before changing a:")

# Assigning 'a' in the global scope
a = 0

# Defining a function
def outer():

    # Giving new value to 'a' in the local scope of the 'outer' function
    # Didn't use global keyword here
    a = 3
    def inner():

        # Defining the variable scope as the local scope of the 'outer' function
        nonlocal a 

        # Changing the value of 'a' in the local scope of the 'inner' function
        a = 14

        # Printing the value of 'a' in the local scope of the 'inner' function
        print("Inside 'inner' function:- ", a)
    
    # Calling the inner function
    inner()

    # Priting the value of 'a' inside the function
    print("Inside the 'outer' function:- ", a)

# Calling the main function
outer()

# Printing the value of 'a' in the global scope
print("In the global scope:- ", a)

# Performing the same steps as above without using the nonlocal keyword
print ("\nNot using the nonlocal keyword before changing a:")

# Assigning 'a' in the global scope
a = 0

def outer():
    a = 3

    def inner():

        # Not using the nonlocal keyword before assigning a new value to a
        a = 14
        print("Inside 'inner' function:- ", a)

    inner()
    print("Inside the 'outer' function:- ", a)
   
# Calling the main function
outer()

print("In the global scope:- ", a)

Output:

Using the nonlocal keyword before changing a:
Inside 'inner' function:- 
14
Inside the 'outer' function:-  14
In the global scope:- 
0

Not using the nonlocal keyword before changing a:
Inside 'inner' function:- 
14
Inside the 'outer' function:-  3
In the global scope:- 
0

Next TopicAlphabet in Python

← prev next →