如何在Python中实现模块内类、函数与变量的懒导入？

开发者阿泽

2026-7-8

Python 模块内对象的懒导入实现方案

Python的懒导入讨论已久，PEP690计划在未来将其设为可选内置特性。我正在开发一个CLI包，启动时间至关重要，希望通过懒加载部分模块来提升启动速度。

当前实现方案

基于Python importlib文档中的懒导入实现函数，我修改构建了LazyImport类，可实现顶层模块的懒导入：

import importlib.util
import sys
from types import ModuleType

class LazyImport:
    def __init__(self):
        pass

    def __new__(
            cls,
            name: str,
    ) -> type(ModuleType):
        try:
            return sys.modules[name]
        except KeyError:
            spec = importlib.util.find_spec(name)
            if spec:
                loader = importlib.util.LazyLoader(spec.loader)
                spec.loader = loader
                module = importlib.util.module_from_spec(spec)
                sys.modules[name] = module
                loader.exec_module(module)
                return module
            else:
                raise ModuleNotFoundError(f"No module named '{name}'") from None

注：这是我能想到的将函数转为类的最佳方式，欢迎提供改进建议。

使用示例：用xr = LazyImport('xarray')替代import xarray as xr，此时xarray会被加入sys.modules但未加载到内存（模块脚本未执行），仅在首次引用xr时（如调用xr.DataArray([1,2,3])、print(xr)或直接引用xr）才会加载模块至内存并执行脚本。

需求目标

希望实现模块内类、函数或变量的懒导入，例如用Da = LazyImport('DataArray', _from='xarray')替代from xarray import DataArray as Da，要求xarray仅被加入sys.modules但不加载至内存，直到首次引用Da时才加载模块，且Da直接指向xarray模块的DataArray类。

尝试过的方案

我尝试过xr = LazyImport('xarray')后执行Da = getattr(xr, 'DataArray')，或修改LazyImport类，但每次引用xr时都会加载xarray模块，无法在不加载模块的前提下创建Da变量。

我需要的是对Da变量的懒求值：仅在首次引用Da时才将其解析为xarray模块的DataArray类（此时才执行模块脚本），且无需调用额外方法（如Da.load()），直接通过首次引用触发加载。

我也查看过lazy_loader等第三方库，但未找到支持外部模块内对象懒导入的方案。

可行实现方案

要实现这一需求，需要创建一个代理类，该类在被实际访问（调用、属性读取、字符串转换等）时才触发模块加载和目标对象的获取。以下是修改后的LazyImport实现：

import importlib.util
import sys
from types import ModuleType

class LazyObjectProxy:
    def __init__(self, module_name, attr_name):
        self._module_name = module_name
        self._attr_name = attr_name
        self._obj = None

    def _load(self):
        """延迟加载模块并获取目标对象"""
        if self._obj is None:
            # 查找模块规格
            spec = importlib.util.find_spec(self._module_name)
            if not spec:
                raise ModuleNotFoundError(f"No module named '{self._module_name}'")
            
            # 配置LazyLoader
            if not isinstance(spec.loader, importlib.util.LazyLoader):
                spec.loader = importlib.util.LazyLoader(spec.loader)
            
            # 注册模块到sys.modules（如果尚未存在）
            if self._module_name not in sys.modules:
                module = importlib.util.module_from_spec(spec)
                sys.modules[self._module_name] = module
                spec.loader.exec_module(module)
            else:
                module = sys.modules[self._module_name]
            
            # 获取目标对象
            self._obj = getattr(module, self._attr_name)

    # 代理属性访问
    def __getattr__(self, name):
        self._load()
        return getattr(self._obj, name)

    # 代理调用操作
    def __call__(self, *args, **kwargs):
        self._load()
        return self._obj(*args, **kwargs)

    # 代理字符串表示
    def __repr__(self):
        self._load()
        return repr(self._obj)

    # 代理字符串转换
    def __str__(self):
        self._load()
        return str(self._obj)

    # 按需添加其他魔法方法，比如__len__、__getitem__等
    def __len__(self):
        self._load()
        return len(self._obj)

class LazyImport:
    def __new__(cls, name: str, _from: str = None) -> ModuleType | LazyObjectProxy:
        if _from is None:
            # 原有模块懒导入逻辑
            try:
                return sys.modules[name]
            except KeyError:
                spec = importlib.util.find_spec(name)
                if spec:
                    loader = importlib.util.LazyLoader(spec.loader)
                    spec.loader = loader
                    module = importlib.util.module_from_spec(spec)
                    sys.modules[name] = module
                    loader.exec_module(module)
                    return module
                else:
                    raise ModuleNotFoundError(f"No module named '{name}'") from None
        else:
            # 返回对象代理，实现模块内对象的懒导入
            return LazyObjectProxy(_from, name)

用法示例

模块懒导入（原有功能保持不变）：

xr = LazyImport('xarray')
# 此时xarray未加载，首次调用xr.DataArray时才触发加载
da = xr.DataArray([1,2,3])

模块内对象懒导入：

Da = LazyImport('DataArray', _from='xarray')
# 此时xarray仅注册到sys.modules，未加载内存
# 首次调用Da时触发模块加载和对象获取
da = Da([1,2,3])
# 直接访问属性也会触发加载
print(Da.__name__)  # 输出DataArray

原理说明

LazyObjectProxy作为目标对象的代理，初始化时仅保存模块名和对象名，不执行任何加载操作。
当代理对象被实际使用（调用、读取属性、转换为字符串等）时，_load方法会被触发：先通过LazyLoader加载模块，再从模块中获取目标对象，之后所有操作都直接转发给真实对象。
加载操作仅执行一次，后续访问会直接使用缓存的真实对象。

注意事项

如果目标对象是模块内的子模块，可直接使用模块懒导入逻辑，无需代理。
若需要支持更多特殊操作（比如索引、迭代等），可在LazyObjectProxy中添加对应的魔法方法（如__getitem__、__iter__），内部调用_load后转发给真实对象。

内容的提问来源于stack exchange，提问作者atteggiani

如何在Python中实现模块内类、函数与变量的懒导入？

当前实现方案 #

需求目标 #

尝试过的方案 #

可行实现方案 #

用法示例 #

原理说明 #

注意事项 #