Import a module from a relative path


How do I import a Python module given its relative path?

For example, if dirFoo contains and dirBar, and dirBar contains, how do I import into

Here’s a visual representation:


Foo wishes to include Bar, but restructuring the folder hierarchy is not an option.

Asked By: Jude Allred



Be sure that dirBar has the file — this makes a directory into a Python package.

Answered By: S.Lott

If you structure your project this way:


Then from you should be able to do:

import dirFoo.Foo


from dirFoo.Foo import FooObject

Per Tom’s comment, this does require that the src folder is accessible either via site_packages or your search path. Also, as he mentions, is implicitly imported when you first import a module in that package/directory. Typically is simply an empty file.

Answered By: bouvard

You could also add the subdirectory to your Python path so that it imports as a normal script.

import sys
sys.path.insert(0, <path to dirFoo>)
import Bar
Answered By: Andrew Cox

This is the relevant PEP:

In particular, presuming dirFoo is a directory up from dirBar…


from ..dirBar import Bar
Answered By: Peter Crabtree

The easiest method is to use sys.path.append().

However, you may be also interested in the imp module.
It provides access to internal import functions.

# mod_name is the filename without the .py/.pyc extention
py_mod = imp.load_source(mod_name,filename_path) # Loads .py file
py_mod = imp.load_compiled(mod_name,filename_path) # Loads .pyc file 

This can be used to load modules dynamically when you don’t know a module’s name.

I’ve used this in the past to create a plugin type interface to an application, where the user would write a script with application specific functions, and just drop thier script in a specific directory.

Also, these functions may be useful:

imp.find_module(name[, path])
imp.load_module(name, file, pathname, description)
Answered By: monkut

Add an file:


Then add this code to the start of

import sys
import Bar
Answered By: Josh

In my opinion the best choice is to put __ init in the folder and call the file with

from dirBar.Bar import *

It is not recommended to use sys.path.append() because something might gone wrong if you use the same file name as the existing python package. I haven’t test that but that will be ambiguous.

Answered By: jhana
import os
import sys
lib_path = os.path.abspath(os.path.join(__file__, '..', '..', '..', 'lib'))

import mymodule
Answered By: lefakir

Just do simple things to import the .py file from a different folder.

Let’s say you have a directory like:


Then just keep an empty file in lib folder as named

And then use

from import <Your Module name>

Keep the file in every folder of the hierarchy of the import module.

Answered By: Deepak 'Kaseriya'

Assuming that both your directories are real Python packages (do have the file inside them), here is a safe solution for inclusion of modules relatively to the location of the script.

I assume that you want to do this, because you need to include a set of modules with your script. I use this in production in several products and works in many special scenarios like: scripts called from another directory or executed with python execute instead of opening a new interpreter.

 import os, sys, inspect
 # realpath() will make your script run, even if you symlink it :)
 cmd_folder = os.path.realpath(os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0]))
 if cmd_folder not in sys.path:
     sys.path.insert(0, cmd_folder)

 # Use this if you want to include modules from a subfolder
 cmd_subfolder = os.path.realpath(os.path.abspath(os.path.join(os.path.split(inspect.getfile( inspect.currentframe() ))[0],"subfolder")))
 if cmd_subfolder not in sys.path:
     sys.path.insert(0, cmd_subfolder)

 # Info:
 # cmd_folder = os.path.dirname(os.path.abspath(__file__)) # DO NOT USE __file__ !!!
 # __file__ fails if the script is called in different ways on Windows.
 # __file__ fails if someone does os.chdir() before.
 # sys.argv[0] also fails, because it doesn't not always contains the path.

As a bonus, this approach does let you force Python to use your module instead of the ones installed on the system.

Warning! I don’t really know what is happening when current module is inside an egg file. It probably fails too.

Answered By: sorin
from .dirBar import Bar

instead of:

from dirBar import Bar

just in case there could be another dirBar installed and confuse a reader.

Answered By: jgomo3

Call me overly cautious, but I like to make mine more portable because it’s unsafe to assume that files will always be in the same place on every computer. Personally I have the code look up the file path first. I use Linux so mine would look like this:

import os, sys
from subprocess import Popen, PIPE
    path = Popen("find / -name 'file' -type f", shell=True, stdout=PIPE)[0]
    if not sys.path.__contains__(path):
except IndexError:
    raise RuntimeError("You must have FILE to run this program!")

That is of course unless you plan to package these together. But if that’s the case you don’t really need two separate files anyway.

Answered By: SuperFamousGuy

Here’s a way to import a file from one level above, using the relative path.

Basically, just move the working directory up a level (or any relative location), add that to your path, then move the working directory back where it started.

#to import from one level above:
cwd = os.getcwd()
below_path =  os.getcwd()
Answered By: Justin Muller

The quick-and-dirty way for Linux users

If you are just tinkering around and don’t care about deployment issues, you can use a symbolic link (assuming your filesystem supports it) to make the module or package directly visible in the folder of the requesting module.

ln -s (path)/


ln -s (path)/package_name

Note: A “module” is any file with a .py extension and a “package” is any folder that contains the file (which can be an empty file). From a usage standpoint, modules and packages are identical — both expose their contained “definitions and statements” as requested via the import command.


Answered By: Brent Bradburn

The easiest way without any modification to your script is to set PYTHONPATH environment variable. Because sys.path is initialized from these locations:

  1. The directory containing the input script (or the current
  2. PYTHONPATH (a list of directory names, with the same
    syntax as the shell variable PATH).
  3. The installation-dependent default.

Just run:

export PYTHONPATH=/absolute/path/to/your/module

You sys.path will contains above path, as show below:

print sys.path

['', '/absolute/path/to/your/module', '/usr/lib/python2.7', '/usr/lib/python2.7/plat-linux2', '/usr/lib/python2.7/lib-tk', '/usr/lib/python2.7/lib-old', '/usr/lib/python2.7/lib-dynload', '/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages/PIL', '/usr/lib/python2.7/dist-packages/gst-0.10', '/usr/lib/python2.7/dist-packages/gtk-2.0', '/usr/lib/pymodules/python2.7', '/usr/lib/python2.7/dist-packages/ubuntu-sso-client', '/usr/lib/python2.7/dist-packages/ubuntuone-client', '/usr/lib/python2.7/dist-packages/ubuntuone-control-panel', '/usr/lib/python2.7/dist-packages/ubuntuone-couch', '/usr/lib/python2.7/dist-packages/ubuntuone-installer', '/usr/lib/python2.7/dist-packages/ubuntuone-storage-protocol']
Answered By: James Gan

Relative sys.path example:

# /lib/
# /src/

if __name__ == '__main__' and __package__ is None:
    sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../lib')))
import my_module

Based on this answer.

Answered By: Der_Meister

For this case to import into, first I’d turn these folders into Python packages like so:


Then I would do it like this in

from .dirBar import Bar

If I wanted the namespacing to look like Bar.whatever, or

from . import dirBar

If I wanted the namespacing dirBar.Bar.whatever. This second case is useful if you have more modules under the dirBar package.

Answered By: Al Conrad

Well, as you mention, usually you want to have access to a folder with your modules relative to where your main script is run, so you just import them.


I have the script in D:/Books/ and some modules (like I need to import from subdirectory D:/Books/includes:

import sys,site
site.addsitedir(sys.path[0] + '\includes')
print (sys.path)  # Just verify it is there
import oldies

Place a print('done') in, so you verify everything is going OK. This way always works because by the Python definition sys.path as initialized upon program startup, the first item of this list, path[0], is the directory containing the script that was used to invoke the Python interpreter.

If the script directory is not available (e.g. if the interpreter is invoked interactively or if the script is read from standard input), path[0] is the empty string, which directs Python to search modules in the current directory first. Notice that the script directory is inserted before the entries inserted as a result of PYTHONPATH.

Answered By: Avenida Gez

Another solution would be to install the py-require package and then use the following in

import require
Bar = require('./dirBar/Bar')
Answered By: Niklas R

I’m not experienced about python, so if there is any wrong in my words, just tell me. If your file hierarchy arranged like this:

project defines a function called func_1(),

from module_1 import func_1

def func_2():

if __name__ == '__main__':

and you run python in cmd, it will do run what func_1() defines. That’s usually how we import same hierarchy files. But when you write from .module_1 import func_1 in, python interpreter will say No module named '__main__.module_1'; '__main__' is not a package. So to fix this, we just keep the change we just make, and move both of the module to a package, and make a third module as a caller to run


from package_1.module_2 import func_2

def func_3():

if __name__ == '__main__':

But the reason we add a . before module_1 in is that if we don’t do that and run, python interpreter will say No module named 'module_1', that’s a little tricky, is right beside Now I let func_1() in do something:

def func_1():

that __name__ records who calls func_1. Now we keep the . before module_1 , run, it will print package_1.module_1, not module_1. It indicates that the one who calls func_1() is at the same hierarchy as, the . imply that module_1 is at the same hierarchy as itself. So if there isn’t a dot, will recognize module_1 at the same hierarchy as itself, it can recognize package_1, but not what “under” it.

Now let’s make it a bit complicated. You have a config.ini and a module defines a function to read it at the same hierarchy as ‘’.


And for some unavoidable reason, you have to call it with, so it has to import from upper

 import ..config

Two dots means import from upper hierarchy (three dots access upper than upper,and so on). Now we run, the interpreter will say:ValueError:attempted relative import beyond top-level package. The “top-level package” at here is Just because is beside, they are at same hierarchy, isn’t “under”, or it isn’t “leaded” by, so it is beyond To fix this, the simplest way is:


I think that is coincide with the principle of arrange project file hierarchy, you should arrange modules with different function in different folders, and just leave a top caller in the outside, and you can import how ever you want.

Answered By: Findon Fassbender

Simply you can use: from Desktop.filename import something


given that the file is name in directory
Users/user/Desktop , and will import everthing.

the code:

from Desktop.test import *

But make sure you make an empty file called “” in that directory

Answered By: 0x1996

This also works, and is much simpler than anything with the sys module:

with open("C:/yourpath/") as f:
Answered By: californium