Python append to import path

How to Use Sys.path.append() in Python

Sys.path is a list of directories where the Python interpreter searches for modules. Mind you, this is a list! When a module is claimed in a project file, it will search through each one of the directories in the list. If the module is located within one of those directories, then everything goes fine and your project is successfully rendered. However, if the module is not located within any of the listed directories, then your project will fail lest you can “append” the directory where your module is located to the list using the append() function. In this tutorial, we’ll be learning about how to use sys.path.append() in Python.

List Current Path

By declaring the following, we can check the current Python path:

from pprint import pprint

Here, the pprint module is just used to make things look pretty, so you can ignore that part, and concentrate on the rest. All we’re trying to do here is to print out sys.path.

What you notice here is that first of all, it’s a list. So according to the list, it will first look in the current working directory, then in other directories one by one. The current working directory is the directory in which the main python script – the one being executed – is found. Further, what this also means is that this list can be modified or edited.

Adding a Path

The sys.path.append() method is used specifically to add a Path to the existing ones.

Suppose now that I have two distinct files: main.py, and file1.py. Main.py is the main file, and we’re going to try to import file1.py (a module that we wrote).

Because file1.py or our module is within the working directory, you should be able to successfully print out the secret sentence. This is so because when the Python interpreter searches for the requested module, it will search in the working directory first and because our module called file1 is within the working directory, it will automatically print out our secret sentence.

Now, suppose that I create a directory within my working directory called “directory1” and place my module called file1 within it.

Now, within the module file1 is the secret phrase that we’re trying to print out. In this case, it will not print out the secret phrase. Why? Because the interpreter isn’t looking in “directory1” for any modules. In other words, the current working directory is a member of the list of sys.path but “directory1” is not a member of that list. So, the resulting error is a ModuleNotFound Error – it couldn’t find or locate the module called file1.

In order to avert this problem, you need to tell the Python interpreter where to look for the module file1. This is where the sys.path.append() method comes in.

The sys.path.append() method is used to append the path that we want to the existing list.

On a Windows system, you’d write:

Please note that you cannot add any given file to sys.path, instead you may add directories, and then import the files you want.

Example #1

So, let’s try the previous operation (where the file1 module is located within directory1) again but this time, we’ll append the path to the file1 module to sys.path using the sys.path.append() method.

sys . path . append ( ‘C:\\Users\\never\\PycharmProjects\\

When we append the path using the sys.path.append() method, we first append the location of the module to Path, and then import it. If done in such a manner, the Python interpreter should be able to locate the requested module, and therefore retrieve the secret variable.

The output of the previous operation is as follows:

Example #2

Let’s take another example, this time on a Linux machine. Let’s suppose that we have one file – main.py.

from pprint import pprint

Here, sys.path[0] is “/home/kalyani” because that is where main.py is located.

Now, let’s modify the script a little bit by using the sys.path.append() method. Let’s use the method to append a particular path (‘/home/kalyani/directory1’) to sys.path.

from pprint import pprint

sys . path . append ( ‘/home/kalyani/directory1’ )

So, the sys.path.append() method has appended the path to the end of the existing list! Here, please also note that the appending is done at the end of the list not at the beginning.

PYTHONPATH

There is one tiny little problem with what we just did and that is that we didn’t permanently put that location onto the sys.path list. The sys.path.append() method is used to temporarily add a path and as such, that path would be valid for a session for example. If you’d like to permanently alter the sys.path list, then we can use PYTHONPATH to add the path to the list. Since sys.path also looks into PYTHONPATH, the locations listed will then be included in the list of paths.

1. On your Linux machine, open up a terminal, and navigate to the folder containing .bashrc.
2. nano .bashrc
3. Add the following at the end of the .bashrc file:

Here, you can add the path that you want.

1. Close the terminal, and open up a new terminal
2. Now, try executing your program. In my case, it will be the following:

from pprint import pprint

When writing complex programs in Python, we will eventually add third party modules or even better, create our own modules. In all cases, we cannot keep every single Python file we create in one directory, we may wish to use multiple directories to adequately classify our files. The problem however is that we may need to import our created modules left and right. In such cases, if we want to prevent a ModuleNotFound Error, then we can add the location of the directory – and mind you, it has to be a directory, not a file – to sys.path using the sys.path.append() method.

Источник

How to Import Modules From Another Folder in Python?

When working on a Python project, you may need to import modules from another folder. For example, to add additional directories to Python for new user-defined modules and packages. There are several ways to import modules from another folder, such as adding a module path to the system path using various functions, using the importlib module, etc.

The following methods are provided to help you to import modules in Python from another folder:

• Method 1: Using sys.path.append()
• Method 2: Using sys.path.insert()
• Method 3: Using the Relative Path to the Module
• Method 4: Using importlib Module

Prerequisites:

The following folder/directory structure is used for this specific post:

The “sub_module.py” Python file (module) contains the various functions.

Module FIle: sub_module.py

The function defined in the file named “sub_module.py” is shown below:

def add(a, b): return a+b def sub(a, b): return a-b def mul(a, b): return a*b def div(a, b): return a/b

Now, we will create another file in which we try to import the previously created module.

Main File: main.py

In the main file, the “sub_module” is imported at the program’s start.

import sub_module # calling sub_module functions print("Addition of two number is :", sub_module.add(2, 2)) print("Subtraction of two number is :", sub_module.mul(2, 2))

The above code throws an error because the module is directly imported from another folder which is not possible.

To solve this issue, Python uses different methods to import modules from another folder.

Method 1: Using the sys.path.append()

The “sys.path.append()” method can be utilized to append a specific/particular path for a Python interpreter to search. The below code uses the “sys.path.append()” function to add the module path to the system path:

import sys sys.path.append(r'C:\Users\p\Documents\program\SUB') import sub_module # calling sub_module functions print("Addition of two number is :", sub_module.add(2, 2)) print("Multiplication of two number is :", sub_module.mul(2, 2))

• The module named “sys” is imported at the start of the program.
• The “sys.path.append()” function takes the path of the module folder as an argument and adds it to the list of paths stored in “sys.path”.
• After adding the path, now we can import the module of another folder using the import keyword and apply various functions.

The functions of the modules stored in another folder have been applied successfully.

Method 2: Using the sys.path.insert()

The “sys.path.insert()” function is used to insert the path of the specific directory to the list of directories of Python.

The syntax of sys.path.insert() is shown below:

The index is where you want to insert the path, and the path is the directory path you want to include. Let’s import the module from another directory using the below code:

import sys sys.path.insert(1, r'C:\Users\p\Documents\program\SUB') import sub_module # calling sub_module functions print("Subtraction of two number is :", sub_module.sub(2, 2)) print("Division of two number is :", sub_module.div(2, 2))

• The module named “sys” is imported at the start.
• The “sys.path.insert()” function takes the index and the complete path as an argument and adds the path to the system.
• After adding now, we can import the module using the keyword “import.”
• Lastly, the module’s function named “sub_module” is called on the given value.

The function returns the subtraction and division of two numbers.

Method 3: Using the Relative Path to the Module

A relative path describes/represents the location of a file or a directory relative to the current/present working directory. The relative path to the module is used in the below code to import the modules from another folder:

from SUB import sub_module # calling sub_module functions print("Subtraction of two number is :", sub_module.sub(2, 2)) print("Division of two number is :", sub_module.div(2, 2))

• The “from SUB import sub_module” is used to import the sub_module from the folder “SUB”.
• The sub() and div() function of the module named “sub_module” is used to find the subtraction and division of the given numbers.

The function of the imported module has returned the values.

Method 4: Using the importlib Module

The importlib package provides the importlib.util module to import the module from the specified path. Here is an example code:

import importlib.util as iu path = r'C:\Users\p\Documents\program\SUB' name = 'sub_module' spec = iu.spec_from_file_location(name, path + '\\' + name + '.py') my_lib = iu.module_from_spec(spec) spec.loader.exec_module(my_lib) print('Addition of Number: ',my_lib.add(5,3)) print('Multiplication of Number: ',my_lib.mul(5,3))

• The code first creates a module specification object by calling the “spec_from_file_location()” function by accepting the name and path of the module file.
• Then, it creates a module object by calling “importlib.util.module_from_spec(spec)” with the specification object.
• Next, it executes the module code by calling “spec.loader.exec_module(module)” with the module object.
• Finally, the function named “add()” and “mul()” is applied on the given value.

The function has been called successfully.

Conclusion

To import modules from another folder, the “sys.path.append()”, “sys.path.insert()”, “relative path to the module,” and “importlib” module is used in Python. The “sys.path.append()” and “sys.path.insert()” is used to add the specified module path to the Python path of directories. The relative path of the module is used to import the specified module from the subdirectory.

This guide has presented various methods to import the modules from another folder using numerous examples.

Источник