动态实例化从一个类的字符串名称在动态导入模块?

在python中，我必须实例化某个类，知道它在字符串中的名称，但这个类“生活”在一个动态导入的模块中。示例如下:

loader类脚本:

import sys
class loader:
def __init__(self, module_name, class_name): # both args are strings
try:
__import__(module_name)
modul = sys.modules[module_name]
instance = modul.class_name() # obviously this doesn't works, here is my main problem!
except ImportError:
# manage import error

some-dynamically-loaded-module脚本:

class myName:
# etc...

我使用这种安排使加载器类使用任何动态加载模块，遵循动态加载模块中的某些预定义行为…

206280 次浏览
小开
最佳答案

你可以使用getattr

getattr(module, class_name)

访问类。更完整的代码:

module = __import__(module_name)
class_ = getattr(module, class_name)
instance = class_()

正如前面提到的下面，我们可以使用importlib

import importlib
module = importlib.import_module(module_name)
class_ = getattr(module, class_name)
instance = class_()
小开

使用getattr从字符串中的名称获取属性。换句话说，获取实例为

instance = getattr(modul, class_name)()
小开

复制粘贴代码片段:

import importlib
def str_to_class(module_name, class_name):
"""Return a class instance from a string reference"""
try:
module_ = importlib.import_module(module_name)
try:
class_ = getattr(module_, class_name)()
except AttributeError:
logging.error('Class does not exist')
except ImportError:
logging.error('Module does not exist')
return class_ or None
小开

如果你想要这个句子from foo.bar import foo2被动态加载，你应该这样做

foo = __import__("foo")
bar = getattr(foo,"bar")
foo2 = getattr(bar,"foo2")


instance = foo2()
小开

从上面的例子中，我不能完全达到我的用例，但Ahmad给了我最接近的(谢谢)。对于那些将来读到这篇文章的人来说，下面是对我有用的代码。

def get_class(fully_qualified_path, module_name, class_name, *instantiation):
"""
Returns an instantiated class for the given string descriptors
:param fully_qualified_path: The path to the module eg("Utilities.Printer")
:param module_name: The module name eg("Printer")
:param class_name: The class name eg("ScreenPrinter")
:param instantiation: Any fields required to instantiate the class
:return: An instance of the class
"""
p = __import__(fully_qualified_path)
m = getattr(p, module_name)
c = getattr(m, class_name)
instance = c(*instantiation)
return instance
小开

博士tl;

使用importlib.import_module导入根模块，并使用getattr函数按类名加载类:

# Standard import
import importlib
# Load "module.submodule.MyClass"
MyClass = getattr(importlib.import_module("module.submodule"), "MyClass")
# Instantiate the class (pass arguments to the constructor, if needed)
instance = MyClass()

解释

你可能不想使用__import__按名称动态导入模块，因为它不允许你导入子模块:

>>> mod = __import__("os.path")
>>> mod.join
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'join'

在这里是python文档中关于__import__的描述:

注:这是一个高级函数，日常不需要 Python编程，不像importlib.import_module().

相反，使用标准的importlib模块按名称动态导入模块。使用getattr，你可以通过类的名字实例化一个类:

import importlib
my_module = importlib.import_module("module.submodule")
MyClass = getattr(my_module, "MyClass")
instance = MyClass()

你也可以这样写:

import importlib
module_name, class_name = "module.submodule.MyClass".rsplit(".", 1)
MyClass = getattr(importlib.import_module(module_name), class_name)
instance = MyClass()

此代码在python≥2.7(包括python 3)中有效。

小开

可以简单地使用pydoc.locate函数。

from pydoc import locate
my_class = locate("module.submodule.myclass")
instance = my_class()
小开

如果你想从字符串中导入一个类和方法，你应该这样做:

dynamic_import
│   my_class.py
│
└───subfolder
│   │   my_subfolder_module.py
│   │

my_subfolder_module.py

 class MySubfolderClass():
def test_method(self):
print ("Hello World")

main.py

import importlib
  

module = importlib.import_module('subfolder.my_subfolder_module')
class_ = getattr(module, "MySubfolderClass")
method_instance = getattr(class_(),"test_method")
method_instance()
#it will output the result of the test method, which is "Hello World"
小开

使用下面的代码片段:

def to_class(path:str):
try:
from pydoc import locate
class_instance = locate(path)
except ImportError:
print('Module does not exist')
return class_instance or None

用法:

如果你的类名是MyClass并且位于my_app.models.MyClass，那么:

path = "my_app.models.MyClass"
my_class = to_class(path)

提交答案