Wie importiert man ein Modul mit seinem Namen als String?

Question

Ich schreibe eine Python-Anwendung, die z. B. einen Befehl als Argument annimmt:

$ python myapp.py command1

Ich möchte, dass die Anwendung erweiterbar ist, d. h., dass neue Module hinzugefügt werden können, die neue Befehle implementieren, ohne dass der Hauptanwendungscode geändert werden muss. Der Baum sieht in etwa so aus:

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

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

Python definiert eine __import__() Funktion, die eine Zeichenkette als Modulnamen annimmt:

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

Die Funktion importiert das Modul name möglicherweise unter Verwendung der angegebenen globals et locals um zu bestimmen, wie der Name in einem Paketkontext zu interpretieren ist. Die fromlist gibt die Namen von Objekten oder Untermodulen an, die aus dem Modul importiert werden sollen, das durch name .

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

Derzeit habe ich also 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 sehr gut, ich frage mich nur, ob es möglicherweise eine idiomatischere Weise zu erreichen, was wir mit diesem Code tun.

Beachten Sie, dass ich ausdrücklich nicht auf die Verwendung von Eiern oder Verlängerungspunkten eingehen möchte. Dies ist kein Open-Source-Projekt und ich erwarte nicht, dass es "Plugins" gibt. Es geht darum, den Hauptanwendungscode zu vereinfachen und ihn nicht jedes Mal ändern zu müssen, wenn ein neues Befehlsmodul hinzugefügt wird.

Answer 1

Mit Python, das älter als 2.7/3.1 ist, ist das so ziemlich die Art und Weise, wie man es macht.

Für neuere Versionen, siehe importlib.import_module にとって Python 2 et Python 3 .

Sie können verwenden exec wenn Sie das auch wollen.

Oder mit __import__ können Sie auf diese Weise eine Liste von Modulen importieren:

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

Direkt entnommen aus Eintauchen in Python .

Answer 2

Der empfohlene Weg für Python 2.7 und 3.1 und später ist die Verwendung von importlib Modul:

importlib.import_module(name, package=None)

Importieren Sie ein Modul. Das Argument name gibt an, welches Modul in absoluten oder relativen Begriffen importiert werden soll (z.B. entweder pkg.mod oder ..mod). Wird der Name in relativen Begriffen angegeben, muss das Argument package 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') importiert pkg.mod).

z.B..

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

Answer 3

Anmerkung: imp ist seit Python 3.4 veraltet zugunsten von importlib

Wie bereits erwähnt, ist die imp Modul stellt Ihnen Ladefunktionen zur Verfügung:

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

Ich habe sie schon einmal benutzt, um etwas Ähnliches zu tun.

In meinem Fall habe ich eine bestimmte Klasse mit bestimmten Methoden definiert, die erforderlich waren. Sobald ich das Modul geladen hatte, prüfte ich, ob die Klasse im Modul enthalten war, und erstellte 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

Answer 4

Heutzutage sollten Sie importlib .

Importieren einer Quelldatei

Le site docs Es gibt sogar ein Rezept dafür, und das 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 auf die Mitglieder (z. B. eine Funktion " hello ") von Ihrem Modul pluginX.py -- in diesem Schnipsel heißt das module -- unter seinem Namensraum; z.B, module.hello() .

Wenn Sie die Mitglieder importieren möchten (z. B. " hello ") können Sie einschließen module / pluginX in der speicherinternen Liste der Module:

sys.modules[module_name] = module

from pluginX import hello
hello()

Ein Paket importieren

Importieren eines Pakets ( z.B.. , pluginX/__init__.py ) unter Ihrem 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)

Answer 5

Verwenden Sie die Koboldmodul oder die direktere __import__() Funktion.