Wie importiere ich ein Modul mit seinem Namen als Zeichenfolge?

Ich schreibe eine Python-Anwendung, die als Befehl ein Argument verwendet, zum Beispiel:

$ python myapp.py command1

Ich möchte, dass die Anwendung erweiterbar ist, dh neue Module hinzufügen kann, die neue Befehle implementieren, ohne die Hauptanwendungsquelle ändern zu müssen. Der Baum sieht ungefähr so ​​aus:

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

Daher möchte ich, dass die Anwendung zur Laufzeit die verfügbaren Befehlsmodule findet und das entsprechende ausführt.

Python definiert eine __import__ -Funktion, die eine Zeichenfolge für einen Modulnamen verwendet :

__import __ (Name, global = Keine, Einheimische = Keine, fromlist = (), Ebene = 0)

Die Funktion importiert den Modulnamen und verwendet möglicherweise die angegebenen globalen und lokalen Elemente, um zu bestimmen, wie der Name in einem Paketkontext interpretiert werden soll. Die fromlist gibt die Namen von Objekten oder Submodulen an, die aus dem Modul mit Namen importiert werden sollen.

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

Also habe ich momentan so etwas wie:

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

command_module.run()

Dies funktioniert einwandfrei. Ich frage mich nur, ob es möglicherweise einen idiomatischeren Weg gibt, um das zu erreichen, was wir mit diesem Code tun.

Beachten Sie, dass ich speziell nicht darauf eingehen möchte, Eier oder Verlängerungspunkte zu verwenden. Dies ist kein Open-Source-Projekt und ich erwarte keine "Plugins". Der Punkt besteht darin, den Hauptanwendungscode zu vereinfachen und die Notwendigkeit zu beseitigen, ihn jedes Mal zu ändern, wenn ein neues Befehlsmodul hinzugefügt wird.

Mit Python älter als 2.7 / 3.1 machen Sie das so.

Bei neueren Versionen finden Sie importlib.import_modulefür Python 2 und und Python 3 .

Sie können verwenden, execwenn Sie möchten.

Oder __import__Sie können eine Liste von Modulen importieren, indem Sie folgende Schritte ausführen:

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

Direkt von Dive Into Python gerissen .

Die empfohlene Methode für Python 2.7 und 3.1 und höher ist die Verwendung des importlibModuls:

importlib.import_module (Name, Paket = Keine)

Importieren Sie ein Modul. Das Argument name gibt an, welches Modul absolut oder relativ importiert werden soll (z. B. pkg.mod oder ..mod). Wenn der Name relativ angegeben wird, muss das Paketargument auf den Namen des Pakets gesetzt werden, das als Anker für die Auflösung des Paketnamens dienen soll (z. B. import_module ('.. mod', 'pkg.subpkg'). wird pkg.mod importieren).

z.B

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

Hinweis: imp ist seit Python 3.4 zugunsten von importlib veraltet

Wie bereits erwähnt, bietet Ihnen das imp- Modul Ladefunktionen :

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

Ich habe diese schon einmal benutzt, um etwas Ähnliches zu machen.

In meinem Fall habe ich eine bestimmte Klasse mit definierten Methoden definiert, die erforderlich waren. Sobald ich das Modul geladen habe, überprüfe ich, ob sich die Klasse im Modul befindet, und erstelle dann eine Instanz dieser Klasse, etwa so:

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

Verwenden Sie das imp-Modul oder die direktere __import__()Funktion.

Heutzutage sollten Sie importlib verwenden .

Importieren Sie eine Quelldatei

Die Dokumente bieten tatsächlich ein Rezept dafür, und es geht so:

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)

Auf diese Weise können Sie hellovon Ihrem Modul aus pluginX.py- in diesem aufgerufenen Snippet module- unter seinem Namespace auf die Mitglieder (z. B. eine Funktion " ") zugreifen . ZB , module.hello().

Wenn Sie die Mitglieder importieren möchten (z. B. " hello"), können Sie module/ pluginXin die speicherinterne Liste der Module aufnehmen:

sys.modules[module_name] = module

from pluginX import hello
hello()

Importieren Sie ein Paket

Importieren eines Pakets ( zB , pluginX/__init__.py) unter dem aktuellen Verzeichnis ist eigentlich ganz einfach:

import importlib

pkg = importlib.import_module('pluginX')

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

Wenn Sie es bei Ihren Einheimischen wollen:

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

das gleiche würde funktionieren mit globals()

Sie können verwenden exec:

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

Ähnlich wie die Lösung von @monkut, jedoch wiederverwendbar und fehlertolerant, wie hier beschrieben. 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

Das folgende Stück hat für mich funktioniert:

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

Wenn Sie in Shell-Skript importieren möchten:

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

Zum Beispiel sind meine Modulnamen wie jan_module/ feb_module/ mar_module.

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

Folgendes hat bei mir funktioniert:

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

Es lädt Module aus dem Ordner 'modus'. Die Module haben eine einzelne Klasse mit demselben Namen wie der Modulname. ZB enthält die Datei modus / modu1.py:

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

Das Ergebnis ist eine Liste der dynamisch geladenen Klassen "Adapter".