如何在Pydantic类中实现由其他字段值决定类型的字段？

核心思路 #

先建立字符串类型标识与Python原生类型的映射，再通过递归逻辑验证多维列表的嵌套类型，最终根据type字段的值动态校验value字段的合法性。

方案一：根验证器（Root Validator）实现 #

这是最直观的实现方式，利用Pydantic的根验证器在实例化时完成动态类型校验。

步骤1：编写辅助验证函数 #

from typing import Any, Union, List
from pydantic import BaseModel, root_validator, ValidationError

def validate_nested_type(value: Any, target_type: type) -> bool:
    """递归验证值是否为目标类型或目标类型的多维列表"""
    if isinstance(value, target_type):
        return True
    elif isinstance(value, list):
        return all(validate_nested_type(item, target_type) for item in value)
    return False

# 类型映射表：字符串标识对应Python原生类型
TYPE_MAPPING = {
    "int": int,
    "float": float,
    "complex": complex,
    "str": str
}

步骤2：定义模型并添加验证逻辑 #

class Example(BaseModel):
    type: str
    value: Union[int, float, complex, str, List[Any], ...]  # 先声明宽泛的类型范围

    @root_validator(pre=False)
    def validate_value_based_on_type(cls, values):
        type_key = values.get("type")
        value = values.get("value")
        
        # 校验type字段的合法性
        if type_key not in TYPE_MAPPING:
            raise ValueError(f"无效类型 '{type_key}'，仅支持{list(TYPE_MAPPING.keys())}")
        
        target_type = TYPE_MAPPING[type_key]
        # 校验value的类型是否符合要求
        if not validate_nested_type(value, target_type):
            raise ValueError(f"value必须是{target_type.__name__}或{target_type.__name__}的嵌套列表")
        
        return values

测试示例 #

# 合法实例
ex1 = Example(type="int", value=5)
ex2 = Example(type="complex", value=1+2j)
ex3 = Example(type="str", value=["a", ["b", "c"]])
ex4 = Example(type="float", value=[1.5, [2.0, 3.7]])

# 非法实例（会抛出ValidationError）
try:
    ex5 = Example(type="int", value="not an int")
except ValidationError as e:
    print(e)

try:
    ex6 = Example(type="float", value=[1, [2.0, "3"]])
except ValidationError as e:
    print(e)

方案二：自定义动态类型字段 #

如果希望将类型校验逻辑封装得更独立，可以自定义字段类型，结合上下文传递type字段的值完成校验。

from typing import Any
from pydantic import ValidatorFunctionWrapHandler

class DynamicTypeField:
    @classmethod
    def __get_validators__(cls):
        yield cls.validate

    @classmethod
    def validate(cls, value: Any, handler: ValidatorFunctionWrapHandler) -> Any:
        # 从上下文获取type字段的值
        type_key = handler.context.get("type")
        if not type_key:
            raise ValueError("必须先提供'type'字段")
        
        target_type = TYPE_MAPPING.get(type_key)
        if not target_type:
            raise ValueError(f"无效类型 '{type_key}'")
        
        if not validate_nested_type(value, target_type):
            raise ValueError(f"value必须是{target_type.__name__}或{target_type.__name__}的嵌套列表")
        
        return value

# 定义模型
class Example2(BaseModel):
    type: str
    value: DynamicTypeField

    @root_validator(pre=True)
    def set_validation_context(cls, values):
        # 将type字段的值传递给value字段的验证上下文
        if "type" in values:
            cls.__fields__["value"].field_info.context["type"] = values["type"]
        return values

关键注意事项 #

• 版本兼容性：Python 3.8仅支持Pydantic v1.x，需通过pip install "pydantic<2"安装对应版本。
• 多维列表支持：辅助函数validate_nested_type支持任意层数的嵌套列表验证，只要所有元素均为目标类型即可。
• IDE类型提示：动态类型场景下IDE的类型提示会受限，这是动态校验的正常权衡。

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