Python Modules

Python Programming Training Certification

Flexible Hours

100 Assignments

Instructor Led online Training

50 LMS Access

24X7 Support

100% Skill Level

Enquire Now

4.9 out of 1000+ Ratings
Best Python Institute for Learning Python Course & Training, Live Project Training in Python with Django, Data Science and AI, Interview Assistance, Expert Coaching Trainers. Python Certification & Interview Assistance! Get free demo now!

Course Overview

Python is one of the world’s top programming languages used today and Python training has become the most popular training across individuals. Training Basket’s Python Training & Certification course covers basic and advanced Python concepts and how to apply them in real-world applications.Python is a flexible and powerful open-source language that is easy to learn and consists of powerful libraries for data analysis and manipulation. Our Python training course content is curated by experts as per the standard Industry curriculum. The curriculum, coding challenges and real-life problems cover data operations in Python, strings, conditional statements, error handling, shell scripting, web scraping and the commonly used Python web framework Django. Take this Python training and certification course and become job-ready now.

Python Modules

A python module can be defined as a python program file which contains a python code including python functions, class, or variables. In other words, we can say that our python code file saved with the extension (.py) is treated as the module. We may have a runnable code inside the python module.

Modules in Python provides us the flexibility to organize the code in a logical way.

To use the functionality of one module into another, we must have to import the specific module.


In this example, we will create a module named as which contains a function func that contains a code to print some message on the console.

Let’s create the module named as

  • #displayMsg prints a message to the name being passed.
    def displayMsg(name)
    print(“Hi “+name);

Here, we need to include this module into our main module to call the method displayMsg() defined in the module named file.

Loading the module in our python code

We need to load the module in our python code to use its functionality. Python provides two types of statements as defined below.

  1. The import statement
  2. The from-import statement

The import statement

The import statement is used to import all the functionality of one module into another. Here, we must notice that we can use the functionality of any python source file by importing that file as the module into another python source file.

We can import multiple modules with a single import statement, but a module is loaded once regardless of the number of times, it has been imported into our file.

The syntax to use the import statement is given below.

  • import module1,module2,…….. module n

Hence, if we need to call the function displayMsg() defined in the file, we have to import that file as a module into our module as shown in the example below.


  • import file;
    name = input(“Enter the name?”)


  • Enter the name?John
    Hi John

The from-import statement

Instead of importing the whole module into the namespace, python provides the flexibility to import only the specific attributes of a module. This can be done by using from? import statement. The syntax to use the from-import statement is given below.

  • from < module-name> import <name 1>, <name 2>..,<name n>

Consider the following module named as calculation which contains three functions as summation, multiplication, and divide.

  • #place the code in the
    def summation(a,b):
    return a+b
    def multiplication(a,b):
    return a*b;
    def divide(a,b):
    return a/b;

  • from calculation import summation
    #it will import only the summation() from
    a = int(input(“Enter the first number”))
    b = int(input(“Enter the second number”))
    print(“Sum = “,summation(a,b)) #we do not need to specify the module name while accessing summation()


  • Enter the first number10
    Enter the second number20
    Sum = 30

The from…import statement is always better to use if we know the attributes to be imported from the module in advance. It doesn’t let our code to be heavier. We can also import all the attributes from a module by using *.

Consider the following syntax.

  • from <module> import *

Renaming a module

Python provides us the flexibility to import some module with a specific name so that we can use this name to use that module in our python source file.

The syntax to rename a module is given below.

  • import <module-name> as <specific-name>


  • #the module calculation of previous example is imported in this example as cal.
    import calculation as cal;
    a = int(input(“Enter a?”));
    b = int(input(“Enter b?”));
    print(“Sum = “,cal.summation(a,b))


  • Enter a?10
    Enter b?20
    Sum = 30

Using dir() function

The dir() function returns a sorted list of names defined in the passed module. This list contains all the sub-modules, variables and functions defined in this module.

Consider the following example.


  • import json

    List = dir(json)



  • [‘JSONDecoder’, ‘JSONEncoder’, ‘__all__’, ‘__author__’, ‘__builtins__’, ‘__cached__’, ‘__doc__’,
    ‘__file__’, ‘__loader__’, ‘__name__’, ‘__package__’, ‘__path__’, ‘__spec__’, ‘__version__’,
    ‘_default_decoder’, ‘_default_encoder’, ‘decoder’, ‘dump’, ‘dumps’, ‘encoder’, ‘load’, ‘loads’, ‘scanner’]

The reload() function

As we have already stated that, a module is loaded once regardless of the number of times it is imported into the python source file. However, if you want to reload the already imported module to re-execute the top-level code, python provides us the reload() function. The syntax to use the reload() function is given below.

  • reload(<module-name>)

for example, to reload the module calculation defined in the previous example, we must use the following line of code.

  • reload(calculation)

Scope of variables

In Python, variables are associated with two types of scopes. All the variables defined in a module contain the global scope unless or until it is defined within a function.

All the variables defined inside a function contain a local scope that is limited to this function itself. We can not access a local variable globally.

If two variables are defined with the same name with the two different scopes, i.e., local and global, then the priority will always be given to the local variable.

Consider the following example.


  • name = “john”
    def print_name(name):
    print(“Hi”,name) #prints the name that is local to this function only.
    name = input(“Enter the name?”)


  • Hi David

Python packages

The packages in python facilitate the developer with the application development environment by providing a hierarchical directory structure where a package contains sub-packages, modules, and sub-modules. The packages are used to categorize the application level code efficiently.

Let’s create a package named Employees in your home directory. Consider the following steps.

1. Create a directory with name Employees on path /home.

2. Create a python source file with name on the path /home/Employees.

  • def getITNames():
    List = [“John”, “David”, “Nick”, “Martin”]
    return List;

3. Similarly, create one more python file with name and create a function getBPONames().

4. Now, the directory Employees which we have created in the first step contains two python modules. To make this directory a package, we need to include one more file here, that is which contains the import statements of the modules defined in this directory.

  • from ITEmployees import getITNames
    from BPOEmployees import getBPONames

5. Now, the directory Employees has become the package containing two python modules. Here we must notice that we must have to create inside a directory to convert this directory to a package.

6. To use the modules defined inside the package Employees, we must have to import this in our python source file. Let’s create a simple python source file at our home directory (/home) which uses the modules defined in this package.

  • import Employees


  • [‘John’, ‘David’, ‘Nick’, ‘Martin’]

We can have sub-packages inside the packages. We can nest the packages up to any level depending upon the application requirements.

The following image shows the directory structure of an application Library management system which contains three sub-packages as Admin, Librarian, and Student. The sub-packages contain the python modules.

Python packages

Recently Trained Students

Jessica Biel

– Infosys

My instructor had sound Knowledge and used to puts a lot of effort that made the course as simple and easy as possible. I was aiming for with the help of the ZebLearn Online training imparted to me by this organization.

Richard Harris


I got my training from Zeblearn in the Python Certification Training, I would like to say that say he is one of the best trainers. He has not even trained me but also motivated me to explore more and the way he executed the project, in the end, was mind-blowing.

Candidate’s Journey During Our Training Program

Card image cap

Expert’s Advice & Selection of Module

Choosing the right type of module for the training is half the battle & Our Team of experts will help & guide you.

Card image cap

Get Trained

Get Trained & Learn End to End Implementation from our Expert Trainer who are working on the same domain.

Card image cap

Work on Projects

We Do make our student’s work on multiple case studies , scenario based tasks & projects in order to provide real-time exposure to them.

Card image cap


We have a dedicated placement cell in order to provide placement assistance & relevant interviews to our candididates till selection

Placement Partner


Leave your details


Download Course Content