Cómo cargar dinámicamente una clase de Python

Dada una cadena de una clase de Python, por ejemplo my_package.my_module.MyClass , ¿cuál es la mejor manera posible de cargarla?

En otras palabras, estoy buscando un equivalente Class.forName() en Java, función en Python. Tiene que funcionar en Google App Engine.

Preferiblemente, esta sería una función que acepta el FQN de la clase como una cadena y devuelve una referencia a la clase:

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

De la documentación de Python, aquí está la función que desea:

def my_import(name):
    components = name.split('.')
    mod = __import__(components[0])
    for comp in components[1:]:
        mod = getattr(mod, comp)
    return mod

La razón por la que un simple __import__no funcionará es porque cualquier importación de algo más allá del primer punto en una cadena de paquete es un atributo del módulo que está importando. Por lo tanto, algo como esto no funcionará:

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

Tendría que llamar a la función anterior de esta manera:

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

O en el caso de tu ejemplo:

klass = my_import('my_package.my_module.my_class')
some_object = klass()

EDITAR : Estaba un poco fuera de lugar. Lo que básicamente quieres hacer es esto:

from my_package.my_module import my_class

La función anterior solo es necesaria si tiene una lista vacía . Por lo tanto, la llamada apropiada sería así:

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

Si no quiere rodar el suyo, hay una función disponible en el pydocmódulo que hace exactamente esto:

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

La ventaja de este enfoque sobre los otros enumerados aquí es que locateencontrará cualquier objeto de Python en la ruta de puntos proporcionada, no solo un objeto directamente dentro de un módulo. por ej my_package.my_module.MyClass.attr.

Si tienes curiosidad por cuál es su receta, aquí está la función:

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

Se basa en la pydoc.safeimportfunción. Aquí están los documentos para eso:

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

import importlib

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

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)

Si está usando Django, puede usar esto. Sí, sé que OP no solicitó django, pero me encontré con esta pregunta buscando una solución de Django, no encontré una y la puse aquí para el próximo chico / chica que la busca.

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

Tenga en cuenta que si desea importar algo que no tiene un me .gusta reo argparseuso:

re = __import__('re')

Aquí es para compartir algo que encontré __import__yimportlib al intentar resolver este problema.

Estoy usando Python 3.7.3.

Cuando trato de llegar a la clase den el módulo a.b.c,

mod = __import__('a.b.c')

La modvariable se refiere al espacio de nombres superior a.

Entonces, para llegar a la clase d, necesito

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 tratamos de hacer

mod = __import__('a.b.c')
d = getattr(mod, 'd')

en realidad estamos tratando de buscar a.d .

Al usar importlib, supongo que la biblioteca ha hecho el recursivo getattrpor nosotros. Entonces, cuando usamos importlib.import_module, en realidad obtenemos el módulo más profundo.

mod = importlib.import_module('a.b.c') #mod is module c
d = getattr(mod, 'd') #this is a.b.c.d

OK, para mí esa es la forma en que funcionó (estoy usando Python 2.7):

a = __import__('file_to_import', globals(), locals(), ['*'], -1)
b = a.MyClass()

Entonces, b es una instancia de la clase 'MyClass'

Si ya tiene una instancia de su clase deseada, puede usar la función 'tipo' para extraer su tipo de clase y usarla para construir una nueva instancia:

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

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

En Google App Engine hay una webapp2función llamada import_string. Para obtener más información, consulte aquí: https://webapp-improved.appspot.com/api/webapp2.html

Entonces,

import webapp2
my_class = webapp2.import_string('my_package.my_module.MyClass')

Por ejemplo, esto se usa en el lugar webapp2.Routedonde puede usar un controlador o una cadena.