Python中的惰性导入/懒导入/动态导入（Lazy Import）

　　参考资料：

　　https://cloud.tencent.com/developer/article/2204701

　　https://github.com/huggingface/diffusers

　　想研究这个lazy import的起因是：我想学习一下高级的算法工程师是如何构建一个pip包的，然后我发现在diffusers这个广泛使用的huggingface包的组织方式中出现了_LazyModule这个破东西。

　　查阅资料后知道，_LazyModule这个模块实际上对应了python中的一种lazy import的思想。也就是在整个包很大的情况下不再将所有的包都import，而仅仅在使用的时候进行真正的import。这么做可以极大地缩短整个的import时间。

　　OK，教练我想学这个，我也想让我的包摩登一把？我要怎么做？首先介绍几个点：

　　1. lazy import这个特性虽然python中已经有PEP做阐述，但是并没有官方的built-in包做支持

　　2. 如果我们想在自己的包中使用lazy import，完全可以借鉴别人已经实现好的类（diffusers，就决定是你了）

　　接下来我讲一下如何使用diffuers里面的lazy import代码让我我们的项目实现lazy import，项目组织如下：

　　重点在于两个地方：一个就是utils文件夹，这个文件夹里的import_utils.py包含了我们lazy import类的实现。另一个就是若干__init__.py文件，这些文件就讲我们lazy import的逻辑交代地很清楚。我们首先来看一看lazy import类的实现：

 1 # Inspired by diffusers repo
 2 # https://github.com/huggingface/diffusers/blob/main/src/diffusers/utils/import_utils.py
 3 import os
 4 import importlib.util
 5 from itertools import chain
 6 from types import ModuleType
 7 from typing import Any
 8 
 9 
10 class _LazyModule(ModuleType):
11     """
12     Module class that surfaces all objects but only performs associated imports when the objects are requested.
13     """
14 
15     # Very heavily inspired by optuna.integration._IntegrationModule
16     # https://github.com/optuna/optuna/blob/master/optuna/integration/__init__.py
17     def __init__(self, name, module_file, import_structure, module_spec=None, extra_objects=None):
18         super().__init__(name)
19         self._modules = set(import_structure.keys())
20         self._class_to_module = {}
21         for key, values in import_structure.items():
22             for value in values:
23                 self._class_to_module[value] = key
24         # Needed for autocompletion in an IDE
25         self.__all__ = list(import_structure.keys()) + \
26             list(chain(*import_structure.values()))
27         self.__file__ = module_file
28         self.__spec__ = module_spec
29         self.__path__ = [os.path.dirname(module_file)]
30         self._objects = {} if extra_objects is None else extra_objects
31         self._name = name
32         self._import_structure = import_structure
33 
34     # Needed for autocompletion in an IDE
35     def __dir__(self):
36         result = super().__dir__()
37         # The elements of self.__all__ that are submodules may or may not be in the dir already, depending on whether
38         # they have been accessed or not. So we only add the elements of self.__all__ that are not already in the dir.
39         for attr in self.__all__:
40             if attr not in result:
41                 result.append(attr)
42         return result
43 
44     def __getattr__(self, name: str) -> Any:
45         if name in self._objects:
46             return self._objects[name]
47         if name in self._modules:
48             value = self._get_module(name)
49         elif name in self._class_to_module.keys():
50             module = self._get_module(self._class_to_module[name])
51             value = getattr(module, name)
52         else:
53             raise AttributeError(
54                 f"module {self.__name__} has no attribute {name}")
55 
56         setattr(self, name, value)
57         return value
58 
59     def _get_module(self, module_name: str):
60         try:
61             return importlib.import_module("." + module_name, self.__name__)
62         except Exception as e:
63             raise RuntimeError(
64                 f"Failed to import {self.__name__}.{module_name} because of the following error (look up to see its"
65                 f" traceback):\n{e}"
66             ) from e
67 
68     def __reduce__(self):
69         return (self.__class__, (self._name, self.__file__, self._import_structure))

　　这里不打算细讲，源码在https://github.com/huggingface/diffusers/blob/main/src/diffusers/utils/import_utils.py，我做了一些精简，读者可以直接copy，接下来讲用法：

　　我们首先看一下最高层的包是如何调用这个lazy import类的，也就是package_name下的__init__.py：

# Only support lazy import for now.
# TODO: support slow import
import sys
__version__ = "0.1"

from .utils import (
    _LazyModule
)

_import_structure = {
    "pipelines": []
}

_import_structure["pipelines"].extend(
    [
        "a",
        "LayoutDMPipeline"
    ]
)


sys.modules[__name__] = _LazyModule(
    __name__,
    globals()["__file__"],
    _import_structure,
    module_spec=__spec__,
    extra_objects={"__version__": __version__},
)

　　我们首先用了一个字典将我们想要导入的东西包起来，然后一起喂给_LazyModule，最后由_LazyModule传给sys.modules

　　这个包起来的东西包含了根目录的下级目录，extend的部分是我们最终想要导入的东西。流程是这样：

　　我们想要一个名为a的东西，那么packge就会去找下级目录找a，如果下级目录能够找到a，那么显然可以直接 from XX import a。但是问题出在下级目录显然也没有a，下级目录又要到下下级目录中去找，直至找到。我们不妨看看叶子的__init__.py

# Only support lazy import for now.
# TODO: support slow import

import sys
from ...utils import (
    _LazyModule
)

_import_structure = {}
_import_structure["bar"] = ["a"]


sys.modules[__name__] = _LazyModule(
    __name__,
    globals()["__file__"],
    _import_structure,
    module_spec=__spec__,
)

　　就是这样~

　　最后再顺一遍：我们通过from XX import a，python有如下操作

　　从XX中要a，XX再找pipelines要a，pipelines再找foo要a，foo再找bar要a，最终要到了a。

　　这么一来，from XX import a, from XX.pipelines import a, from XX.pipelines.foo import a, from XX.pipelines.foo.bar import a，全部都是可用的。