Як динамічно завантажувати клас Python

Враховуючи рядок класу Python, наприклад my_package.my_module.MyClass, який найкращий спосіб завантажити його?

Іншими словами, я шукаю еквівалент Class.forName()у Java, функція в Python. Для цього потрібно працювати в Google App Engine.

Переважно це була б функція, яка приймає FQN класу як рядок і повертає посилання на клас:

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

З документації на python ось потрібна функція:

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

Причина простого __import__не буде працювати в тому, що будь-який імпорт будь-якого, що минув першої точки в рядку пакета, є атрибутом модуля, який ви імпортуєте. Таким чином, щось подібне не буде працювати:

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

Вам потрібно було б зателефонувати вищевказаній функції так:

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

Або у випадку вашого прикладу:

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

ЕДИТ : Я трохи від цього не став. Що ви в основному хочете зробити, це це:

from my_package.my_module import my_class

Вищевказана функція необхідна лише у тому випадку, якщо у вас є порожній список зі списку. Таким чином, відповідний дзвінок буде таким:

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

Якщо ви не хочете прокручувати свій власний, в pydocмодулі є функція, яка робить саме це:

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

Перевага такого підходу перед іншими, перерахованими тут, полягає в тому locate, що знайде будь-який об’єкт python на наданому пунктиром шляху, а не лише об'єкт безпосередньо в модулі. напр my_package.my_module.MyClass.attr.

Якщо вам цікаво, що таке їх рецепт, ось функція:

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

Він покладається на pydoc.safeimportфункцію. Ось документи для цього:

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

Якщо ви використовуєте Django, ви можете використовувати це. Так, я знаю, що ОП не просив джанго, але я наткнувся на це питання, шукаючи рішення Джанго, не знайшов його, і поставив його тут для наступного хлопця / галя, який його шукає.

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

Майте на увазі, якщо ви хочете імпортувати щось, що не має ., наприклад, reабо argparseвикористовувати:

re = __import__('re')

Ось, щоб поділитися тим, що я знайшов, __import__і importlibнамагаючись вирішити цю проблему.

Я використовую Python 3.7.3.

Коли я намагаюся потрапити до класу dв модулі a.b.c,

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

modЗмінний відносяться до верхнього простору імен a.

Тож щоб потрапити до класу d, мені потрібно

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

Якщо ми спробуємо зробити

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

ми насправді намагаємось шукати a.d.

При використанні importlibя думаю, що бібліотека зробила getattrдля нас рекурсивну форму . Отже, коли ми використовуємо importlib.import_module, ми фактично отримуємо ручку на найглибший модуль.

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

Гаразд, для мене це так, як це працювало (я використовую Python 2.7):

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

Тоді, b - екземпляр класу "MyClass"

Якщо у вас вже є екземпляр потрібного класу, ви можете скористатися функцією 'type', щоб витягти його тип класу і використовувати це для побудови нового примірника:

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

У Google App Engine є webapp2функція, яка називається import_string. Для отримання додаткової інформації дивіться тут: https://webapp-improved.appspot.com/api/webapp2.html

Так,

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

Наприклад, це використовується в тих випадках, webapp2.Routeколи ви можете використовувати обробник або рядок.