Comment importer un module avec son nom sous forme de chaîne?

J'écris une application Python qui prend comme commande un argument, par exemple:

$ python myapp.py command1

Je veux que l'application soit extensible, c'est-à-dire qu'elle puisse ajouter de nouveaux modules qui implémentent de nouvelles commandes sans avoir à changer la source principale de l'application. L'arbre ressemble à quelque chose comme:

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

Je souhaite donc que l'application trouve les modules de commande disponibles au moment de l'exécution et exécute le module approprié.

Python définit une fonction __import__ , qui prend une chaîne pour un nom de module:

__import __ (nom, globaux = Aucun, locaux = Aucun, fromlist = (), niveau = 0)

La fonction importe le nom du module, en utilisant potentiellement les valeurs globales et locales données pour déterminer comment interpréter le nom dans un contexte de package. La fromlist donne les noms des objets ou sous-modules qui doivent être importés du module donné par nom.

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

Donc, actuellement, j'ai quelque chose comme:

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

command_module.run()

Cela fonctionne très bien, je me demande simplement s'il existe un moyen plus idiomatique d'accomplir ce que nous faisons avec ce code.

Notez que je ne veux pas spécifiquement utiliser des œufs ou des points d'extension. Ce n'est pas un projet open-source et je ne m'attends pas à ce qu'il y ait des "plugins". Le but est de simplifier le code de l'application principale et de supprimer la nécessité de le modifier chaque fois qu'un nouveau module de commande est ajouté.

Avec Python plus ancien que 2.7 / 3.1, c'est à peu près ainsi que vous le faites.

Pour les versions plus récentes, voir importlib.import_modulepour Python 2 et et Python 3 .

Vous pouvez également l'utiliser execsi vous le souhaitez.

Ou en utilisant, __import__vous pouvez importer une liste de modules en procédant comme suit:

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

Extrait directement de Dive Into Python .

La méthode recommandée pour Python 2.7 et 3.1 et versions ultérieures consiste à utiliser le importlibmodule:

importlib.import_module (nom, package = Aucun)

Importez un module. L'argument nom spécifie le module à importer en termes absolus ou relatifs (par exemple, pkg.mod ou ..mod). Si le nom est spécifié en termes relatifs, l'argument package doit être défini sur le nom du package qui doit servir d'ancrage pour résoudre le nom du package (par exemple, import_module ('.. mod', 'pkg.subpkg') importera pkg.mod).

par exemple

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

Remarque: imp est déconseillé depuis Python 3.4 en faveur de importlib

Comme mentionné, le module imp vous offre des fonctions de chargement:

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

Je les ai déjà utilisés pour effectuer quelque chose de similaire.

Dans mon cas, j'ai défini une classe spécifique avec des méthodes définies qui étaient nécessaires. Une fois que j'ai chargé le module, je vérifierais si la classe était dans le module, puis je créerais une instance de cette classe, quelque chose comme ceci:

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

Utilisez le module imp ou la __import__()fonction plus directe .

De nos jours, vous devriez utiliser importlib .

Importer un fichier source

Les documents fournissent en fait une recette pour cela, et cela se passe comme suit:

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 cette façon, vous pouvez accéder aux membres (par exemple, une fonction " hello") de votre module pluginX.py- dans cet extrait appelé module- sous son espace de noms; Par exemple, module.hello().

Si vous souhaitez importer les membres (par exemple, " hello"), vous pouvez inclure module/ pluginXdans la liste des modules en mémoire:

sys.modules[module_name] = module

from pluginX import hello
hello()

Importer un package

L'importation d'un package ( par exemple , pluginX/__init__.py) sous votre répertoire actuel est en fait simple:

import importlib

pkg = importlib.import_module('pluginX')

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

Si vous le souhaitez dans vos locaux:

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

même fonctionnerait avec globals()

Vous pouvez utiliser exec:

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

Similaire à la solution de @monkut mais réutilisable et tolérante aux erreurs décrite ici 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

La pièce ci-dessous a fonctionné pour moi:

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

si vous voulez importer en shell-script:

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

Par exemple, les noms de mes modules sont comme jan_module/ feb_module/ mar_module.

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

Ce qui suit a fonctionné pour moi:

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

Il charge les modules du dossier «modus». Les modules ont une seule classe avec le même nom que le nom du module. Par exemple, le fichier modus / modu1.py contient:

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

Le résultat est une liste de classes "adaptateurs" chargés dynamiquement.