Como importar um módulo que recebeu seu nome como string?

Estou escrevendo um aplicativo Python que usa como comando um argumento, por exemplo:

$ python myapp.py command1

Quero que o aplicativo seja extensível, ou seja, seja capaz de adicionar novos módulos que implementam novos comandos sem precisar alterar a fonte principal do aplicativo. A árvore se parece com:

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

Então, eu quero que o aplicativo encontre os módulos de comando disponíveis em tempo de execução e execute o apropriado.

Python define uma função __import__ , que recebe uma string para o nome de um módulo:

__import __ (nome, globais = Nenhum, locais = Nenhum, da lista = (), nível = 0)

A função importa o nome do módulo, potencialmente usando os globais e locais fornecidos para determinar como interpretar o nome em um contexto de pacote. A lista from fornece os nomes de objetos ou submódulos que devem ser importados do módulo fornecido pelo nome.

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

Então, atualmente, tenho 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()

Isso funciona muito bem, só estou me perguntando se existe uma maneira mais idiomática de realizar o que estamos fazendo com esse código.

Note que eu especificamente não quero usar ovos ou pontos de extensão. Este não é um projeto de código aberto e não espero que haja "plugins". O objetivo é simplificar o código principal do aplicativo e remover a necessidade de modificá-lo toda vez que um novo módulo de comando é adicionado.

Com o Python anterior a 2.7 / 3.1, é assim que você faz.

Para as versões mais recentes, ver importlib.import_modulepara Python 2 e e Python 3 .

Você pode usar execse quiser também.

Ou __import__você pode importar uma lista de módulos fazendo o seguinte:

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

Rasgado direto de Dive Into Python .

A maneira recomendada para o Python 2.7 e 3.1 e posterior é usar o importlibmódulo:

importlib.import_module (nome, pacote = Nenhum)

Importe um módulo. O argumento name especifica qual módulo importar em termos absolutos ou relativos (por exemplo, pkg.mod ou ..mod). Se o nome for especificado em termos relativos, o argumento do pacote deve ser definido como o nome do pacote que deve atuar como a âncora para resolver o nome do pacote (por exemplo, import_module ('.. mod', 'pkg.subpkg') importará o pkg.mod).

por exemplo

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

Nota: imp está obsoleto desde o Python 3.4 em favor do importlib

Como mencionado, o módulo imp fornece funções de carregamento:

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

Eu usei isso antes para executar algo semelhante.

No meu caso, defini uma classe específica com métodos definidos que eram necessários. Depois de carregar o módulo, verificaria se a classe estava no módulo e criaria uma instância dessa classe, algo como isto:

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 o módulo imp , ou a __import__()função mais direta .

Atualmente você deve usar importlib .

Importar um arquivo de origem

Os documentos realmente fornecem uma receita para isso, e é assim:

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)

Dessa forma, você pode acessar os membros (por exemplo, uma função " hello") do seu módulo pluginX.py- neste trecho chamado module- sob seu espaço de nome; Por exemplo module.hello(),.

Se você deseja importar os membros (por exemplo, " hello"), você pode incluir module/ pluginXna lista de módulos na memória:

sys.modules[module_name] = module

from pluginX import hello
hello()

Importar um pacote

A importação de um pacote ( por exemplo , pluginX/__init__.py) sob seu diretório atual é realmente simples:

import importlib

pkg = importlib.import_module('pluginX')

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

Se você quiser nos locais:

>>> 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)]'

mesmo funcionaria com globals()

Você pode usar exec:

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

Semelhante à solução da @monkut, mas reutilizável e tolerante a erros descrita aqui 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

A peça abaixo funcionou para mim:

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

se você deseja importar no shell-script:

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

Por exemplo, os nomes dos meus módulos são como jan_module/ feb_module/ mar_module.

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

O seguinte funcionou para mim:

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

Carrega módulos da pasta 'modus'. Os módulos possuem uma única classe com o mesmo nome que o nome do módulo. Por exemplo, o arquivo modus / modu1.py contém:

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

O resultado é uma lista de classes "adaptadores" carregados dinamicamente.