Python dynamique de l'instanciation de la chaîne de nom d'une classe et dynamique, le module importé

En python, je dois instancier certaine classe, sachant son nom dans une chaîne de caractères, mais cette classe "vies" dans dynamiquement, un module importé. Prenons l'exemple suivant:

chargeur-script de classe:

import sys
class loader:
  def __init__(self, module_name, class_name): # both args are strings
    try:
      __import__(module_name)
      modul = sys.modules[module_name]
      instance = modul.class_name() # obviously this doesn't works, here is my main problem!
    except ImportError:
       # manage import error

quelques-chargées dynamiquement-module de script:

class myName:
  # etc...

- Je utiliser cet arrangement pour effectuer toute chargées dynamiquement-module pour être utilisé par le chargeur de classe à la suite de certains comportements prédéfinis dans le dyn-chargé-modules...

Toutes les idées sont les bienvenues.

InformationsquelleAutor Javier Novoa C. | 2011-01-27

python

203

Vous pouvez utiliser getattr
```
getattr(module, class_name)
```
pour accéder à la classe. Code plus complet:
```
module = __import__(module_name)
class_ = getattr(module, class_name)
instance = class_()
```
Comme mentionné ci-dessous, nous pouvons utiliser importlib
```
import importlib
module = importlib.import_module(module_name)
class_ = getattr(module, class_name)
instance = class_()
```
- module = __import__(module, fromlist=[name]) seulement travaillé pour moi.
- Si quelqu'un a de la difficulté avec la méthode d'importation Sven mentionné ci-dessus, j'ai trouvé mon code fonctionnait mieux à l'aide de la méthode suivante au lieu de cela importlib.import_module. Peut être utilisé comme: module = importlib.import_module(nom du module)
- vous devriez poster que comme une réponse, il est souvent plus utile d'être en mesure d'utiliser directement la chaîne de caractères retournée par obj.__module__
- importlib.import_module charge la .py fichier dans un pyc si nécessaire ainsi que de gérer le module complet.nom.cheminement.d'.obtenir.d'.la classe. __import__ ne sera pas faire ces choses, dans un django environnement (pas testé en dehors de cela)
InformationsquelleAutor Sven Marnach
103

tl;dr

Importer le module racine avec importlib.import_module et de la charge de la classe par son nom à l'aide de getattr fonction:
```
# Standard import
import importlib
# Load "module.submodule.MyClass"
MyClass = getattr(importlib.import_module("module.submodule"), "MyClass")
# Instantiate the class (pass arguments to the constructor, if needed)
instance = MyClass()
```
explications

Vous ne voulez probablement pas à utiliser __import__ dynamique d'importer un module par son nom, car il ne vous permet pas d'importer des submodules:
```
>>> mod = __import__("os.path")
>>> mod.join
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'join'
```
Ici est ce que le python doc a dit à propos de __import__:

Note: Ceci est une fonction avancée qui n'est pas nécessaire dans la vie quotidienne
Programmation Python, contrairement à importlib.import_module().

Au lieu de cela, utiliser la norme importlib module dynamique d'importer un module par son nom. Avec getattr vous pouvez ensuite instancier une classe par son nom:
```
import importlib
my_module = importlib.import_module("module.submodule")
MyClass = getattr(my_module, "MyClass")
instance = MyClass()
```
Vous pouvez également écrire:
```
import importlib
module_name, class_name = "module.submodule.MyClass".rsplit(".", 1)
MyClass = getattr(importlib.import_module(module_name), class_name)
instance = MyClass()
```
Ce code est valide en python ≥ 2.7 (y compris python 3).
- peut-être que je ne comprends pas votre réponse, mais j'ai utilisé import pour importer des submodules: __import__("module". + submodule_name_string)
- Le code suivant génère une AttributeError: mod = __import__("os.path"); mod.join tandis que le suivant ne marche pas: mod = importlib.import_module("os.path"); mod.join
- oh je vois, vous avez raison, mais j'ai effectué les opérations suivantes pour obtenir de l'os.chemin d'accès.méthode join: getattr(sys.modules["os.chemin"], "join")
- ha! et je vois bien que quand les utiliser, puis 'import " est inutile XD
- Si cette classe a besoin d'un argument ?
- Vous pouvez simplement passer des arguments à l'appel à MyClass.
- L'option marqué comme réponse n'a pas fonctionné pour moi (à l'aide de submodules) toutefois, cette réponse ne. Je pense que cela devrait être la réponse puisque c'est plus de solution générique pour le chargement dynamique de modules.
InformationsquelleAutor Régis B.
11

Utilisation getattr pour obtenir un attribut à partir d'un nom dans une chaîne de caractères. En d'autres termes, obtenir de l'instance comme
```
instance = getattr(modul, class_name)()
```
InformationsquelleAutor AFoglia

Copier-coller l'extrait de code:

import importlib
def str_to_class(module_name, class_name):
    """Return a class instance from a string reference"""
    try:
        module_ = importlib.import_module(module_name)
        try:
            class_ = getattr(module_, class_name)()
        except AttributeError:
            logging.error('Class does not exist')
    except ImportError:
        logging.error('Module does not exist')
    return class_ or None

InformationsquelleAutor Andrejs Cainikovs

5

Si vous voulez que cette phrase from foo.bar import foo2 être chargés dynamiquement, vous devriez faire ce
```
foo = __import__("foo")
bar = getattr(foo,"bar")
foo2 = getattr(bar,"foo2")

instance = foo2()
```
InformationsquelleAutor Ahmad Muzakki

Je ne pouvais pas tout à fait là dans mon cas d'utilisation à partir des exemples ci-dessus, mais Ahmad m'a le plus proche (merci). Pour ceux qui nous lisent dans l'avenir, voici le code qui a fonctionné pour moi.

def get_class(fully_qualified_path, module_name, class_name, *instantiation):
    """
    Returns an instantiated class for the given string descriptors
    :param fully_qualified_path: The path to the module eg("Utilities.Printer")
    :param module_name: The module name eg("Printer")
    :param class_name: The class name eg("ScreenPrinter")
    :param instantiation: Any fields required to instantiate the class
    :return: An instance of the class
    """
    p = __import__(fully_qualified_path)
    m = getattr(p, module_name)
    c = getattr(m, class_name)
    instance = c(*instantiation)
    return instance

InformationsquelleAutor SteveJ

On peut simplement utiliser la pydoc.locate fonction.

from pydoc import locate
my_class = locate("module.submodule.myclass")
instance = my_class()

InformationsquelleAutor Xema

Vous devez vous connecter pour publier un commentaire.

tl;dr

explications