如何动态加载Python类

Question

给定一个Python类的字符串，例如my_package.my_module.MyClass，加载它的最佳方法是什么？

换句话说，我正在寻找 Java 中等效的 Class.forName() 函数，Python 中的函数。 它需要在 Google App Engine 上运行。

最好是一个函数，它接受类的 FQN 作为字符串，并返回对该类的引用：

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

Answer 1

如果您不想自己动手，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)."""

Answer 2

如果您使用的是 Django，则可以使用 导入字符串。

是的，我知道 OP 没有要求 django，但我在寻找 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')

Answer 3

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)

Answer 4

这里分享一下我在尝试解决这个问题时在 __import__ 和 importlib 上发现的一些东西。

我正在使用Python 3.7.3。

当我尝试访问模块 abc 中的类 d 时，

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

我们实际上是在尝试寻找 ad。

当使用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

Answer 5

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

修复 python 3.11 上的错误导入

Answer 6

好的，对我来说，这就是它的工作方式（我使用的是 Python 2.7）：

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

然后，b 是类“MyClass”的实例

Answer 7

如果您碰巧已经拥有所需类的实例，则可以使用“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()

Answer 8

Python 有一个内置库 importlib 来完成这项工作。 ：，如何绕过包名称作为参数动态访问模块方法和类方法。 下面给出一个例子。

模块1：

def get_scenario_data():
    return "module1 scenario data"


class Module1:

    def module1_function1(self):
        return "module1_function"

    def module1_function2(self):
        return "module2_function"

模块2：

def get_scenario_data():
    return "module2 scenario data"



class Module2:

    def module2_function1(self):
        return "module2_function1"

    def module2_function2(self):
        return "module2_function2"

ModuleTest：

1. 将根据包名称作为参数动态访问模块方法
2. 将根据包名称作为参数动态访问类方法。

模块测试

import importlib

module = importlib.import_module('pack1.nestedpack1.module1')
print(module.get_scenario_data())
modul1_cls_obj = getattr(module, 'Module1')()
print(modul1_cls_obj.module1_function1())
print(modul1_cls_obj.module1_function2())

module = importlib.import_module('pack1.nestedpack1.module2')
modul2_cls_obj = getattr(module, 'Module2')()
print(modul2_cls_obj.module2_function1())
print(modul2_cls_obj.module2_function2())
print(module.get_scenario_data())

结果

module1 scenario data
module1_function
module2_function
module2_function1
module2_function2
module2 scenario data

Answer 9

PyPI 模块自动加载器和 导入

# PyPI imports
import pkg_resources, subprocess, sys

modules   = {'lxml.etree', 'pandas', 'screeninfo'}
required  = {m.split('.')[0] for m in modules}
installed = {pkg.key for pkg in pkg_resources.working_set}
missing   = required - installed

if missing:
    subprocess.check_call([sys.executable, '-m', 'pip', 'install', '--upgrade', 'pip'])
    subprocess.check_call([sys.executable, '-m', 'pip', 'install', *missing])

for module in set.union(required, modules):
    globals()[module] = __import__(module)

测试：

print(pandas.__version__)
print(lxml.etree.LXML_VERSION)

Answer 10

为现有答案添加一点复杂性......

根据用例，必须显式指定完整路径可能会有些不方便（例如 package.subpackage.module...）您要导入的类/方法的名称。 在 importlib 之上，我们可以利用 __init__.py 使事情变得更加干净。

假设我有一个 python 包，如下所示：

├── modes
│   ├── __init__.py
│   ├── bar.py
│   ├── foo.py
│   ├── modes.py

foo.py，比如说，有一些我们想在程序中其他地方使用的类/函数：

from modes.modes import Mode

class Foo(Mode):
    def __init__(self, *arg, **kwargs):
        super(Foo, self).__init__(*arg, **kwargs)
        
    def run(self):
        self.LOG.info(f"This is FOO!")

使用命令行参数，我可以传递与我想要运行的模式相对应的参数。 我希望能够做到这样的事情：

def set_mode(mode):
    """  """
    import importlib
    module = importlib.import_module('modes.foo')
    getattr(module, mode)().run()

哪个输出：

>> set_mode("Foo")
>> engine_logger:INFO - This is FOO!

工作正常，但是我们真正想要得到的是：

def set_mode(mode):
    """  """
    import importlib
    module = importlib.import_module('modes')  # only import the package, not modules explicitely
    getattr(module, mode)().run()

这会引发错误：

>> set_mode("Foo")
>> AttributeError: module 'modes' has no attribute 'Foo'

但是，我们可以将以下内容添加到 / mode/__init__.py：

from .foo import Foo
from .bar import Bar

那么，我们可以这样做：

>> set_mode("Foo")
>> engine_logger:INFO - This is FOO!

>> set_mode("Bar")
>> engine_logger:INFO - This is BAR!

在其他世界中，我们在 init.py 中导入的所有子模块/函数/类都可以直接使用 importlib.import_module(...) 找到，而不必指定来自外部的完整路径。

Answer 11

我已经创建了这个方法

import importlib
import sys
import os


def import_classes(root_directory: str):
    imported_classes, import_errors = [], []
    for root, dirs, files in os.walk(root_directory):

    if os.path.isabs(root):
        """
            When an absolute path is specified: 'C:\\Users\\admin\\PycharmProjects\\my_project\\_dev\\plugin_discovery\\scenarios'
            we will add the parent directory: 'C:\\Users\\admin\\PycharmProjects\\my_project\\_dev\\plugin_discovery' into "sys.path" variable
            and we will start to create the import path starting from the last parent directory: "scenarios"
        """
        parent_dir, last_parent_directory = os.path.dirname(root), os.path.basename(root)

    else:
        # When a relative path is specified; just add the current working directory into "sys.path" variable
        parent_dir, last_parent_directory = os.getcwd(), root

    """
    Python searches for modules starting from each path specified in "sys.path" list.
        Example:
            Current working directory: "C:\\Users\\admin\\PycharmProjects\\my_project\\_dev\\plugin_discovery"
            last_parent_directory:  "scenarios"

            If current working directory in sys.path, python will try to import the module from:
                "C:\\Users\\admin\\PycharmProjects\\my_project\\_dev\\plugin_discovery\\scenarios"
    
    This is why we add the parent directory into "sys.path" variable
    """
    if parent_dir not in sys.path:
        sys.path.insert(0, parent_dir)

    # Import classes from Python Files
    for filename in files:
        if filename.endswith('.py'):
            module_name = os.path.splitext(filename)[0]  # Remove the file extension to get the module name
            last_parent_directory = last_parent_directory.replace("..\\", "").replace("../", "").replace(".\\", "").replace("./", "")  # Remove relative path prefix
            last_parent_directory = last_parent_directory.replace("\\", ".").replace("/", ".")  # Replace path separators with dots

            module_import_path = f"{last_parent_directory}.{module_name}"  # Build module import path

            try:
                # Force the module to be reimported if it has already been imported
                if module_import_path in sys.modules:
                    del sys.modules[module_import_path]
                
                module_object = importlib.import_module(module_import_path)
                
                # Iterate over items in the module_object
                for attribute_name in dir(module_object):
                    # Get the attributes from the module_object
                    attribute = getattr(module_object, attribute_name)

                    # Check if it's a class and append to list
                    if isinstance(attribute, type):
                        imported_classes.append(attribute)

            except Exception as import_error:
                # In case of import errors; save the import arguments and the error and continue with other files
                import_errors.append((parent_dir, module_import_path, import_error))

return imported_classes, import_errors

现在，假设我们有以下文件夹结构和类：

scenarios_root (directory)
  scenarios (directory)
    scenario1.py
      -> Scenario1 (class)
      -> Scenario2 (class)
      -> Scenario3 (class)
                
    scenario2.py
      -> ScenarioA (class)
      -> ScenarioB (class)
      -> ScenarioC (class)

如果我们执行导入函数：

if __name__ == '__main__':
  imported_clas, import_err = import_classes(r"..\_dev\2023_08_30_plugin_discovery\scenarios_root")
  print(f"Number of imported classes: {len(imported_clas)}")
  print(f"Imported classes: {imported_clas}")
  print(f"Import errors: {import_err}", end="\n\n")

输出：

Number of imported classes: 6
Imported classes: [<class '_dev.2023_08_30_plugin_discovery.scenarios_root.scenarios.scenario1.Scenario1'>, <class '_dev.2023_08_30_plugin_discovery.scenarios_root.scenarios.scenario1.Scenario2'>, <class '_dev.2023_08_30_plugin_discovery.scenarios_root.scenarios.scenario1.Scenario3'>, <class '_dev.2023_08_30_plugin_discovery.scenarios_root.scenarios.scenario2.ScenarioA'>, <class '_dev.2023_08_30_plugin_discovery.scenarios_root.scenarios.scenario2.ScenarioB'>, <class '_dev.2023_08_30_plugin_discovery.scenarios_root.scenarios.scenario2.ScenarioC'>]
Import errors: []

Answer 12

大家可以试试这个：

from pydoc import locate

module = locate("path to py file"))
if module != None:
  classname = getattr(module, "class name")
  if classname != None:
       classobject = classname("arguments")

Answer 13

在 Google App Engine 中，有一个名为 import_string 的 webapp2 函数。 有关详细信息，请参阅此处：https://webapp-improved.appspot.com/api/webapp2 .html

因此，

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

例如，这在 webapp2.Route 中使用，您可以在其中使用处理程序或字符串。

Answer 14

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

Answer 15

从 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

仅当您有一个空 fromlist 时才需要上述函数。 因此，适当的调用将如下所示：

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

Answer 16

import importlib

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