How to import a Python module given the full path?
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
Python3
# class class GFG: # method def method_in(): print ( "Inside Class method" ) # explicit function def method_out(): print ( "Inside explicit method" ) |
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.
Python3
# importing module import sys # appending a path sys.path.append( 'articles' ) # importing required module import gfg from gfg import GFG # accessing its content GFG.method_in() gfg.method_out() |
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.
Python3
import importlib.util # specify the module that needs to be # imported relative to the path of the # module spec = importlib.util.spec_from_file_location( "gfg" , "articles/gfg.py" ) # creates a new module based on spec foo = importlib.util.module_from_spec(spec) # executes the module in its own namespace # when a module is imported or reloaded. spec.loader.exec_module(foo) foo.GFG.method_in() foo.method_out() |
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.
Python3
from importlib.machinery import SourceFileLoader # imports the module from the given path foo = SourceFileLoader( "gfg" , "articles/gfg.py" ).load_module() foo.GFG.method_in() foo.method_out() |
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.
Python3
# main.py module_name = "gfg" module_path = "./articles/gfg.py" # Using exec() to dynamically load the module with open (module_path, "r" ) as file : code = compile ( file .read(), module_path, 'exec' ) exec (code) # Now you can use the imported module gfg_module = globals ()[module_name] # Example usage gfg_module.some_function() |
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.
Python3
import imp # Specify the path to the gfg.py module module_path = './articles/gfg.py' # Load the module using imp.load_source gfg_module = imp.load_source( 'gfg' , module_path) # Now you can use the functions or variables defined in gfg.py gfg_module.some_function() |
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()`).
Python3
import importlib.util # Specify the path to gfg.py module_path = './articles/gfg.py' module_name = 'gfg_module' # You can choose any name for the module # Create a spec for the module module_spec = importlib.util.spec_from_file_location(module_name, module_path) # Load the module from the spec gfg_module = importlib.util.module_from_spec(module_spec) module_spec.loader.exec_module(gfg_module) # Now you can use the gfg_module as if it were imported normally gfg_module.some_function_in_gfg() |
Output
Inside Class method
Inside explicit method
Contact Us