¿Cómo puedo importar un módulo dinámicamente dado su nombre como cadena?

Question 1

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

$ python myapp.py command1

Quiero que la aplicación sea extensible, es decir, poder 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

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

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

__import__(name, globals=None, locals=None, fromlist=(), level=0)

La función importa el módulo. namepotencialmente usando el dado globals y locals para determinar cómo interpretar el nombre en un contexto de paquete. los fromlist da los nombres de los objetos o submódulos que deben importarse del módulo dado por name.

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 posiblemente 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 entrar en el uso de 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.

_{Ver también: ¿Cómo importo un módulo dada la ruta completa?}

Question 2

Con Python anterior a 2.7/3.1, así es como se hace.

Para versiones más recientes, consulte importlib.import_module por Pitón 2 y Pitón 3.

Puedes usar exec si tu tambien quieres.

o usando __import__ puede importar una lista de módulos haciendo esto:

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

Arrancado directamente de Sumérgete en Python.

Question 3

los recomendado forma para Python 2.7 y 3.1 y posteriores es usar importlib módulo:

importlib.import_module(name, package=None)

Importar un módulo. El argumento del 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 ancla para resolver el nombre del paquete (p. ej. import_module('..mod', 'pkg.subpkg') importará pkg.mod).

p.ej

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

Question 4

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

Como se mencionó el diablillo El módulo le proporciona funciones de carga:

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

He usado estos 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

Question 5

Hoy en día deberías usar importlib.

Importar un archivo fuente

los documentos en realidad proporciona 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 manera puede acceder a los miembros (por ejemplo, una función “hello“) de su módulo pluginX.py — en este fragmento llamado module — bajo su espacio de nombres; P.ej, module.hello().

Si desea importar los miembros (p. ej., “hello“) puede incluir module/pluginX en la lista de módulos en memoria:

sys.modules[module_name] = module

from pluginX import hello
hello()

Importar un paquete

Importación de un paquete (p.ej, 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)

Question 6

Utilizar el módulo diablilloo el más directo __import__() función.

Question 7

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

Question 8

Puedes usar exec:

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

Importar un archivo fuente

Importar un paquete

¿Ha sido útil esta solución?