Pydantic嵌套模型验证递归吗

本文目录导读：

1. 基本嵌套模型验证
2. 深度递归验证
3. 嵌套列表和字典
4. 递归验证与错误处理
5. 复杂嵌套验证示例
6. 性能注意事项

是的，Pydantic 支持嵌套模型的递归验证,让我通过几个例子来说明：

基本嵌套模型验证

from pydantic import BaseModel
from typing import List, Optional
class Address(BaseModel):
    street: str
    city: str
    zip_code: str
class User(BaseModel):
    name: str
    age: int
    address: Address  # 嵌套模型
# 验证时会递归验证 Address
user = User(
    name="Alice",
    age=30,
    address={
        "street": "123 Main St",
        "city": "Beijing",
        "zip_code": "100000"
    }
)
print(user)
# name='Alice' age=30 address=Address(street='123 Main St', city='Beijing', zip_code='100000')

深度递归验证

class Department(BaseModel):
    name: str
    manager: Optional['Department'] = None  # 自引用递归
    employees: List['Employee'] = []        # 循环引用
class Employee(BaseModel):
    name: str
    department: Optional['Department'] = None
# 解决前向引用问题
Department.model_rebuild()
Employee.model_rebuild()
# 构建复杂嵌套结构
dept = Department(
    name="Engineering",
    employees=[
        Employee(name="Bob"),
        Employee(name="Charlie")
    ]
)
print(dept.model_dump())

嵌套列表和字典

class Item(BaseModel):
    name: str
    price: float
class Order(BaseModel):
    order_id: int
    items: List[Item]  # 嵌套列表
    metadata: dict[str, Item] = {}  # 嵌套字典
# 验证嵌套结构
order = Order(
    order_id=1,
    items=[
        {"name": "Book", "price": 29.99},
        {"name": "Pen", "price": 1.99}
    ],
    metadata={
        "special": {"name": "Gift Box", "price": 5.99}
    }
)

递归验证与错误处理

try:
    # 错误的嵌套数据
    user = User(
        name="Bob",
        age=25,
        address={
            "street": "456 Oak St",
            "city": "Shanghai"
            # 缺少 zip_code
        }
    )
except Exception as e:
    print(e)
    # 1 validation error for User
    # address -> zip_code
    #   Field required [type=missing, ...]

复杂嵌套验证示例

from datetime import datetime
from typing import Optional
class Comment(BaseModel):
    id: int
    text: str
    author: str
    created_at: datetime
    replies: List['Comment'] = []  # 递归嵌套
class Post(BaseModel):
    id: int str
    content: str
    tags: List[str]
    comments: List[Comment]  # 多层嵌套
# 构建多层嵌套数据
post = Post(
    id=1,"Pydantic Guide",
    content="...",
    tags=["python", "validation"],
    comments=[
        {
            "id": 1,
            "text": "Great article!",
            "author": "Alice",
            "created_at": "2024-01-01T10:00:00",
            "replies": [
                {
                    "id": 2,
                    "text": "Thanks!",
                    "author": "Author",
                    "created_at": "2024-01-01T11:00:00",
                    "replies": []
                }
            ]
        }
    ]
)

性能注意事项

对于非常深层的递归嵌套，Pydantic 会进行全量验证,这可能会影响性能：

# 深度递归时谨慎使用
class DeepNode(BaseModel):
    value: int
    children: List['DeepNode'] = []
# 设置递归深度限制
from pydantic import field_validator
class SafeNode(BaseModel):
    value: int
    children: List['SafeNode'] = []
    _depth: int = 0
    @field_validator('children')
    @classmethod
    def limit_depth(cls, v, info):
        if info.data.get('_depth', 0) > 100:  # 设置深度限制
            raise ValueError('Maximum depth exceeded')
        return v

Pydantic 确实支持递归嵌套模型验证：

• ✅ 自动递归验证嵌套模型
• ✅ 支持自引用和循环引用
• ✅ 支持嵌套列表、字典等容器
• ✅ 提供详细的错误信息
• ⚠️ 注意深度递归可能影响性能

使用 model_dump() 和 model_validate() 时也会递归处理嵌套结构。