How do absolute import and relative import differ?

While absolute import entails the path from a project's root folder to the desired module, relative import entails the path starting from the path of the current module to the desired module.

What are the types of relative imports?

The two types of relative imports are implicit relative imports and explicit relative imports.

Which type of relative import does Python 3.x support?

Python 3.x supports explicit relative imports.

What are the types of modules in Python?

Built-in and user-defined modules are the two types of modules in Python.

When should you use relative import?

You should use relative import when you are alone working on a Python project or when the module is in the same directory where you are importing the module.

Absolute vs Relative Imports in Python

When you work on a big Python project, you will be dividing the Python code into multiple Python files. This splitting of code into multiple files gives a modular look to the project, and it is one of the best ways to write clean code.

Mostly, all the top Python libraries are written using multiple Python files known as Python modules and reside in multiple directories or folders known as Python packages . The Python import statement makes it easy for Pythonistas to use the code of one Python file in another.

However, still many Python beginner and intermediate learners find the import statement confusing and do not know the difference between relative and absolute imports in Python (absolute vs relative imports).

Here in this Python tutorial, we will walk you through the Python import statement and discuss the difference between relative and absolute imports.

What is Import in Python?

import is a Python keyword that is used for importing code in the current Python script. The Python import statement is generally used when we want to access another Python file, Python module, or Python package in the current script.

For instance, suppose you want to use the Python math module to round off a floating-point number to a whole number . First, you need to import the math module in your current script before using the floor() and ceil() methods.

Example #error

>>> num = 39.7
>>> math.floor(num)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'math' is not defined

If you do not import the module you wish to use in your Python script, then Python will throw a NameError . Example

>>> import math
>>> num = 39.7
>>> math.floor(num)
39

The import statement will add the module object to the current scope of your program. So if you want to use the imported module throughout any section of the program, you need to mention the import statement at the top of your Python program or script.

How Does The Import Statement Work?

The import statement goes through a lot behind the scenes. First, the import statement looks for the module or package in the sys.modules . The sys.module section stores all the previous imported code, and it is like cached storage for already imported modules.

If the import does not find the module or package in the sys.module section, it starts searching through the Python Standard Libraries. Still, if the import does not find the module in the Python Standard Libraries , it starts searching the same in the installed libraries section or system.path .

Even if the import statement is not able to find the module or package, it throws a ModuleNotFoundError. The search for import search starts from your current directory, and then it goes to the Python built-in Standard Libraries, and at last look for the same in the installed libraries.

Import Statement Syntax

Generally, we mention the import statement at the top of our Python program or script, so we can access the module from any section of the program. Names of modules and packages are case-sensitive, and thus, make sure you are writing the correct name.

import module_name

import package_name

The import statement imports the complete module or packages to your current Python program or script. However, Python also provides the from statement that works along with import . This makes the import statement sophisticated.

from package_name import module
or

from module_name import module_function

Example

#import module
>>> import math
>>> num = 34.88
>>> math.floor(num)
34

#from module import module function
>>> from math import floor
>>> num =35.9
>>> floor(num)
35

#from module import all functions or submodule
>>> from math import *
>>> num =48.37
>>> ceil(num)
49

Types of Python Imports

You can use two different types of import statements to import a module or package to your current Python program. These are:

Absolute Imports
Relative Imports

1. Python Absolute Imports

In the Python absolute import, we include the absolute path of the module from its root directory or folder. To separate every subdirectory or module, we use the period symbol (.). Absolute imports are generally used when we only want to import specific functions or sub-modules from modules or packages.

Syntax

??? project
|   ??? package_A
|   ?   ??? __init__.py 
|   ?   ??? module_A.py
|   ?   ??? module_B.py
|   ??? package_B
|      ??? __init__.py
|      ??? module_C.py
|      ??? module_D.py
|      ??? subpackage_A
|          ??? module_E.py

For instance, if you want to access a method function_E that is written inside the module_E, you need to specify the absolute path to module_E.py and grab the function_E method. For example:

from project.pakage_B.subpackage_A.module_E import function_E.

Using the same syntax, you can access any module and package of the project.

Pros of Absolute Import

Absolute imports are clean and give a brief idea about the method or module you want to use.
It also becomes easy for the interpreter to directly look for the specified module.

Cons of Absolute Import

In some cases, the absolute import becomes quite long because of subfolders or modules. And this could expand the import statement into two lines.
In absolute importing, you have to be careful while mentioning the root folder. If you are in the subfolder, then the above folder will be your root folder.

2. Python Relative Imports

In relative imports, we mention the import statement relative to the location of the current Python program or where we are using the import statement.

Syntax

??? project1
|   ??? package_A
|   ?   ??? __init__.py 
|   ?   ??? module_A.py
|   ?   ??? module_B.py
|   ?   ??? CurrentProgram.py
|   ??? package_B
|      ??? __init__.py
|      ??? module_C.py
|      ??? module_D.py
|      ??? subpackage_B
|          ??? module_E.py
|------project2

Suppose you are at CurrentProgram.py , and you want to access the function_B method from module_B.py . So, instead of using the absolute import, it would be a great practice to use the relative import because CurrentProgram.py and module_B.py are in the same location. In relative import, we use the (.) dot notation to represent the current directory. #CurrentProgram.py

from .module_B import function_B

Access the module_E method function_E from module_C . #package_B/module_C

.subpackage_B.module_E import function_E

Pros of Relative Import

For small projects where you are not using many sub-folders, relative import provides a cleaner way to import Python modules .
The relative import rarely gets too long.

Cons of Relative Import

If you are working on a project with multiple subfolders, their relative import could get messy.
For shared projects, relative imports are hard to read.