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 testcase.py, testutils.py & mock.py

sys.path.append('/foo/bar/mock-0.3.1')



from testcase import TestCase

from testutils import RunTests

from mock import Mock, sentinel, patch

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 = '~/config.py'



import os

import sys



sys.path.append(os.path.dirname(os.path.expanduser(configfile)))



import config

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/file.py")

That interface is available in Python 2.7 and Python 3.2+

You can use the

load_source(module_name, path_to_file) 

method from imp module.

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("module.name", SourceFileLoader("module.name", "/path/to/file.py"))

mod = module_from_spec(spec)

spec.loader.exec_module(mod)

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.

def import_file(full_path_to_module):

    try:

        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()

        os.chdir(module_dir)

        module_obj = __import__(module_name)

        module_obj.__file__ = full_path_to_module

        globals()[module_name] = module_obj

        os.chdir(save_cwd)

    except:

        raise ImportError



import_file('/home/somebody/somemodule.py')

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

config_file = "/tmp/config.py"

with open(config_file) as f:

    code = compile(f.read(), config_file, 'exec')

    exec(code, globals(), locals())

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

Do you mean load or import?

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

/foo/bar.py

You could do:

import sys

sys.path[0:0] = ['/foo'] # puts the /foo directory at the start of your path

import bar

If your top-level module is not a file but is packaged as a directory with __init__.py, 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/__init__.py"

MODULE_NAME = "mymodule"

spec = importlib.util.spec_from_file_location(MODULE_NAME, MODULE_PATH)

module = importlib.util.module_from_spec(spec)

sys.modules[spec.name] = module 

spec.loader.exec_module(module)

Without this line, when exec_module is executed, it tries to bind relative imports in your top level __init__.py 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['spam.foo'] (as you would after the above import), the latter must appear as the foo attribute of the former" as discussed here.

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/mymodule.py you'd need to do:

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

...but that should get the job done.

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

Temporarily

import sys

sys.path.append("/path/to/my/modules/")

import my_module

Permanently

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

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

Credit/Source: saarrrr, another stackexchange question

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]



    # http://docs.python.org/library/imp.html?highlight=imp#module-imp

    imp.load_source(basename_without_extension, infile)

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



    try:



        # 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

        print(ec)



    finally:

        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.

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 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(f.read(), module)

module['foo']()

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)

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/module.py"



directory, module_name = os.path.split(filename)

module_name = os.path.splitext(module_name)[0]



path = list(sys.path)

sys.path.insert(0, directory)

try:

    module = __import__(module_name)

finally:

    sys.path[:] = path # restore

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:\mylib.py')

>>>another = import_file('relative_subdir/another.py')

You can get it at:

http://pypi.python.org/pypi/import_file

or at

http://code.google.com/p/import-file/

Import package modules at runtime (Python recipe)

http://code.activestate.com/recipes/223972/

###################

##                #

## classloader.py #

##                #

###################



import sys, types



def _get_mod(modulePath):

    try:

        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)

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!

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

ie:

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

python will create /absolute/path/to/script/module.pyc and will update it if you change the contents of /absolute/path/to/module/module.py

then include the following in mypythonscript.py

from module import *

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

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

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/mymodule.py'

sys.path.append(dirname) # only directories should be added to PYTHONPATH

module_name = os.path.splitext(basename)[0] # '/my/path/mymodule.py' --> '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.

Create python module test.py

import sys

sys.path.append("<project-path>/lib/")

from tes1 import Client1

from tes2 import Client2

import tes3

Create python module test_check.py

from test import Client1

from test import Client2

from test import test3

We can import the imported module from module.

Adding this to the list of answers as I couldn't find anything that worked. 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')

something.do_something()

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 __init__.py file and then turns it back into a filename. For Python 3.4+ (uses pathlib), which makes sense since Py2 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 __init__.py file.



    :rtype: str

    '''

    p = pathlib.Path(filename).resolve()

    paths = 

    if p.name != '__init__.py':

        paths.append(p.stem)

    while True:

        p = p.parent

        if not p:

            break

        if not p.is_dir():

            break



        inits = [f for f in p.iterdir() if f.name == '__init__.py']

        if not inits:

            break



        paths.append(p.stem)



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

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

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.

    try:

        return sys.modules[name]

    except KeyError:

        pass



    # 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)



    try:

        return imp.load_module(name, fp, pathname, description)

    finally:

        # Since we may exit via an exception, close fp explicitly.

        if fp:

            fp.close()