Come importare un modulo dato il suo nome come stringa?

Sto scrivendo un'applicazione Python che accetta come comando come argomento, ad esempio:

$ python myapp.py command1

Voglio che l'applicazione sia estensibile, cioè per poter aggiungere nuovi moduli che implementano nuovi comandi senza dover cambiare l'origine dell'applicazione principale. L'albero è simile a:

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

Quindi voglio che l'applicazione trovi i moduli di comando disponibili in fase di esecuzione ed esegua quello appropriato.

Python definisce una funzione __import__ , che accetta una stringa per il nome di un modulo:

__import __ (nome, globali = Nessuno, locali = Nessuno, dalla lista = (), livello = 0)

La funzione importa il nome del modulo, utilizzando potenzialmente i globali e i locali indicati per determinare come interpretare il nome in un contesto di pacchetto. La fromlist fornisce i nomi di oggetti o sottomoduli che dovrebbero essere importati dal modulo dato dal nome.

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

Quindi attualmente ho qualcosa del tipo:

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

command_module.run()

Funziona bene, mi chiedo solo se esiste forse un modo più idiomatico per realizzare ciò che stiamo facendo con questo codice.

Nota che non voglio specificamente usare uova o punti di estensione. Questo non è un progetto open source e non mi aspetto che ci siano "plugin". Il punto è semplificare il codice principale dell'applicazione e rimuovere la necessità di modificarlo ogni volta che viene aggiunto un nuovo modulo di comando.

Con Python più vecchio di 2.7 / 3.1, è praticamente come lo fai.

Per le versioni più recenti, vedere importlib.import_moduleper Python 2 e Python 3 .

Puoi usarlo anche execse lo desideri.

O usando __import__puoi importare un elenco di moduli in questo modo:

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

Strappato direttamente da Dive Into Python .

Il modo consigliato per Python 2.7 e 3.1 e versioni successive è utilizzare il importlibmodulo:

importlib.import_module (nome, pacchetto = Nessuno)

Importa un modulo. L'argomento name specifica quale modulo importare in termini assoluti o relativi (es. Pkg.mod o ..mod). Se il nome è specificato in termini relativi, l'argomento del pacchetto deve essere impostato sul nome del pacchetto che deve fungere da ancoraggio per la risoluzione del nome del pacchetto (ad esempio import_module ('.. mod', 'pkg.subpkg') importerà pkg.mod).

per esempio

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

Nota: imp è deprecato da Python 3.4 a favore di importlib

Come accennato, il modulo imp offre funzioni di caricamento:

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

Ho usato questi prima per eseguire qualcosa di simile.

Nel mio caso ho definito una classe specifica con metodi definiti che erano richiesti. Una volta caricato il modulo, verificherei se la classe era nel modulo e quindi creavo un'istanza di quella classe, qualcosa del genere:

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

Utilizzare il modulo imp o la __import__()funzione più diretta .

Al giorno d'oggi dovresti usare importlib .

Importa un file di origine

I documenti in realtà forniscono una ricetta per questo, e va come:

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)

In questo modo puoi accedere ai membri (es. Una funzione " hello") dal tuo modulo pluginX.py- in questo snippet chiamato module- sotto il suo spazio dei nomi; Ad es module.hello().

Se si desidera importare i membri (ad es. " hello") È possibile includere module/ pluginXnell'elenco dei moduli in memoria:

sys.modules[module_name] = module

from pluginX import hello
hello()

Importa un pacchetto

L'importazione di un pacchetto ( ad es. , pluginX/__init__.py) Nella directory corrente è in realtà semplice:

import importlib

pkg = importlib.import_module('pluginX')

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

Se lo vuoi nella tua gente del posto:

>>> 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 stesso funzionerebbe con globals()

Puoi usare exec:

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

Simile alla soluzione di @monkut ma riutilizzabile e tollerante agli errori qui descritto 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

Il pezzo sotto ha funzionato per me:

>>>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 vuoi importare in shell-script:

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

Ad esempio, i nomi dei miei moduli sono come jan_module/ feb_module/ mar_module.

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

Per me ha funzionato:

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

Carica i moduli dalla cartella 'modus'. I moduli hanno una singola classe con lo stesso nome del nome del modulo. Ad esempio il file modus / modu1.py contiene:

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

Il risultato è un elenco di "adattatori" di classi caricate dinamicamente.