In this article we are going to learn about python modules. How to a write a python module. Different ways of importing a python module into a program. Most commonly used built-in python modules and how search path works.


What is python module?

Python module is a python file containing python definitions and executable statements. Biggest advantage of python module is we can use any python program readily into our program without actual copying the code definitions.

When a program gets bigger then it becomes very difficult to organize and maintain it. So we may want to split it into a different manageable and organized files. This breaking down of python code into different files is made possible by python modules.

Splitting of a big single python program into separate python modules helps us in many ways like;

  • It becomes easy to read the code and understand it.
  • Maintenance of neatly grouped code is easy.
  • Python module makes easy re-usability of frequently used code. We can group frequently used code into a module. So next time instead of copying the actual code definition into a program, we can just import the module.
  • Also there are many python built-in modules available which can be used into our code.
How to a write a python module. Different ways of importing a python module into a program. Most commonly used built-in python modules and how search path works.

Write a python module:

Python module is nothing but a python file with definitions and executable statements in it.

Suppose we are having a python file named “custom_module.py” with some python definitions in it, Then the file (custom_module.py) will be called as module and the name of module will be name of file (custom_module).

So for learning purpose let’s create a sample module file which performs basic mathematical operations. Save it with name “basic_math_operations.py

# Function "addition" performs addition of two numbers a and b and returns the sum it to its caller.
def addition(a, b):
add = a + b
return add

def subtraction(a, b):
sub = a - b
return sub

def multiplication(a, b):
multiply = a * b
return multiply

def division(a, b):
divide = a / b
return divide

We have written our first module “basic_math_operations.py” so the name of module becomes “basic_math_operations“.


How to import a python module?

For importing any module in a file just write keyword “import “followed by the name of the module.

Now let’s try to import module “basic_math_operations.py” in a new python file and try to use the function “addition” from imported module.

import basic_math_operations
Result = basic_math_operations.addition(5, 8)
print(Result)

#Output: 13

How to access the functions from a python module?

In above example we have imported “basic_math_operations” by using import keyword. Now by using module name along with dot operator we can access the functions from imported module.

So the construct for accessing a function from imported module is “module name.function name“. In above example to access addition function we have written “basic_math_operations.addition(5, 8)“.

Rename a module while importing:

While importing a module, instead of importing it with its actual name we can create an alias (rename) for it. To create an alias (rename) for a module while importing we have to use “as” keyword.

There is no difference in behavior if we rename a module while importing. Only benefit of renaming is to save the typing time.

import basic_math_operations as basicMath
print(basicMath.addition(5, 8))

#Output:
13

Here we have imported module named “basic_math_operations” with a new name as “basicMath“.

After creating an alias it is mandatory to use the alias only. We are not supposed to use the original module name. Due to this fact “basic_math_operations.addition()” becomes an invalid statement. Correct statement is “basicMath.addtion()“.

Import only required statements from module:

Sometimes instead of importing complete module into a program we may want to import only the required statements. We can do so by using following syntax;

from <name of module> import <statement>

from basic_math_operations import multiplication, division

# Valid statements
print(multiplication(5, 4))
print(division(12, 4)

# Invalid statement since we haven't imported addition function from basic_math_operations module.
print(addition(9, 6))

Here from the basic_math_operations.py module we have imported only two functions i.e multiplication, division.

In above example though “addition()” function is present in “basic_math_operations” module but since we have’t imported it in our program so we’ll not be able to use it. It will not be able to identify the “addition()” function and will show us a ‘NameError’.

Import all names:

We can import all the definitions from a module using “*” (asterisk).

from basic_math_operations import *

print(multiplication(5, 4))
print(division(12, 4)
print(addition(9, 6))

#output:
20
3.0
15

Use of asterisk after import keyword imports all the definitions and statements from module except those beginning with underscore “_” character.

This is not a good programming practice to import all the module definitions using asterisk (*). It makes code poorly readable.


Python built-in modules:

In python there are many built-in python modules available which we can use readily. You can check the complete python built-in modules list here. These modules are present in your python installation directory\lib location.

These built-in modules can be imported in same way like we have imported our custom module.

Let’s see one example of how we can import and use python built-in module. Here we are going to import the python built-in “calendar” module and check if the year is leap year or not.

import calendar
print(calendar.isleap(2019))
print(calendar.isleap(2020))

#Output:
False
True

In above sample program, Statement “import calendar” imports the calendar module into our program. Within the calendar module “.isleap()” function available to check if the year is a leap year or not. this functions returns the result into a Boolean format i.e if the year is leap it return “True” otherwise it returns the value “False”.


Python module search path:

Until now we have seen how to import a module in python program. But we have nowhere mentioned about the location of module file. We have just mentioned the “import” keyword followed by the module name. So how python interpreter finds the module file to import all the definitions from it.

There are several locations in which python interpreter search for the module. These locations are known as search paths.

Suppose we have imported a module “basic_math_operations“, So the interpreter first checks for this module in built-in module directory. If not found then it start to search for ” basic_math_operations.py” file into the list of directories defined by environment variable sys.path

sys.path variable has following locations by default:

  • The directory containing the input script (or the current directory when no file is specified).
  • PYTHONPATH (a list of directory names, with the same syntax as the shell variable PATH).
  • The installation-dependent default.

In sys.path we can add our own path in as well.


Reloading a module during execution:

Python interpreter imports the module only once during the program execution. Even if we write the multiple import statements for a single module, Interpreter imports the module only once.

Now we are facing a problem here, We have imported a module which gets changed during the course of program execution and we want to import these changes as well. Since re-importing of a module is not possible.

To solve this issue python has provided a way. There is a “reload()” function available in “importlib” module (Earlier known as “imp” module).
As the name suggest function “reload()” performs reloading of specified module during course of program execution.

import importlib
import basic_math_operations

print(Test.multiplication(5, 4))
print(Test.division(12, 4))

importlib.reload(basic_math_operations)

print(Test.addition(9, 6))

Built-in dir() function

Python built-in “dir()” function is used to find out the names of definitions present inside the imported modules.

import basic_math_operations
print(dir(basic_math_operations))

#Output:
__builtins__
__cached__
__doc__
__file__
__loader__
__name__
__package__
__spec__
addition
division
multiplication
subtraction

We can see that, “dir()” function returns us all the names present in a module. All the names those starts and ends with double underscore (_) character are the python default attributes.

Continue Reading:

Share this Post

Leave a Comment

Your email address will not be published.