Scope and Name Space

Scope of Object and Names

 The scope refers to the region in the program code where variables and names are
accessible.
 It also determines the visibility and lifetime of a variable in the program code.
 Assigning a value, defining a function or class (using def or class) or importing module
operation creates a name and its place in the code defines its scope.
 The names or objects which are accessible are called in-scope.
 The names or objects which are not accessible are called out-of-scope.
 The Python scope concept follows the LEGB (Local, Enclosing, Global and built-in) rule.
 The scope concept helps to avoid the name collision and use of global names across the
programs.

Names and Objects in Python

 Python is a dynamically types language, so when we assign the value to the variable for the
first time, it creates the variable. Others names or objects come in existence as given :
Operation Statement
Assignment X=value
Import Operation import module
Function definitions def fun( )
Arguments in the function def fun( x1, x2 , x3 )
Class definition class abc :

 Python uses the location of the name assignment or definition to associate it with a scope.
 If a variable assigned value in the function, it has a local scope.
 If a variable assigned value at the top level and outside all the functions, it has a global scope.

Python Scope Vs Namespace

 The scope of a variables and objects are related to the concept of the namespace.
 The scope determines the visibility of the names and objects in the program.
 A namespace is a collection of names.
 In python, scopes are implemented as dictionaries that maps names to objects. These
dictionaries are called namespaces.
 The dictionaries have the names as key and the objects as value.
 A strings, lists, functions, etc everything in Python is an object.
Searching a name in the Namespace
 Whenever we use a name, such as a variable or a function name, Python searches through
different scope levels (or namespaces) to determine whether the name exists or not.
 If the name exists, then we always get the first occurrence of it.
 Otherwise, we get an error.

Types of namespace
1. Built-in Namespace It includes functions and exception names that are built-in in
the python.
2. Global Namespace It includes the names from the modules that are imported in
the code. It lasts till the end of program.
3 Local Namespace It includes the names defined in the function. It is created
when the function is called and ends when the value
returned.

LEGB Rule for Python Scope

 The LEGB stands for Local, Enclosing, Global and Built-in.
 Python resolves names using the LEGB rules.
 The LEGB rule is a kind of name lookup procedure, which determines the order in which
Python looks up names.
 For example, if we access a name, then Python will look that name up sequentially in the
local, enclosing, global, and built-in scope.

Local (or function) scope

 It is the code block or body of any Python function or lambda expression.
 This Python scope contains the names that you define inside the function.
 These names will only be visible from the code of the function.
 It’s created at function call, not at function definition, so we have as many different local
scopes as function calls.
 It is applicable if we call the same function multiple times, or recursively.
 Each call will result in a new local scope being created.

Enclosing (or nonlocal) scope

 It is a special scope that only exists for nested functions.
 If the local scope is an inner or nested function, then the enclosing scope is the scope of the
outer or enclosing function.
 This scope contains the names that you define in the enclosing function.
 The names in the enclosing scope are visible from the code of the inner and enclosing
functions.

Global (or module) scope

 It is the top-most scope in a Python program, script, or module.
 This scope contains all of the names that are defined at the top level of a program or a
module.
 Names in this Python scope are visible from everywhere in your code.

Built-in scope
 It is a special scope which is created or loaded at script run or opens an interactive session.
 This scope contains names such as keywords, functions, exceptions, and other attributes that
are built into Python.
 Names in this scope are also available from everywhere in your code.

Type of Scope in Python (LEGB)

Built in Scope

Global Scope

Enclosing Scope

Local Scope

Example
#var1 is in the global namespace
var1 = 5
def ABC( ):
 # var2 is in the local namespace
var2 = 6
def XYZ( ):
# var3 is in the nested local
# namespace
var3 = 7

 In this example, the var1 is declared in the global namespace because it is not enclosed
inside any function. So it is accessible everywhere in the script.
 var2 is inside the ABC( ). So, it can be accessed only inside the ABC( ) and outside the
function, it no longer exists.
 var3 also has a local scope, the function is nested and we can use var3 only inside XYZ(
).

Modules
 A module helps to break the large program to manageable and organized code. It allows
the reusability of code.
 Module is a Python file containing a set of Python Statements and Functions.
 Module files has the “.py” extension. e.g. my_abc.py

Create Module
To create a module , save a file with extension “.py”

File my_abc.py

def show(name, age) :

print("Name : " , name)
print("Age : ", age)

Employee= { "name":"Ajay", "age":30, "Salary":20000 }

Import Module
 Import Statement help to provide the Module contents to the caller program code.
 Import module created a separate namespace, which contains all the objects define in the
module.
 Module content like identifiers , functions , class or objects defined in the module can be
accessed using the dot notation like <ModuleName>.<FunctionName>. eg. my_abc.show( )
Syntax
import Module_Name

Example
To import the module “my_abc.py” for using in the “m1.py” program file.
import my_abc
print("\n Accessing function from Module\n")
my_abc.show("vikas",27)

print("\n Accessing Variable from Module\n")

print(my_abc.Employee["name"])
print(my_abc.Employee["age"])
print(my_abc.Employee["salary"])

Output
Accessing function from Module
Name : vikas
Age : 27

Accessing Variable from Module

Ajay
30
20000

Renaming Module
To import the module “my_abc.py” and rename it “m” for using in the “m1.py” program file.

import my_abc as m

print("\n Accessing function from Module\n")

m.show("vikas",27)

print("\n Accessing Variable from Module\n")

print(m.Employee["name"])
print(m.Employee["age"])
print(m.Employee["salary"])
Output
Accessing function from Module
Name : vikas
Age : 27

Accessing Variable from Module

Ajay
30
20000

Using the dir( ) function

This function is used to list all the functions or variables defined in the module imported.

import my_abc
x=dir( my_abc )
print( x )

print( __file__ )
print( __name__ )

Output
['Employee', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__',
'__package__', '__spec__', 'show']

C:/Python38-32/m2.py
__main__
In this, Employee and show is defined in the “my_abc” module and remaining are the
system defined.

Using the from …import

 This is used to import the part of the module as required.
 If the module is imported using the “from..import” syntax, then module name is not
used before the function or variable imported.
 For example if show( ) is imported from my_abc module, we can’t use my_abc.show( ),
instead use show( ) only.

Example-1
 from my_abc import show
print("\n Accessing function from Module\n")
show("vikas", 27)
print("\n Accessing Variable from Module\n")
print(Employee["name"]) # This is not accessible, as not imported.

Output
Accessing function from Module
Name : vikas
Age : 27
Accessing Variable from Module

Traceback (most recent call last):

File "C:/Python38-32/m1.py", line 7, in <module>
print(Employee["name"])
NameError: name 'Employee' is not defined

Example-2

from my_abc import Employee

print("\n Accessing Variable from Module\n")

print(Employee["name"])
print(Employee["age"])
print(Employee["salary"])

print("\n Accessing function from Module\n")

show("vikas",27)

Output
Accessing Variable from Module
Ajay
30
20000

Accessing function from Module

Traceback (most recent call last):
File "C:/Python38-32/m1.py", line 10, in <module>
show("vikas",27)
NameError: name 'show' is not defined

Importing all the Modules using from…import

  It can be used to import the objects from the modules.
 If the module is imported using the “from..import” syntax, then module name is not
used before the function or variable imported.

Example
from my_abc import *

print("\n Accessing Variable from Module\n")

print(Employee["name"])
print(Employee["age"])
print(Employee["salary"])

print("\n Accessing function from Module\n")

show("vikas",27)

Output
Accessing Variable from Module

Ajay
30
20000

Accessing function from Module

Name : vikas
Age : 27
Packages
 A package is a well-organized hierarchy of sub-directories and files, for easier access of
modules.
 The directory is a package [or sub package] and files are modules.
 Package is a place for similar modules, and help in grouping and organizing them.
 Package directory or sub-directory must contain a file “_ _init__.py” used as initialization
code. It can be an empty file. However, it new version of python, this is not compulsory.
 Packages help avoid collisions between module names and modules help avoid collision
between variable names.
 Packages are helpful to manage the large projects having lots of modules.
Create Package
To create a Package – MyPkg perform the following steps –
1) Create a folder on “D:\MyPkg”
2) Create a sub folder in D:\MyPkg – P1 & P2

3) Create a module m1.py , m2.py in D:\MyPkg\P1 sub folder.

4) Create a module m3.py and m4.py in D:\MyPkg\P1 sub folder.

5) Content of the Module are as follows

Module M1.py
Employee={ "name":"Ajay M1", "age":27, "salary":30000}
def show(name):
print("Name :", name)

Module M2.py
Employee={ "name":"Vijay M2", "age":27, "salary":30000}
def sum(x , y):
return(x+y)

Module M3.py
def show(name, age):
print("Name :", name)
print("Age :", age)
 Employee={ "name":"Ajay M3", "age":27, "salary":30000}

Module M4.py
def mul(x,y):
print("sum : ", x*y)

Employee={ "name":"Vijay M4", "age":27, "salary":30000}

Import Package
 Import Statement help to provide the Module contents to the caller program code.
 Import Package creates a separate namespace for each sub package, which contains all the
objects define in the module.
 We can provide the path for package using sys.path.append("Package Path") in the code or
modify the PYTHONPATH environment variable.
 Package content like identifiers, functions, class or objects defined in the module can be
accessed using the dot notation like <PackageName>.<ModuleName>.<FunctionName>.
eg. MyPkg.my_abc.show( )
Syntax
import Package_Name.Module_Name

Example
To import the package “D:\Mykg\P1” for using in the “m1.py” and “m2.py” module file.

import sys
sys.path.append("D:\\")

import MyPkg.P1.m1
import MyPkg.P1.m2

print("Objects in P1 - m1 module ")

print( dir(MyPkg.P1.m1))

print("Objects in P1 - m2 module ")

print( dir(MyPkg.P1.m2))

print("Accessing P1 - m1 module ")

MyPkg.P1.m1.show("Ajay")

print("Accessing P1 - m1 module ")

print( MyPkg.P1.m1.Employee["name"])

print("Accessing P1 - m2 module ")

 print( "Sum : ", MyPkg.P1.m2.sum(20,20))

print("Accessing P1 - m2 module ")

print( MyPkg.P1.m2.Employee["name"])

Output
Objects in P1 - m1 module
['Employee', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__',
'__package__', '__spec__', 'show']

Objects in P1 - m2 module
['Employee', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__',
'__package__', '__spec__', 'sum']

Accessing P1 - m1 module
Name : Ajay

Accessing P1 - m1 module
Ajay M1

Accessing P1 - m2 module
Sum : 40

Accessing P1 - m2 module
Vijay M2

In this output , “Employee” & “show” exists in Module-m1 and

“Employee” & “sum” exists in Module –m2.
Employee object exists in both Module(m1,m2) , but it is not colliding with each other , due to
separate namespace.

Renaming Module
To import the package “D:\Mykg\P1\m1” and rename it as“M1” for using in the program file.

import sys
sys.path.append("D:\\")

import MyPkg.P1.m1 as M1
import MyPkg.P1.m2 as M2

print("Accessing P1 - m1 module ")

M1.show("Ajay")

print("Accessing P1 - m1 module ")

print( M1.Employee["name"])
 print("Accessing P1 - m2 module ")
print( "Sum : ", M2.sum(20,20))

print("Accessing P1 - m2 module ")

print( M2.Employee["name"])

Output
Accessing P1 - m1 module
Name : Ajay

Accessing P1 - m1 module
Ajay M1

Accessing P1 - m2 module
Sum : 40
Accessing P1 - m2 module
Vijay M2

Using the dir( ) function

This function is used to list all the functions or variables defined in the Package imported.
import sys
sys.path.append("D:\\")
import MyPkg.P1.m1 as M1
import MyPkg.P1.m2 as M2

print("Objects in P1 - m1 module ")

print( dir(M1))
print( M1.__file__)
print( M1.__name__)
print("Objects in P1 - m2 module ")
print( dir(M2))
print( M2.__file__)
print( M2.__name__)

Output
Objects in P1 - m1 module
['Employee', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__',
'__package__', '__spec__', 'show']
D:\MyPkg\P1\m1.py
MyPkg.P1.m1

Objects in P1 - m2 module
 ['Employee', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__',
'__package__', '__spec__', 'sum']
D:\MyPkg\P1\m2.py
MyPkg.P1.m2
In this, Employee and show is defined in the “m1” module and
Employee and sum is defined in the “m2” module and
Remaining is the system defined.

Packages

Module m1.py
Employee={ "name":"Ajay M1", "age":27, "salary":30000}
def show(name):
print("Name :", name)

Module m2.py
Employee={ "name":"Vijay
me":"Vijay M2", "age":27, "salary":30000}
def sum(x,y):
return(x+y)

Module m3.py
def show(name,age):
print("Name :", name)
print("Age :", age)
Employee={ "name":"Ajay M3", "age":27, "salary":30000}

Module m4.py
def mul(x,y):
 print("sum : ", x*y)

Employee={ "name":"Vijay M4", "age":27, "salary":30000}

Using the from …import

 This is used to import the part of the Package as required.
 If the module from the package is imported using the “from..import” syntax, then
module name is not used before the function or variable imported, as applicable in DOT
Notation.
 For example if show( ) is imported from P1.m1 module, we use show( ) instead of
P1.m1.show( ).

Example-1

import sys
sys.path.append("D:\\")

from MyPkg.P1.m1 import show

from MyPkg.P1.m2 import sum

print("Objects loaded in Memory")

print(dir())

print("Accessing P1 - m1 module ")

show("Ajay")

print("Accessing P1 - m2 module ")

print( "Sum :", sum(20,20))
print("\n Accessing Variable from Module\n")
print(Employee["name"]) # This is not accessible, as not imported.

Output

Objects loaded in Memory

['__annotations__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__',
'__package__', '__spec__', 'show', 'sum', 'sys']

Accessing P1 - m1 module
Name : Ajay

Accessing P1 - m2 module
Sum : 40
 Accessing P1 - m1 module
Traceback (most recent call last):
File "D:\Python38\p3.py", line 17, in <module>
print( Employee["name"])
NameError: name 'Employee' is not defined

Example-2
import sys
sys.path.append("D:\\")

from MyPkg.P1.m1 import Employee

from MyPkg.P1.m2 import Employee

print("Objects loaded in Memory")

print(dir())
print("Accessing P1 - m1 module ")
print( Employee["name"])

print("Accessing P1 - m2 module ")

print( Employee["name"])

Output
Objects loaded in Memory
['Employee', '__annotations__', '__builtins__', '__doc__', '__file__', '__loader__',
'__name__', '__package__', '__spec__', 'sys']

Accessing P1 - m1 module
Vijay M2

Accessing P1 - m2 module
Vijay M2

In this, Employee object is present in both the modules (m1 and m2), so the Employee object
from the module-m2 replaces Employee from the module-m1. Thus, output is same in above
case. To resolve this issue, follow the following example

Example-3

import sys
sys.path.append("D:\\")

from MyPkg.P1.m1 import Employee as E1

 from MyPkg.P1.m2 import Employee as E2

print("Objects loaded in Memory")

print(dir( ))
print("Accessing P1 - m1 module ")
print( E1["name"])

print("Accessing P1 - m2 module ")

print( E2["name"])

Output
Objects loaded in Memory
['E1', 'E2', '__annotations__', '__builtins__', '__doc__', '__file__', '__loader__',
'__name__', '__package__', '__spec__', 'sys']

Accessing P1 - m1 module
Ajay M1

Accessing P1 - m2 module
Vijay M2

Importing all the Modules using from…import *

 It can be used to import all the modules from the package.
 If the module is imported using the “from...import” syntax, then module name is not
used before the function or variable imported.
 For module , import * allows importing all the objects defined in the module.
 For Package, import * does not import anything. It will allow importing, only if the
__init__.py file is present in the folder and __all__ is defined in it.

Content of __init__.py file present in the “D:\MyPkg\P1” folder

__all__=["m1","m2"]

Example-1
import sys
sys.path.append("D:\\")
from MyPkg.P1 import *
print("Objects loaded in Memory")
print(dir())
 print("Accessing P1 - m1 module ")
print( m1.Employee["name"])

print("Accessing P1 - m2 module ")

print( m2.Employee["name"])

Output
Objects loaded in Memory
['__annotations__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__',
'__package__', '__spec__', 'm1', 'm2', 'sys']
Accessing P1 - m1 module
Ajay M1
Accessing P1 - m2 module
Vijay M2
Example-2
#__init__.py file not present in D:\MyPkg\P2 folder

import sys
sys.path.append("D:\\")

from MyPkg.P2 import *

print("Objects loaded in Memory")

print(dir())

print("Accessing P1 - m1 module ")

print( m3.Employee["name"])

print("Accessing P1 - m2 module ")

print( m4.Employee["name"])

Output

Objects loaded in Memory

['__annotations__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__',
'__package__', '__spec__', 'sys']

Accessing P1 - m1 module
Traceback (most recent call last):
File "D:/Python38/p4.py", line 12, in <module>
print( m3.Employee["name"])
NameError: name 'm3' is not defined