Python动态属性的类型标注：TYPE_CHECKING与更优实践

import importlib

class _ModuleRegistry(object):
    _modules = {}

    def defer_import(
        self,
        import_statement: str,
        import_name: str,
    ):
        """
        延迟导入模块，并将指定名称的对象作为属性设置。
        """
        self._modules[import_name] = import_statement
        setattr(self, import_name, None) # 初始设置为None

    def __getattribute__(self, __name: str):
        """
        当访问属性时，如果属性是延迟导入的，则执行导入并缓存结果。
        """
        # 避免无限递归和访问内部属性
        if (
            __name
            and not __name.startswith("__")
            and __name not in ("defer_import", "_modules")
        ):
            import_statement = self._modules.get(__name)
            if import_statement:
                # 警告：使用 exec() 存在安全风险且难以类型检查
                exec(import_statement, globals()) # 在全局命名空间执行导入
                setattr(self, __name, globals().get(__name)) # 缓存导入的对象
            ret_val = globals().get(__name) # 从全局命名空间获取对象
            if ret_val:
                return ret_val
            else:
                return None
        else:
            # 访问非延迟导入的属性或内部属性
            val = super().__getattribute__(__name)
            return val

registry = _ModuleRegistry()
registry.defer_import("from pandas import read_csv", "read_csv")

# 此时，类型检查器无法知道 registry.read_csv 是一个函数
# print(registry.read_csv)

from typing import TYPE_CHECKING, Any

# 实际的 _ModuleRegistry 类定义，在运行时使用
class _ModuleRegistry:
    _modules: dict[str, str] = {}

    def defer_import(
        self,
        import_statement: str,
        import_name: str,
    ):
        self._modules[import_name] = import_statement
        setattr(self, import_name, None)

    def __getattribute__(self, __name: str) -> Any:
        if (
            __name
            and not __name.startswith("__")
            and __name not in ("defer_import", "_modules")
        ):
            import_statement = self._modules.get(__name)
            if import_statement:
                # 警告：exec() 存在安全风险
                exec(import_statement, globals())
                setattr(self, __name, globals().get(__name))
            ret_val = globals().get(__name)
            if ret_val:
                return ret_val
            else:
                return None
        else:
            return super().__getattribute__(__name)

# 仅在类型检查时生效的代码块
if TYPE_CHECKING:
    # 导入需要延迟加载的模块中的具体对象，并为其提供类型提示
    from pandas import read_csv
    # 创建一个虚拟的 registry 对象，并为其添加类型已知的属性
    # 这里使用 Any 类型来表示 _ModuleRegistry 的实例，
    # 或者可以定义一个仅用于类型检查的 Registry 协议
    registry: _ModuleRegistry = Any() # 或者直接使用 _ModuleRegistry()
    registry.read_csv = read_csv # 为类型检查器显式声明属性类型
else:
    # 运行时使用的 registry 实例
    registry = _ModuleRegistry()

# 运行时调用延迟导入
registry.defer_import("from pandas import read_csv", "read_csv")

# 此时，类型检查器将能够识别 registry.read_csv 的类型
# print(registry.read_csv)
# reveal_type(registry.read_csv) # Mypy 将显示其为函数类型

class DataProcessor:
    def process_csv(self, file_path: str):
        # 仅在调用此方法时才导入 pandas
        from pandas import read_csv
        df = read_csv(file_path)
        # ... 对 df 进行操作
        return df

processor = DataProcessor()
# 此时 pandas 尚未导入
result = processor.process_csv("data.csv")

from typing import Callable, TypeVar, Any

_T = TypeVar('_T')

class LazyLoader:
    def __init__(self, import_path: str, obj_name: str):
        self._import_path = import_path
        self._obj_name = obj_name
        self._loaded_obj: Any = None

    def __get__(self, instance: Any, owner: Any) -> Any:
        if self._loaded_obj is None:
            # 动态导入模块并获取对象
            module = importlib.import_module(self._import_path)
            self._loaded_obj = getattr(module, self._obj_name)
        return self._loaded_obj

class MyRegistry:
    # 使用 LazyLoader 描述符
    read_csv: Callable[..., Any] = LazyLoader("pandas", "read_csv")
    # 其他属性...

registry = MyRegistry()
# 此时 pandas 尚未导入
df = registry.read_csv("another_data.csv") # 第一次访问时导入并缓存