¿Cómo importar un módulo dado su nombre como cadena?

Estoy escribiendo una aplicación Python que toma como comando como argumento, por ejemplo:

$ python myapp.py command1

Quiero que la aplicación sea extensible, es decir, que pueda agregar nuevos módulos que implementen nuevos comandos sin tener que cambiar la fuente principal de la aplicación. El árbol se parece a:

myapp/
    __init__.py
    commands/
        __init__.py
        command1.py
        command2.py
    foo.py
    bar.py

Entonces, quiero que la aplicación encuentre los módulos de comando disponibles en tiempo de ejecución y ejecute el apropiado.

Python define una función __import__ , que toma una cadena para el nombre de un módulo:

__importar __ (nombre, globales = Ninguno, locales = Ninguno, de la lista = (), nivel = 0)

La función importa el nombre del módulo, potencialmente usando los globales y locales dados para determinar cómo interpretar el nombre en un contexto de paquete. La lista de origen proporciona los nombres de los objetos o submódulos que deben importarse del módulo dado por su nombre.

Fuente: https://docs.python.org/3/library/functions.html# import

Así que actualmente tengo algo como:

command = sys.argv[1]
try:
    command_module = __import__("myapp.commands.%s" % command, fromlist=["myapp.commands"])
except ImportError:
    # Display error message

command_module.run()

Esto funciona bien, solo me pregunto si es posible que haya una forma más idiomática de lograr lo que estamos haciendo con este código.

Tenga en cuenta que específicamente no quiero usar huevos o puntos de extensión. Este no es un proyecto de código abierto y no espero que haya "complementos". El objetivo es simplificar el código de la aplicación principal y eliminar la necesidad de modificarlo cada vez que se agrega un nuevo módulo de comando.

Con Python anterior a 2.7 / 3.1, así es como lo haces.

Para las versiones más recientes, ver importlib.import_modulepara Python 2 y y Python 3 .

Puedes usar execsi quieres también.

O utilizando __import__puede importar una lista de módulos haciendo esto:

>>> moduleNames = ['sys', 'os', 're', 'unittest'] 
>>> moduleNames
['sys', 'os', 're', 'unittest']
>>> modules = map(__import__, moduleNames)

Ripeado directamente de Dive Into Python .

La forma recomendada para Python 2.7 y 3.1 y posterior es usar el importlibmódulo:

importlib.import_module (nombre, paquete = Ninguno)

Importar un módulo. El argumento de nombre especifica qué módulo importar en términos absolutos o relativos (por ejemplo, pkg.mod o ..mod). Si el nombre se especifica en términos relativos, entonces el argumento del paquete debe establecerse en el nombre del paquete que actuará como el ancla para resolver el nombre del paquete (por ejemplo, import_module ('.. mod', 'pkg.subpkg') importará pkg.mod).

p.ej

my_module = importlib.import_module('os.path')

Nota: imp está en desuso desde Python 3.4 a favor de importlib

Como se mencionó, el módulo imp le proporciona funciones de carga:

imp.load_source(name, path)
imp.load_compiled(name, path)

Los he usado antes para realizar algo similar.

En mi caso, definí una clase específica con los métodos definidos que se requerían. Una vez que cargué el módulo, verificaría si la clase estaba en el módulo y luego crearía una instancia de esa clase, algo como esto:

import imp
import os

def load_from_file(filepath):
    class_inst = None
    expected_class = 'MyClass'

    mod_name,file_ext = os.path.splitext(os.path.split(filepath)[-1])

    if file_ext.lower() == '.py':
        py_mod = imp.load_source(mod_name, filepath)

    elif file_ext.lower() == '.pyc':
        py_mod = imp.load_compiled(mod_name, filepath)

    if hasattr(py_mod, expected_class):
        class_inst = getattr(py_mod, expected_class)()

    return class_inst

Use el módulo imp , o la __import__()función más directa .

Hoy en día deberías usar importlib .

Importar un archivo fuente

Los documentos realmente proporcionan una receta para eso, y dice así:

import sys
import importlib.util

file_path = 'pluginX.py'
module_name = 'pluginX'

spec = importlib.util.spec_from_file_location(module_name, file_path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)

# check if it's all there..
def bla(mod):
    print(dir(mod))
bla(module)

De esta forma puede acceder a los miembros (por ejemplo, una función " hello") desde su módulo pluginX.py, en este fragmento que se llama module, bajo su espacio de nombres; Ej module.hello().

Si desea importar los miembros (por ejemplo, " hello") puede incluir module/ pluginXen la lista de módulos en memoria:

sys.modules[module_name] = module

from pluginX import hello
hello()

Importar un paquete

Importar un paquete ( por ejemplo , pluginX/__init__.py) bajo su directorio actual es realmente sencillo:

import importlib

pkg = importlib.import_module('pluginX')

# check if it's all there..
def bla(mod):
    print(dir(mod))
bla(pkg)

Si lo quieres en tus locales:

>>> mod = 'sys'
>>> locals()['my_module'] = __import__(mod)
>>> my_module.version
'2.6.6 (r266:84297, Aug 24 2010, 18:46:32) [MSC v.1500 32 bit (Intel)]'

lo mismo funcionaría con globals()

Puedes usar exec:

exec("import myapp.commands.%s" % command)

Similar a la solución de @monkut pero reutilizable y tolerante a errores descrita aquí http://stamat.wordpress.com/dynamic-module-import-in-python/ :

import os
import imp

def importFromURI(uri, absl):
    mod = None
    if not absl:
        uri = os.path.normpath(os.path.join(os.path.dirname(__file__), uri))
    path, fname = os.path.split(uri)
    mname, ext = os.path.splitext(fname)

    if os.path.exists(os.path.join(path,mname)+'.pyc'):
        try:
            return imp.load_compiled(mname, uri)
        except:
            pass
    if os.path.exists(os.path.join(path,mname)+'.py'):
        try:
            return imp.load_source(mname, uri)
        except:
            pass

    return mod

La siguiente pieza funcionó para mí:

>>>import imp; 
>>>fp, pathname, description = imp.find_module("/home/test_module"); 
>>>test_module = imp.load_module("test_module", fp, pathname, description);
>>>print test_module.print_hello();

si desea importar en shell-script:

python -c '<above entire code in one line>'

Por ejemplo, los nombres de mis módulos son como jan_module/ feb_module/ mar_module.

month = 'feb'
exec 'from %s_module import *'%(month)

Lo siguiente funcionó para mí:

import sys, glob
sys.path.append('/home/marc/python/importtest/modus')
fl = glob.glob('modus/*.py')
modulist = []
adapters=[]
for i in range(len(fl)):
    fl[i] = fl[i].split('/')[1]
    fl[i] = fl[i][0:(len(fl[i])-3)]
    modulist.append(getattr(__import__(fl[i]),fl[i]))
    adapters.append(modulist[i]())

Carga módulos de la carpeta 'modus'. Los módulos tienen una sola clase con el mismo nombre que el nombre del módulo. Por ejemplo, el archivo modus / module1.py contiene:

class modu1():
    def __init__(self):
        self.x=1
        print self.x

El resultado es una lista de clases cargadas dinámicamente "adaptadores".