Comment charger dynamiquement une classe Python

Donné une chaîne d'un Python de classe, par exemple my_package.my_module.MyClass, quelle est la meilleure façon de le charger?

En d'autres mots, je suis à la recherche d'un équivalent Class.forName() en Java, une fonction en Python. Il a besoin de travailler sur Google App Engine.

De préférence, ce serait une fonction qui accepte la FQN de la classe comme une chaîne de caractères et retourne une référence à la classe:

my_class = load_class('my_package.my_module.MyClass')
my_instance = my_class()

J'ai besoin d'être en mesure d'assigner la classe de référence à une variable.
Ce qui semble être un doublon de: stackoverflow.com/questions/452969/...
Vous avez raison c'est un doublon, merci pour le trouver
J'ai jamais eu besoin de charger une classe comme ça en Python. Vous savez où le module est alors pourquoi ne pas charger le module et ensuite utiliser ses classes comme le Python veut que vous, son beaucoup plus simple
Si vous n'avez jamais besoin de faire cela, alors vous n'avez pas écrit assez intéressant programmes encore. Continuer à pratiquer.

InformationsquelleAutor pjesi | 2009-02-13

168

De la documentation python, voici la fonction que vous voulez:
```
def my_import(name):
    components = name.split('.')
    mod = __import__(components[0])
    for comp in components[1:]:
        mod = getattr(mod, comp)
    return mod
```
La raison pour laquelle un simple __import__ de ne pas travailler est parce que toute importation de rien passé le premier point dans un paquet de chaîne est un attribut du module que vous importez. Donc, quelque chose comme cela ne fonctionne pas:
```
__import__('foo.bar.baz.qux')
```
Vous devez appeler la fonction ci-dessus comme suit:
```
my_import('foo.bar.baz.qux')
```
Ou, dans le cas de votre exemple:
```
klass = my_import('my_package.my_module.my_class')
some_object = klass()
```
MODIFIER: j'ai été un peu hors sujet sur ce. Ce que vous avez l'impression de vouloir faire est ceci:
```
from my_package.my_module import my_class
```
La fonction ci-dessus est uniquement nécessaire si vous avez un vide fromlist. Ainsi, l'appel approprié serait comme ceci:
```
mod = __import__('my_package.my_module', fromlist=['my_class'])
klass = getattr(mod, 'my_class')
```
- J'ai essayé my_import('my_package.mon_module.my_class'), mais n'obtenez pas de module trouvé my_class, ce qui est logique puisque c'est une classe pas un module. Howver si je peux utiliser gettattr pour obtenir la classe après l'appel à my_import
- C'est bizarre. Tout ce passé le premier point est appelé à l'aide getattr. Il ne devrait pas y avoir de différence.
- Pensé à elle. Voir le poste de modifier.
- Merci je pense que c'est le meilleur moyen. Maintenant j'ai seulement besoin de la meilleure façon de diviser la chaîne " my_pakcage.mon_module.my_class " dans mod_name, klass_name mais je suppose que je peux comprendre 🙂
- Le my_import() code n'est pas nécessaire, vous pouvez utiliser des points dans un __import__() appel de l'amende juste. Ils ont tous pour désigner les noms de module cependant. Un symbole à partir du module doit être récupérées avec getattr().
- Si vous utilisez mod = __import__(nom.split('.')[0]), puis les composants=nom.split('.')[1:] (ou équivalent), il travaille également pour les noms de classe. E. g. my_import("datetime.date")
- Votre modifier la solution fonctionne sans le fromlist option (en python 2) c'est à dire mod = __import__('my_package.my_module'); klass = getattr(mod, 'my_class') est très bien. Je ne peux pas pour la vie de moi l'effet de fromlist, la documentation n'est pas clair pour moi.
- la documentation python (le code) de import est dit d'utiliser importlib. devrait donc répondre à la caisse par Adam Spence
InformationsquelleAutor Jason Baker

102

Si vous ne voulez pas passer votre propre, il n'y est une fonction disponible dans le pydoc module qui fait exactement cela:

from pydoc import locate
my_class = locate('my_package.my_module.MyClass')

L'avantage de cette approche sur les autres, énumérés ici est que locate trouverez tout objet python au pointillé chemin, non pas un objet directement dans un module. par exemple,my_package.my_module.MyClass.attr.

Si vous êtes curieux de savoir ce que leur recette est, voici la fonction:

def locate(path, forceload=0):
    """Locate an object by name or dotted path, importing as necessary."""
    parts = [part for part in split(path, '.') if part]
    module, n = None, 0
    while n < len(parts):
        nextmodule = safeimport(join(parts[:n+1], '.'), forceload)
        if nextmodule: module, n = nextmodule, n + 1
        else: break
    if module:
        object = module
    else:
        object = __builtin__
    for part in parts[n:]:
        try:
            object = getattr(object, part)
        except AttributeError:
            return None
    return object

Il s'appuie sur pydoc.safeimport fonction. Voici les docs pour que:

"""Import a module; handle errors; return None if the module isn't found.

If the module *is* found but an exception occurs, it's wrapped in an
ErrorDuringImport exception and reraised.  Unlike __import__, if a
package path is specified, the module at the end of the path is returned,
not the package at the beginning.  If the optional 'forceload' argument
is 1, we reload the module from disk (unless it's a dynamic extension)."""

Je upvoted cette réponse. BTW, voici le code qui ont également safeimport comme il semble étrange que l'importation pydoc juste pour ça: github.com/python/cpython/blob/...
Je upvoted cette réponse trop, c'est la meilleure de toutes les réponses pertinentes.
Cela semble être en mesure de gérer qualname (objet n'est pas au top de module de l'espace de noms) correctement ainsi.
oui, vous pouvez le faire locate('my_package.my_module.MyClass.attr.method.etc')

InformationsquelleAutor chadrik

74
```
import importlib

module = importlib.import_module('my_package.my_module')
my_class = getattr(module, 'MyClass')
my_instance = my_class()
```
- ne fonctionne pas. import_module les importations d'un module de classe.
- une fois que vous avez importé le module de façon dynamique, vous avez accès à la classe via le module
- Juste édité ma réponse à être plus concis. C'est la meilleure façon de charger une classe en Python.
- B-B-B-Benny et le Spence! 😉
- Super! C'est même une partie de la bibliothèque standard de 2,7 et jusqu'.
InformationsquelleAutor Adam Spence
29
```
def import_class(cl):
    d = cl.rfind(".")
    classname = cl[d+1:len(cl)]
    m = __import__(cl[0:d], globals(), locals(), [classname])
    return getattr(m, classname)
```
- C'est le propre solution! Vous pourriez envisager d'utiliser: (modulename, classname) = cl.rsplit('.', 2)
- C'est génial), j'avais créé putils paquet avec différents utils, aussi la classe de l'importation de là. Si vous le souhaitez, vous pouvez l'utiliser à partir de ce paquet.
- 1) ?
- J'ai réussi à passer {} au lieu de variables globales/habitants et il fonctionne toujours très bien
InformationsquelleAutor Stan
6

Si vous êtes à l'aide de Django, vous pouvez utiliser cette. Oui je suis au courant de l'OP n'a pas demander de django, mais j'ai couru à travers cette question de la recherche d'un Django solution, n'est-ce pas en trouver un, et de le mettre ici pour le prochain garçon/gal qui le cherche.
```
# It's available for v1.7+
# https://github.com/django/django/blob/stable/1.7.x/django/utils/module_loading.py
from django.utils.module_loading import import_string

Klass = import_string('path.to.module.Klass')
func = import_string('path.to.module.func')
var = import_string('path.to.module.var')
```
Gardez à l'esprit, si vous voulez importer quelque chose qui n'est pas un ., comme re ou argparse utilisation:
```
re = __import__('re')
```
InformationsquelleAutor Javier Buzzi
1

OK, c'est pour moi la façon dont il a travaillé (j'utilise Python 2.7):
```
a = __import__('file_to_import', globals(), locals(), ['*'], -1)
b = a.MyClass()
```
Alors, b est une instance de la classe "Maclasse'

InformationsquelleAutor lfvv

Si vous avez déjà une instance de votre classe, vous pouvez utiliser le "type" de la fonction pour en extraire le type de classe et l'utiliser pour construire une nouvelle instance:

class Something(object):
    def __init__(self, name):
        self.name = name
    def display(self):
        print(self.name)

one = Something("one")
one.display()
cls = type(one)
two = cls("two")
two.display()

InformationsquelleAutor Jason DeMorrow

0

Ici est de partager quelque chose que j'ai trouvé sur __import__ et importlib tout en essayant de résoudre ce problème.

Je suis à l'aide de Python 3.7.3.

Quand j'ai essayer d'obtenir à la classe d dans le module a.b.c,
```
mod = __import__('a.b.c')
```
La mod variable consultez le top de l'espace de noms a.

Donc, pour arriver à la classe d, j'ai besoin de
```
mod = getattr(mod, 'b') #mod is now module b
mod = getattr(mod, 'c') #mod is now module c
mod = getattr(mod, 'd') #mod is now class d
```
Si nous essayons de faire
```
mod = __import__('a.b.c')
d = getattr(mod, 'd')
```
nous sommes en train d'essayer de regarder pour a.d.

Lors de l'utilisation de importlib, je suppose que la bibliothèque a fait l'récursive getattr pour nous. Donc, lorsque nous utilisons importlib.import_module, nous avons effectivement obtenir une poignée sur le plus profond de module.
```
mod = importlib.import_module('a.b.c') #mod is module c
d = getattr(mod, 'd') #this is a.b.c.d
```
InformationsquelleAutor Richard Wong
-2
```
module = __import__("my_package/my_module")
the_class = getattr(module, "MyClass")
obj = the_class()
```
- Notez que cela fonctionne en raison d'un bogue dans le import fonction. Chemins d'accès de fichier doit pas être utilisée dans le import fonction et ne fonctionne pas dans la version 2.6 de python et ci-dessus: docs.python.org/whatsnew/2.6.html#porting-to-python-2-6
- va travailler avec des "." au lieu de la barre oblique "/"
InformationsquelleAutor oefe
-2

Dans Google App Engine il y a un webapp2 fonction appelée import_string. Pour plus d'infos, voir ici:https://webapp-improved.appspot.com/api/webapp2.html

Donc,
```
import webapp2
my_class = webapp2.import_string('my_package.my_module.MyClass')
```
Par exemple, il est utilisé dans le webapp2.Route où vous pouvez soit utiliser un gestionnaire ou une chaîne de caractères.

InformationsquelleAutor ph0eb0s

Vous devez vous connecter pour publier un commentaire.