Cara memuat kelas Python secara dinamis

Diberikan string dari kelas Python, misalnya my_package.my_module.MyClass, apa cara terbaik untuk memuatnya?

Dengan kata lain saya mencari yang setara Class.forName()di Jawa, berfungsi dengan Python. Perlu bekerja di Google App Engine.

Lebih disukai ini adalah fungsi yang menerima FQN dari kelas sebagai string, dan mengembalikan referensi ke kelas:

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

Dari dokumentasi python, inilah fungsi yang Anda inginkan:

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

Alasan sederhana __import__tidak akan bekerja adalah karena setiap impor apa pun melewati titik pertama dalam paket string adalah atribut dari modul yang Anda impor. Dengan demikian, sesuatu seperti ini tidak akan berfungsi:

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

Anda harus memanggil fungsi di atas seperti:

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

Atau dalam hal contoh Anda:

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

EDIT : Saya agak kecewa dengan hal ini. Apa yang pada dasarnya ingin Anda lakukan adalah ini:

from my_package.my_module import my_class

Fungsi di atas hanya diperlukan jika Anda memiliki daftar kosong . Dengan demikian, panggilan yang tepat akan seperti ini:

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

Jika Anda tidak ingin roll sendiri, ada fungsi yang tersedia di pydocmodul yang melakukan ini:

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

Keuntungan dari pendekatan ini atas yang lain yang tercantum di sini adalah bahwa locateakan menemukan setiap objek python di jalan putus-putus yang disediakan, bukan hanya obyek langsung dalam sebuah modul. mis my_package.my_module.MyClass.attr.

Jika Anda ingin tahu apa resep mereka, inilah fungsinya:

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

Itu bergantung pada pydoc.safeimportfungsi. Inilah dokumen untuk itu:

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

Jika Anda menggunakan Django, Anda dapat menggunakan ini. Ya saya sadar OP tidak meminta Django, tetapi saya menemukan pertanyaan ini untuk mencari solusi Django, tidak menemukan satu, dan menaruhnya di sini untuk anak laki-laki / perempuan berikutnya yang mencarinya.

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

Ingat, jika Anda ingin mengimpor sesuatu yang tidak memiliki ., suka reatauargparse gunakan:

re = __import__('re')

Ini untuk membagikan sesuatu yang saya temukan di __import__danimportlib saat mencoba menyelesaikan masalah ini.

Saya menggunakan Python 3.7.3.

Ketika saya mencoba untuk masuk ke kelas ddalam modul a.b.c,

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

The modvariabel merujuk ke puncak namespace a.

Jadi untuk sampai ke kelas d, saya harus

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

Jika kita coba lakukan

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

kami sebenarnya sedang mencari a.d.

Saat menggunakan importlib, saya kira perpustakaan telah melakukan rekursif getattruntuk kita. Jadi, ketika kita gunakan importlib.import_module, kita benar-benar mendapatkan pegangan pada modul terdalam.

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

OK, bagi saya itu cara kerjanya (saya menggunakan Python 2.7):

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

Kemudian, b adalah turunan dari kelas 'MyClass'

Jika Anda telah memiliki instance dari kelas yang Anda inginkan, Anda dapat menggunakan fungsi 'type' untuk mengekstrak tipe kelasnya dan menggunakan ini untuk membuat instance baru:

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

Di Google App Engine ada webapp2fungsi yang disebut import_string. Untuk info lebih lanjut lihat di sini: https://webapp-improved.appspot.com/api/webapp2.html

Begitu,

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

Misalnya ini digunakan di webapp2.Routemana Anda bisa menggunakan pawang atau string.