How can I import a module dynamically given the full path?


How do I load a Python module given its full path?

Note that the file can be anywhere in the filesystem where the user has access rights.

See also: How to import a module given its name as string?

Asked By: derfred



I believe you can use imp.find_module() and imp.load_module() to load the specified module. You’ll need to split the module name off of the path, i.e. if you wanted to load /home/mypath/ you’d need to do:

imp.find_module('mymodule', '/home/mypath/')

…but that should get the job done.

Answered By: Matt

Let’s have MyClass in module defined at /path/to/ Below is how we import MyClass from this module

For Python 3.5+ use (docs):

import importlib.util
import sys
spec = importlib.util.spec_from_file_location("", "/path/to/")
foo = importlib.util.module_from_spec(spec)
sys.modules[""] = foo

For Python 3.3 and 3.4 use:

from importlib.machinery import SourceFileLoader

foo = SourceFileLoader("", "/path/to/").load_module()

(Although this has been deprecated in Python 3.4.)

For Python 2 use:

import imp

foo = imp.load_source('', '/path/to/')

There are equivalent convenience functions for compiled Python files and DLLs.

See also

Answered By: Sebastian Rittau

You can use the

load_source(module_name, path_to_file)

method from the imp module.

Answered By: zuber

Import package modules at runtime (Python recipe)

##                #
## #
##                #

import sys, types

def _get_mod(modulePath):
        aMod = sys.modules[modulePath]
        if not isinstance(aMod, types.ModuleType):
            raise KeyError
    except KeyError:
        # The last [''] is very important!
        aMod = __import__(modulePath, globals(), locals(), [''])
        sys.modules[modulePath] = aMod
    return aMod

def _get_func(fullFuncName):
    """Retrieve a function object from a full dotted-package name."""

    # Parse out the path, module, and function
    lastDot = fullFuncName.rfind(u".")
    funcName = fullFuncName[lastDot + 1:]
    modPath = fullFuncName[:lastDot]

    aMod = _get_mod(modPath)
    aFunc = getattr(aMod, funcName)

    # Assert that the function is a *callable* attribute.
    assert callable(aFunc), u"%s is not callable." % fullFuncName

    # Return a reference to the function itself,
    # not the results of the function.
    return aFunc

def _get_class(fullClassName, parentClass=None):
    """Load a module and retrieve a class (NOT an instance).

    If the parentClass is supplied, className must be of parentClass
    or a subclass of parentClass (or None is returned).
    aClass = _get_func(fullClassName)

    # Assert that the class is a subclass of parentClass.
    if parentClass is not None:
        if not issubclass(aClass, parentClass):
            raise TypeError(u"%s is not a subclass of %s" %
                            (fullClassName, parentClass))

    # Return a reference to the class itself, not an instantiated object.
    return aClass

##       Usage      ##

class StorageManager: pass
class StorageManagerMySQL(StorageManager): pass

def storage_object(aFullClassName, allOptions={}):
    aStoreClass = _get_class(aFullClassName, StorageManager)
    return aStoreClass(allOptions)
Answered By: user10370

You can also do something like this and add the directory that the configuration file is sitting in to the Python load path, and then just do a normal import, assuming you know the name of the file in advance, in this case “config”.

Messy, but it works.

configfile = '~/'

import os
import sys


import config
Answered By: Chris Cherry

Do you mean load or import?

You can manipulate the sys.path list specify the path to your module, and then import your module. For example, given a module at:


You could do:

import sys
sys.path[0:0] = ['/foo'] # Puts the /foo directory at the start of your path
import bar
Answered By: Wheat

You can do this using __import__ and chdir:

def import_file(full_path_to_module):
        import os
        module_dir, module_file = os.path.split(full_path_to_module)
        module_name, module_ext = os.path.splitext(module_file)
        save_cwd = os.getcwd()
        module_obj = __import__(module_name)
        module_obj.__file__ = full_path_to_module
        globals()[module_name] = module_obj
    except Exception as e:
        raise ImportError(e)
    return module_obj

Answered By: Chris Calloway

The advantage of adding a path to sys.path (over using imp) is that it simplifies things when importing more than one module from a single package. For example:

import sys
# the mock-0.3.1 dir contains, &

from testcase import TestCase
from testutils import RunTests
from mock import Mock, sentinel, patch
Answered By: Daryl Spitzer

I made a package that uses imp for you. I call it import_file and this is how it’s used:

>>>from import_file import import_file
>>>mylib = import_file('c:\')
>>>another = import_file('relative_subdir/')

You can get it at:

or at

Answered By: ubershmekel

This should work

path = os.path.join('./path/to/folder/with/py/files', '*.py')
for infile in glob.glob(path):
    basename = os.path.basename(infile)
    basename_without_extension = basename[:-3]

    imp.load_source(basename_without_extension, infile)
Answered By: Hengjie

You can use the pkgutil module (specifically the walk_packages method) to get a list of the packages in the current directory. From there it’s trivial to use the importlib machinery to import the modules you want:

import pkgutil
import importlib

packages = pkgutil.walk_packages(path='.')
for importer, name, is_package in packages:
    mod = importlib.import_module(name)
    # do whatever you want with module now, it's been imported!
Answered By: bob_twinkles

In Linux, adding a symbolic link in the directory your Python script is located works.


ln -s /absolute/path/to/module/ /absolute/path/to/script/

The Python interpreter will create /absolute/path/to/script/module.pyc and will update it if you change the contents of /absolute/path/to/module/

Then include the following in file

from module import *
Answered By: user2760152

The best way, I think, is from the official documentation (29.1. imp — Access the import internals):

import imp
import sys

def __import__(name, globals=None, locals=None, fromlist=None):
    # Fast path: see if the module has already been imported.
        return sys.modules[name]
    except KeyError:

    # If any of the following calls raises an exception,
    # there's a problem we can't handle -- let the caller handle it.

    fp, pathname, description = imp.find_module(name)

        return imp.load_module(name, fp, pathname, description)
        # Since we may exit via an exception, close fp explicitly.
        if fp:
Answered By: Zompa

This area of Python 3.4 seems to be extremely tortuous to understand! However with a bit of hacking using the code from Chris Calloway as a start I managed to get something working. Here’s the basic function.

def import_module_from_file(full_path_to_module):
    Import a module given the full path/filename of the .py file

    Python 3.4


    module = None


        # Get module name and path from full path
        module_dir, module_file = os.path.split(full_path_to_module)
        module_name, module_ext = os.path.splitext(module_file)

        # Get module "spec" from filename
        spec = importlib.util.spec_from_file_location(module_name,full_path_to_module)

        module = spec.loader.load_module()

    except Exception as ec:
        # Simple error printing
        # Insert "sophisticated" stuff here

        return module

This appears to use non-deprecated modules from Python 3.4. I don’t pretend to understand why, but it seems to work from within a program. I found Chris’ solution worked on the command line but not from inside a program.

Answered By: Redlegjed

I’m not saying that it is better, but for the sake of completeness, I wanted to suggest the exec function, available in both Python 2 and Python 3.

exec allows you to execute arbitrary code in either the global scope, or in an internal scope, provided as a dictionary.

For example, if you have a module stored in "/path/to/module" with the function foo(), you could run it by doing the following:

module = dict()
with open("/path/to/module") as f:
    exec(, module)

This makes it a bit more explicit that you’re loading code dynamically, and grants you some additional power, such as the ability to provide custom builtins.

And if having access through attributes, instead of keys is important to you, you can design a custom dict class for the globals, that provides such access, e.g.:

class MyModuleClass(dict):
    def __getattr__(self, name):
        return self.__getitem__(name)
Answered By: yoniLavi

To import a module from a given filename, you can temporarily extend the path, and restore the system path in the finally block reference:

filename = "directory/"

directory, module_name = os.path.split(filename)
module_name = os.path.splitext(module_name)[0]

path = list(sys.path)
sys.path.insert(0, directory)
    module = __import__(module_name)
    sys.path[:] = path # restore
Answered By: Peter Zhu

It sounds like you don’t want to specifically import the configuration file (which has a whole lot of side effects and additional complications involved). You just want to run it, and be able to access the resulting namespace. The standard library provides an API specifically for that in the form of runpy.run_path:

from runpy import run_path
settings = run_path("/path/to/")

That interface is available in Python 2.7 and Python 3.2+.

Answered By: ncoghlan

Here is some code that works in all Python versions, from 2.7-3.5 and probably even others.

config_file = "/tmp/"
with open(config_file) as f:
    code = compile(, config_file, 'exec')
    exec(code, globals(), locals())

I tested it. It may be ugly, but so far it is the only one that works in all versions.

Answered By: sorin

I have come up with a slightly modified version of @SebastianRittau’s wonderful answer (for Python > 3.4 I think), which will allow you to load a file with any extension as a module using spec_from_loader instead of spec_from_file_location:

from importlib.util import spec_from_loader, module_from_spec
from importlib.machinery import SourceFileLoader 

spec = spec_from_loader("", SourceFileLoader("", "/path/to/"))
mod = module_from_spec(spec)

The advantage of encoding the path in an explicit SourceFileLoader is that the machinery will not try to figure out the type of the file from the extension. This means that you can load something like a .txt file using this method, but you could not do it with spec_from_file_location without specifying the loader because .txt is not in importlib.machinery.SOURCE_SUFFIXES.

I’ve placed an implementation based on this, and @SamGrondahl’s useful modification into my utility library, haggis. The function is called haggis.load.load_module. It adds a couple of neat tricks, like the ability to inject variables into the module namespace as it is loaded.

Answered By: Mad Physicist

This will allow imports of compiled (pyd) Python modules in 3.4:

import sys
import importlib.machinery

def load_module(name, filename):
    # If the Loader finds the module name in this list it will use
    # module_name.__file__ instead so we need to delete it here
    if name in sys.modules:
        del sys.modules[name]
    loader = importlib.machinery.ExtensionFileLoader(name, filename)
    module = loader.load_module()
    locals()[name] = module
    globals()[name] = module

load_module('something', r'C:PathTosomething.pyd')
Answered By: David

A quite simple way: suppose you want import file with relative path ../../MyLibs/

libPath = '../../MyLibs'
import sys
if not libPath in sys.path: sys.path.append(libPath)
import pyfunc as pf

But if you make it without a guard you can finally get a very long path.

Answered By: Andrei Keino

If your top-level module is not a file but is packaged as a directory with, then the accepted solution almost works, but not quite. In Python 3.5+ the following code is needed (note the added line that begins with ‘sys.modules’):

MODULE_PATH = "/path/to/your/module/"
MODULE_NAME = "mymodule"
import importlib
import sys
spec = importlib.util.spec_from_file_location(MODULE_NAME, MODULE_PATH)
module = importlib.util.module_from_spec(spec)
sys.modules[] = module 

Without this line, when exec_module is executed, it tries to bind relative imports in your top level to the top level module name — in this case “mymodule”. But “mymodule” isn’t loaded yet so you’ll get the error “SystemError: Parent module ‘mymodule’ not loaded, cannot perform relative import”. So you need to bind the name before you load it. The reason for this is the fundamental invariant of the relative import system: “The invariant holding is that if you have sys.modules[‘spam’] and sys.modules[‘’] (as you would after the above import), the latter must appear as the foo attribute of the former” as discussed here.

Answered By: Sam Grondahl

A simple solution using importlib instead of the imp package (tested for Python 2.7, although it should work for Python 3 too):

import importlib

dirname, basename = os.path.split(pyfilepath) # pyfilepath: '/my/path/'
sys.path.append(dirname) # only directories should be added to PYTHONPATH
module_name = os.path.splitext(basename)[0] # '/my/path/' --> 'mymodule'
module = importlib.import_module(module_name) # name space of defined module (otherwise we would literally look for "module_name")

Now you can directly use the namespace of the imported module, like this:

a = module.myvar
b = module.myfunc(a)

The advantage of this solution is that we don’t even need to know the actual name of the module we would like to import, in order to use it in our code. This is useful, e.g. in case the path of the module is a configurable argument.

Answered By: Ataxias

This answer is a supplement to Sebastian Rittau’s answer responding to the comment: "but what if you don’t have the module name?" This is a quick and dirty way of getting the likely Python module name given a filename — it just goes up the tree until it finds a directory without an file and then turns it back into a filename. For Python 3.4+ (uses pathlib), which makes sense since Python 2 people can use "imp" or other ways of doing relative imports:

import pathlib

def likely_python_module(filename):
    Given a filename or Path, return the "likely" python module name.  That is, iterate
    the parent directories until it doesn't contain an file.

    :rtype: str
    p = pathlib.Path(filename).resolve()
    paths = []
    if != '':
    while True:
        p = p.parent
        if not p:
        if not p.is_dir():

        inits = [f for f in p.iterdir() if == '']
        if not inits:


    return '.'.join(reversed(paths))

There are certainly possibilities for improvement, and the optional files might necessitate other changes, but if you have in general, this does the trick.

To import your module, you need to add its directory to the environment variable, either temporarily or permanently.


import sys
import my_module


Adding the following line to your .bashrc (or alternative) file in Linux
and excecute source ~/.bashrc (or alternative) in the terminal:

export PYTHONPATH="${PYTHONPATH}:/path/to/my/modules/"

Credit/Source: saarrrr, another Stack Exchange question

Answered By: Miladiouss

Create Python module

import sys
from tes1 import Client1
from tes2 import Client2
import tes3

Create Python module

from test import Client1
from test import Client2
from test import test3

We can import the imported module from module.

Answered By: abhimanyu

I have written my own global and portable import function, based on importlib module, for:

  • Be able to import both modules as submodules and to import the content of a module to a parent module (or into a globals if has no parent module).
  • Be able to import modules with a period characters in a file name.
  • Be able to import modules with any extension.
  • Be able to use a standalone name for a submodule instead of a file name without extension which is by default.
  • Be able to define the import order based on previously imported module instead of dependent on sys.path or on a what ever search path storage.

The examples directory structure:

 +- /std1
 |   |
 |   +-
 +- /std2
 |   |
 |   +-
 +- /std3

Inclusion dependency and order:


Latest changes store:

import os, sys, inspect, copy

SOURCE_FILE = os.path.abspath(inspect.getsourcefile(lambda:0)).replace('\','/')
SOURCE_DIR = os.path.dirname(SOURCE_FILE)

print("test::SOURCE_FILE: ", SOURCE_FILE)

# portable import to the global space
sys.path.append(TACKLELIB_ROOT) # TACKLELIB_ROOT - path to the library directory
import tacklelib as tkl


# cleanup
del tkl # must be instead of `tkl = None`, otherwise the variable would be still persist

tkl_import_module(SOURCE_DIR, '')


#testlib.testlib.std3.std3_test()                             # does not reachable directly ...
getattr(globals()['testlib'], 'testlib.std3').std3_test()     # ... but reachable through the `globals` + `getattr`

tkl_import_module(SOURCE_DIR, '', '.')


#testlib.std3.std3_test()                                     # does not reachable directly ...
globals()['testlib.std3'].std3_test()                         # ... but reachable through the `globals` + `getattr`

# optional for 3.4.x and higher
#import os, inspect
#SOURCE_FILE = os.path.abspath(inspect.getsourcefile(lambda:0)).replace('\','/')
#SOURCE_DIR = os.path.dirname(SOURCE_FILE)

print("1 testlib::SOURCE_FILE: ", SOURCE_FILE)

tkl_import_module(SOURCE_DIR + '/std1', '', 'testlib_std1')

# SOURCE_DIR is restored here
print("2 testlib::SOURCE_FILE: ", SOURCE_FILE)

tkl_import_module(SOURCE_DIR + '/std3', '')

print("3 testlib::SOURCE_FILE: ", SOURCE_FILE)

def base_test():

# optional for 3.4.x and higher
#import os, inspect
#SOURCE_FILE = os.path.abspath(inspect.getsourcefile(lambda:0)).replace('\','/')
#SOURCE_DIR = os.path.dirname(SOURCE_FILE)

print("testlib.std1::SOURCE_FILE: ", SOURCE_FILE)

tkl_import_module(SOURCE_DIR + '/../std2', '', 'testlib_std2')

def std1_test():

# optional for 3.4.x and higher
#import os, inspect
#SOURCE_FILE = os.path.abspath(inspect.getsourcefile(lambda:0)).replace('\','/')
#SOURCE_DIR = os.path.dirname(SOURCE_FILE)

print("testlib.std2::SOURCE_FILE: ", SOURCE_FILE)

def std2_test():

# optional for 3.4.x and higher
#import os, inspect
#SOURCE_FILE = os.path.abspath(inspect.getsourcefile(lambda:0)).replace('\','/')
#SOURCE_DIR = os.path.dirname(SOURCE_FILE)

print("testlib.std3::SOURCE_FILE: ", SOURCE_FILE)

def std3_test():

Output (3.7.4):

test::SOURCE_FILE:  <root>/test01/
import : <root>/test01/ as testlib -> []
1 testlib::SOURCE_FILE:  <root>/test01/
import : <root>/test01/std1/ as testlib_std1 -> ['testlib']
import : <root>/test01/std1/../std2/ as testlib_std2 -> ['testlib', 'testlib_std1']
testlib.std2::SOURCE_FILE:  <root>/test01/std1/../std2/
2 testlib::SOURCE_FILE:  <root>/test01/
import : <root>/test01/std3/ as testlib.std3 -> ['testlib']
testlib.std3::SOURCE_FILE:  <root>/test01/std3/
3 testlib::SOURCE_FILE:  <root>/test01/
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', '__file__', '__cached__', 'os', 'sys', 'inspect', 'copy', 'SOURCE_FILE', 'SOURCE_DIR', 'TackleGlobalImportModuleState', 'tkl_membercopy', 'tkl_merge_module', 'tkl_get_parent_imported_module_state', 'tkl_declare_global', 'tkl_import_module', 'TackleSourceModuleState', 'tkl_source_module', 'TackleLocalImportModuleState', 'testlib'])
import : <root>/test01/ as . -> []
1 testlib::SOURCE_FILE:  <root>/test01/
import : <root>/test01/std1/ as testlib_std1 -> ['testlib']
import : <root>/test01/std1/../std2/ as testlib_std2 -> ['testlib', 'testlib_std1']
testlib.std2::SOURCE_FILE:  <root>/test01/std1/../std2/
2 testlib::SOURCE_FILE:  <root>/test01/
import : <root>/test01/std3/ as testlib.std3 -> ['testlib']
testlib.std3::SOURCE_FILE:  <root>/test01/std3/
3 testlib::SOURCE_FILE:  <root>/test01/
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', '__file__', '__cached__', 'os', 'sys', 'inspect', 'copy', 'SOURCE_FILE', 'SOURCE_DIR', 'TackleGlobalImportModuleState', 'tkl_membercopy', 'tkl_merge_module', 'tkl_get_parent_imported_module_state', 'tkl_declare_global', 'tkl_import_module', 'TackleSourceModuleState', 'tkl_source_module', 'TackleLocalImportModuleState', 'testlib', 'testlib_std1', 'testlib.std3', 'base_test'])

Tested in Python 3.7.4, 3.2.5, 2.7.16


  • Can import both module as a submodule and can import content of a module to a parent module (or into a globals if has no parent module).
  • Can import modules with periods in a file name.
  • Can import any extension module from any extension module.
  • Can use a standalone name for a submodule instead of a file name without extension which is by default (for example, as testlib, as testlib_blabla and so on).
  • Does not depend on a sys.path or on a what ever search path storage.
  • Does not require to save/restore global variables like SOURCE_FILE and SOURCE_DIR between calls to tkl_import_module.
  • [for 3.4.x and higher] Can mix the module namespaces in nested tkl_import_module calls (ex: named->local->named or local->named->local and so on).
  • [for 3.4.x and higher] Can auto export global variables/functions/classes from where being declared to all children modules imported through the tkl_import_module (through the tkl_declare_global function).


  • Does not support complete import:
    • Ignores enumerations and subclasses.
    • Ignores builtins because each what type has to be copied exclusively.
    • Ignore not trivially copiable classes.
    • Avoids copying builtin modules including all packaged modules.
  • [for 3.3.x and lower] Require to declare tkl_import_module in all modules which calls to tkl_import_module (code duplication)

Update 1,2 (for 3.4.x and higher only):

In Python 3.4 and higher you can bypass the requirement to declare tkl_import_module in each module by declare tkl_import_module in a top level module and the function would inject itself to all children modules in a single call (it’s a kind of self deploy import).

Update 3:

Added function tkl_source_module as analog to bash source with support execution guard upon import (implemented through the module merge instead of import).

Update 4:

Added function tkl_declare_global to auto export a module global variable to all children modules where a module global variable is not visible because is not a part of a child module.

Update 5:

All functions has moved into the tacklelib library, see the link above.

Answered By: Andry

There’s a package that’s dedicated to this specifically:

from thesmuggler import smuggle

# À la `import weapons`
weapons = smuggle('')

# À la `from contraband import drugs, alcohol`
drugs, alcohol = smuggle('drugs', 'alcohol', source='')

# À la `from contraband import drugs as dope, alcohol as booze`
dope, booze = smuggle('drugs', 'alcohol', source='')

It’s tested across Python versions (Jython and PyPy too), but it might be overkill depending on the size of your project.

Answered By: fny

If we have scripts in the same project but in different directory means, we can solve this problem by the following method.

In this situation is in src/main/util/

import sys

import src.main.util.utils
from src.main.util.utils import json_converter # json_converter is example method
Answered By: Kumar KS

These are my two utility functions using only pathlib. It infers the module name from the path.

By default, it recursively loads all Python files from folders and replaces by the parent folder name. But you can also give a Path and/or a glob to select some specific files.

from pathlib import Path
from importlib.util import spec_from_file_location, module_from_spec
from typing import Optional

def get_module_from_path(path: Path, relative_to: Optional[Path] = None):
    if not relative_to:
        relative_to = Path.cwd()

    abs_path = path.absolute()
    relative_path = abs_path.relative_to(relative_to.absolute())
    if == "":
        relative_path = relative_path.parent
    module_name = ".".join(relative_path.with_suffix("").parts)
    mod = module_from_spec(spec_from_file_location(module_name, path))
    return mod

def get_modules_from_folder(folder: Optional[Path] = None, glob_str: str = "*/**/*.py"):
    if not folder:
        folder = Path(".")

    mod_list = []
    for file_path in sorted(folder.glob(glob_str)):

    return mod_list
Answered By: Benos

Here’s a way of loading files sorta like C, etc.

from importlib.machinery import SourceFileLoader
import os

    if (MODULE_PATH [ 0 ] == "/"):
        DIR_PATH = os.path.dirname (os.path.realpath (__file__))
        FULL_PATH = os.path.normpath (DIR_PATH + "/" + MODULE_PATH)

    return SourceFileLoader (FULL_PATH, FULL_PATH).load_module ()

Implementations Where:

Y = LOAD ("../")
A = LOAD ("./")
D = LOAD ("./C/")

Y.DEF ();
A.DEF ();
D.DEF ();
A_.DEF ();

Where each of the files looks like this:

def DEF ():
    print ("A");
Answered By: Bryan Grace

I find this is a simple answer:

module = dict()

code = """
import json

def testhi() :
    return json.dumps({"key" : "value"}, indent = 4 )

exec(code, module)
x = module['testhi']()
Answered By: Mhadhbi issam

To add to Sebastian Rittau‘s answer:
At least for CPython, there’s pydoc, and, while not officially declared, importing files is what it does:

from pydoc import importfile
module = importfile('/path/to/')

PS. For the sake of completeness, there’s a reference to the current implementation at the moment of writing:, and I’m pleased to say that in the vein of xkcd 1987 it uses neither of the implementations mentioned in issue 21436 — at least, not verbatim.

Answered By: ジョージ

Something special is to import a module with absolute path with Exec():
(exec takes a code string or code object. While eval takes an expression.)


And then get values or object with eval():

println('get module data: '+evalStr('pyplot.hist(x)'));

Load a module with exec is like an import with wildcard namespace:

Execstring('from histogram import *'); 
Answered By: Max Kleiner

You can use importfile from pydoc

from pydoc import importfile
module = importfile('/full/path/to/module/')
name = module.myclass() # myclass is a class inside your python file
Answered By: Jorge

Assuming that your MyClass is in, you can use this one line to dynamically import it/

cls = `MyClass`
MyClass = getattr(__import__(cls, globals(), locals(), [cls], 0), cls)
Answered By: Uri Goren