Comment charger dynamiquement une classe Python ?

Question

Étant donné une chaîne de caractères d'une classe Python, par exemple my_package.my_module.MyClass Quelle est la meilleure façon de le charger ?

En d'autres termes, je cherche un équivalent Class.forName() en Java, fonction en Python. Il doit fonctionner sur Google App Engine.

Il s'agirait de préférence d'une fonction qui accepte le FQN de la classe sous la forme d'une chaîne de caractères et qui renvoie une référence à la classe :

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

Answer 1

D'après 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 en est simple __import__ ne fonctionne pas, car toute importation de quelque chose au-delà du premier point d'une chaîne de paquets est un attribut du module que vous importez. Ainsi, quelque chose comme ceci ne fonctionnera pas :

__import__('foo.bar.baz.qux')

Vous devriez 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()

EDITAR : Je me suis un peu trompé sur ce point. Ce que vous voulez faire en gros, c'est ça :

from my_package.my_module import my_class

La fonction ci-dessus n'est nécessaire que si vous avez une vide de la liste. Ainsi, l'appel approprié serait comme ceci :

mod = __import__('my_package.my_module', fromlist=['my_class'])
klass = getattr(mod, 'my_class')

Answer 2

Si vous n'avez pas envie de le faire vous-même, il existe une fonction disponible dans l'application pydoc qui fait exactement cela :

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

L'avantage de cette approche par rapport aux autres énumérées ici est que locate trouvera cualquier objet python au niveau du chemin pointé fourni, et pas seulement un objet directement dans un module, par exemple my_package.my_module.MyClass.attr .

Si vous êtes curieux de savoir quelle est leur recette, 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 la documentation à ce sujet :

"""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)."""

Answer 3

import importlib

module = importlib.import_module('my_package.my_module')
my_class = getattr(module, 'MyClass')
my_instance = my_class()

Answer 4

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)

Answer 5

module = __import__("my_package/my_module")
the_class = getattr(module, "MyClass")
obj = the_class()