The __import__ function can be a bit hard to understand.

If you change

i = __import__('matplotlib.text')

to

i = __import__('matplotlib.text', fromlist=[''])

then i will refer to matplotlib.text.

In Python 3.1 or later, you can use importlib:

import importlib
i = importlib.import_module("matplotlib.text")

Some notes

• If you're trying to import something from a sub-folder e.g. ./feature/email.py, the code will look like importlib.import_module("feature.email")

• Before Python 3.3 you could not import anything if there was no __init__.py in the folder with file you were trying to import (see caveats before deciding if you want to keep the file for backward compatibility e.g. with pytest).

importlib.import_module is what you are looking for. It returns the imported module.

import importlib
# equiv. of your `import matplotlib.text as text`
text = importlib.import_module('matplotlib.text')

You can thereafter access anything in the module as text.myclass, text.myfunction, etc.

spent some time trying to import modules from a list, and this is the thread that got me most of the way there - but I didnt grasp the use of ___import____ -

so here's how to import a module from a string, and get the same behavior as just import. And try/except the error case, too. :)

 pipmodules = ['pycurl', 'ansible', 'bad_module_no_beer']
 for module in pipmodules:
 try:
 # because we want to import using a variable, do it this way
 module_obj = __import__(module)
 # create a global object containging our module
 globals()[module] = module_obj
 except ImportError:
 sys.stderr.write("ERROR: missing python module: " + module + "\n")
 sys.exit(1)

and yes, for python 2.7> you have other options - but for 2.6<, this works.

Apart from using the importlib one can also use exec method to import a module from a string variable.

Here I am showing an example of importing the combinations method from itertools package using the exec method:

MODULES = [
 ['itertools','combinations'],
]
for ITEM in MODULES:
 import_str = "from {0} import {1}".format(ITEM[0],', '.join(str(i) for i in ITEM[1:]))
 exec(import_str)
ar = list(combinations([1, 2, 3, 4], 2))
for elements in ar:
 print(elements)

Output:

(1, 2)
(1, 3)
(1, 4)
(2, 3)
(2, 4)
(3, 4)

You can also use exec built-in function that execute any string as a Python code.

In [1]: module = 'pandas'
 ...: function = 'DataFrame'
 ...: alias = 'DF'
In [2]: exec(f"from {module} import {function} as {alias}")
In [3]: DF
Out[3]: pandas.core.frame.DataFrame

For me this was the most readable way to solve my problem.

Module auto-install & import from list

Below script works fine with both submodules and pseudo submodules.

# PyPI imports
import pkg_resources, subprocess, sys
modules = {'lxml.etree', 'pandas', 'screeninfo'}
required = {m.split('.')[0] for m in modules}
installed = {pkg.key for pkg in pkg_resources.working_set}
missing = required - installed
if missing:
 subprocess.check_call([sys.executable, '-m', 'pip', 'install', '--upgrade', 'pip'])
 subprocess.check_call([sys.executable, '-m', 'pip', 'install', *missing])
for module in set.union(required, modules):
 globals()[module] = __import__(module)

Tests:

print(pandas.__version__)
print(lxml.etree.LXML_VERSION)

I developed these 3 useful functions:

def loadModule(moduleName):
 module = None
 try:
 import sys
 del sys.modules[moduleName]
 except BaseException as err:
 pass
 try:
 import importlib
 module = importlib.import_module(moduleName)
 except BaseException as err:
 serr = str(err)
 print("Error to load the module '" + moduleName + "': " + serr)
 return module
def reloadModule(moduleName):
 module = loadModule(moduleName)
 moduleName, modulePath = str(module).replace("' from '", "||").replace("<module '", '').replace("'>", '').split("||")
 if (modulePath.endswith(".pyc")):
 import os
 os.remove(modulePath)
 module = loadModule(moduleName)
 return module
def getInstance(moduleName, param1, param2, param3):
 module = reloadModule(moduleName)
 instance = eval("module." + moduleName + "(param1, param2, param3)")
 return instance

And everytime I want to reload a new instance I just have to call getInstance() like this:

myInstance = getInstance("MyModule", myParam1, myParam2, myParam3)

Finally I can call all the functions inside the new Instance:

myInstance.aFunction()

The only specificity here is to customize the params list (param1, param2, param3) of your instance.

from <mymodule> import x, y, z

Since I do not see a safe solution mimicking from <mymodule> import x, y, z, where mymodule is given as user input, this is what I suggest:

mymodule = input()
# pseudocode: from <mymodule> import x, y, z
symbols = ['x', 'y', 'z']
mymodule_ = __import__(mymodule, fromlist=symbols)
for s in symbols:
 globals()[s] = eval("mymodule_.%s" % s)

Explanation:

One cannot subscript a module in Python (e.g., mymodule_[symbols[1]]), therefore need for an eval/exec function. We do not want a user input there as a safety measure though. Thus it is done in two steps: first, import the module; second, expose the symbols.

• python
• python-import