How to import a Python module given the full path? - GeeksforGeeks (2024)

The Python module is a file consisting of Python code with a set of functions, classes, and variable definitions. The module makes the code reusable and easy to understand. The program that needs to use the module should import that particular module. In this article, we will discuss how to import a Python module given its full path.

Different Ways to Import Python Files

Various methods can be used to import the module by using its full path. here we are using some generally used methods for importing python files in Python those are following.

• Using sys.path.append() Function
• Using importlib Package
• Using SourceFileLoader Class
• Using exec() Function
• Using imp Module
• Using importlib.util.spec_from_file_location()

Consider the following file arrangement and let’s see how the above-listed methods can be used to import gfg.py module in main.py:

python
 |--main.py
 |articles
 |--gfg.py 

Below is the code for gfg.py

Import Python File Using sys.path.append() Function

This is the easiest way to import a Python module by adding the module path to the path variable. The path variable contains the directories Python interpreter looks in for finding modules that were imported in the source files.

Syntax :

sys.path.append(“module_path”)

In this example Python code adds the ‘articles’ directory to the system path, allowing the import of the ‘gfg’ module. It then calls the ‘method_in’ from the ‘GFG’ class and ‘method_out’ from the ‘gfg’ module.

Output:

Inside Class method
Inside explicit method

Import Python File Using importlib Package

The importlib package provides the implementation of the import statement in Python source code portable to any Python interpreter. This enables users to create their custom objects which helps them to use the import process according to their needs. The importlib.util is one of the modules included in this package that can be used to import the module from the given path.

Syntax:

module = importlib.util.spec_from_file_location(“module_name”, “module_path”)

In this example This code dynamically imports a module named “gfg.py” located in the “articles” directory, creates a new module object, and then executes methods “method_in” and “method_out” from the imported module “foo.GFG” and “foo,” respectively.

Output:

Inside Class method
Inside explicit method

Import Python File Using SourceFileLoader Class

SourceFileLoader class is an abstract base class that is used to implement source file loading with help of load_module() function which actually imports the module.

Syntax :

module = SourceFileLoader(“module_name”,”module_path”).load_module()

In this example code uses the `SourceFileLoader` from `importlib.machinery` to dynamically import a module named “gfg” from the file “articles/gfg.py”. It then calls the method `method_in()` from the class `GFG` within the imported module and the function `method_out()` from the imported module.

Output:

Inside Class method
Inside explicit method

Import Python File Using exec() Function

The `exec()` function in Python is a built-in function used for dynamic execution of Python code. It takes a string as input, interprets it as a sequence of Python statements, and executes them. This allows for runtime code generation and flexibility .

Syntax :

exec(code, globals=None, locals=None)

In this example code in `main.py` dynamically loads the “gfg.py” module using the `exec()` function. It reads the content of the file, compiles it, and executes it, allowing access to the module’s functions. Finally, it demonstrates usage by calling the “some_function()” from the dynamically imported “gfg.py” module.

Output :

Inside Class method
Inside explicit method

Import Python File Using imp Module

The imp module in Python provides tools for working with modules, such as dynamically loading them. One common use is for importing modules based on a string name. The imp module has been replaced by the importlib module in newer Python versions.

In this example the below code uses the deprecated `imp` module to dynamically load the `gfg.py` module from the specified path and then invokes the function `some_function()` from that module.

Output :

Inside Class method
Inside explicit method

Using importlib.util.spec_from_file_location()

The importlib.util module provides functions for working with the import system. The spec_from_file_location() function can be used to create a module specification from a file location, and module_from_spec() can be used to create a module from the specification.

Syntax :

spec = importlib.util.spec_from_file_location(module_name, file_path)

In this example code dynamically imports a module (`gfg.py`) using `importlib.util`, specifying the file path and a chosen module name. It creates a module specification, loads the module from the specification, and then allows the use of functions from the dynamically imported module (`gfg_module.some_function_in_gfg()`).

Output

Inside Class method
Inside explicit method