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

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.

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.

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