Come caricare dinamicamente una classe Python

Data una stringa di una classe Python, ad esempio my_package.my_module.MyClass, qual è il modo migliore per caricarla?

In altre parole, sto cercando un equivalente Class.forName()in Java, funzione in Python. Deve funzionare su Google App Engine.

Preferibilmente questa sarebbe una funzione che accetta l'FQN della classe come stringa e restituisce un riferimento alla classe:

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

Dalla documentazione di Python, ecco la funzione desiderata:

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

Il motivo per cui un semplice __import__non funziona è perché qualsiasi importazione di qualcosa oltre il primo punto in una stringa di pacchetto è un attributo del modulo che stai importando. Pertanto, qualcosa del genere non funzionerà:

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

Dovresti chiamare la funzione sopra in questo modo:

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

O nel caso del tuo esempio:

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

EDIT : ero un po 'fuori su questo. Quello che sostanzialmente vuoi fare è questo:

from my_package.my_module import my_class

La funzione sopra è necessaria solo se hai un fromlist vuoto . Pertanto, la chiamata appropriata sarebbe così:

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

Se non vuoi lanciarne uno tuo, c'è una funzione disponibile nel pydocmodulo che fa esattamente questo:

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

Il vantaggio di questo approccio rispetto agli altri elencati qui è che locatetroverà qualsiasi oggetto Python nel percorso punteggiato fornito, non solo un oggetto direttamente all'interno di un modulo. es my_package.my_module.MyClass.attr.

Se sei curioso di sapere qual è la loro ricetta, ecco la funzione:

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

Si basa sulla pydoc.safeimportfunzione. Ecco i documenti per questo:

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

Se stai usando Django puoi usarlo. Sì, sono consapevole che OP non ha chiesto django, ma ho incontrato questa domanda alla ricerca di una soluzione Django, non l'ho trovata e l'ho messa qui per il ragazzo / ragazza successivo che la cerca.

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

Tieni presente che se desideri importare qualcosa che non ha ., come reo argparseusare:

re = __import__('re')

Qui è per condividere qualcosa che ho trovato su __import__eimportlib mentre cercavo di risolvere questo problema.

Sto usando Python 3.7.3.

Quando provo ad arrivare alla classe dnel modulo a.b.c,

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

La modvariabile si riferisce allo spazio dei nomi principale a.

Quindi per arrivare in classe d, devo farlo

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

Se proviamo a fare

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

stiamo effettivamente cercando di cercare a.d .

Durante l'utilizzo importlib, suppongo che la libreria abbia fatto il ricorsivo getattrper noi. Quindi, quando usiamo importlib.import_module, otteniamo effettivamente una maniglia sul modulo più profondo.

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

OK, per me è così che ha funzionato (sto usando Python 2.7):

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

Quindi, b è un'istanza della classe 'MyClass'

Se ti capita di avere già un'istanza della classe desiderata, puoi utilizzare la funzione 'type' per estrarne il tipo di classe e utilizzarla per costruire una nuova istanza:

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

In Google App Engine c'è una webapp2funzione chiamata import_string. Per maggiori informazioni vedi qui: https://webapp-improved.appspot.com/api/webapp2.html

Così,

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

Ad esempio, questo viene utilizzato webapp2.Routedove è possibile utilizzare un gestore o una stringa.