Pydantic v2 入门教程：模型、字段、验证器

本问将覆盖 Pydantic v2 中 API 的每个核心模块：如何定义模型、如何给字段附加约束、怎么写验证器、怎么组合嵌套结构、怎么控制序列化行为，以及最后如何生成 JSON Schema。所有示例都基于 Pydantic v2 和 Python 3.10，每个代码清单都是完整可运行的，可以放心粘贴测试。

用 BaseModel 定义模型

Pydantic 的基石就是 BaseModel。继承它之后，你只需要用类型注解声明字段就行了——Pydantic 会在类创建时自动检查注解、构建校验 schema，后面每次实例化都会用这套 schema 去验证输入数据。

无默认值的字段就是必填项；有默认值或声明为 T | None 且默认 None 的字段就是可选的。看一个最简单的例子：

from pydantic import BaseModel

class Address(BaseModel):
    street: str
    city: str
    state: str
    zip_code: str
    country: str = "US"           # 可选，默认 "US"
    apartment: str | None = None  # 可选，默认 None

addr = Address(
    street="123 Main St",
    city="Springfield",
    state="IL",
    zip_code="62704",
)
print(addr)
# street='123 Main St' city='Springfield' state='IL' zip_code='62704' country='US' apartment=None

要是光靠注解加默认值还不够用，那就上 Field()。它可以给字段附加元数据、约束和文档说明，让模型更规范。

from pydantic import BaseModel, Field

class Product(BaseModel):
    name: str = Field(
        min_length=1, max_length=200,
        title="Product Name",
        description="商品显示名称",
        examples=["Widget Pro"]
    )
    sku: str = Field(
        pattern=r"^[A-Z]{2,4}-\d{4,8}$",
        description="库存单位，格式 'XX-0000'",
        examples=["WP-12345"]
    )
    price: float = Field(
        gt=0, le=999_999.99,
        description="美元价格，必须为正"
    )
    quantity: int = Field(
        default=0, ge=0,
        description="库存数量，不可为负"
    )
    category: str = Field(
        validation_alias="product_category",
        description="来自目录系统的产品类别"
    )

product = Product(
    name="Widget Pro", sku="WP-12345", price=29.99,
    quantity=150, product_category="Electronics"
)
print(product.category)  # Electronics

：如果你有几个地方需要重复用同样的约束条件（比如“正整数”或“不超过100个字符的字符串”），可以用 Annotated 把它定义成一个类型别名，然后直接复用。效果跟 Field() 一样，但更利于跨模型共享。

from typing import Annotated
from pydantic import BaseModel, Field

PositiveInt = Annotated[int, Field(gt=0)]
ShortStr = Annotated[str, Field(min_length=1, max_length=100)]

class Widget(BaseModel):
    quantity: PositiveInt
    name: ShortStr

两种风格在校验行为上是等价的，但如果想让类型跨多个模型复用，强烈推荐 Annotated。

：默认情况下 Pydantic 采用宽松模式——兼容类型会自动转换，不会直接拒绝。这在处理 JSON 数据（全是字符串）时非常省心。比如：

event = Event(name="PyCon", attendees="500", event_date="2025-05-15")
# "500" 自动转 int，"2025-05-15" 自动转 date

如果你想走严格模式（拒绝任何隐式转换），可以在模型级设置 model_config = ConfigDict(strict=True)，也可以在字段级加 Field(strict=True) 或 Annotated[int, Strict()]。一般来说，数据源已经是强类型（如内部 Python 调用、强类型数据库驱动）时用严格模式更安全；解析 JSON 或表单数据时建议保持宽松。

验证器：field_validator 和 model_validator

Pydantic 内置的类型系统和 Field() 约束已经覆盖了绝大多数校验需求。但如果你需要更灵活的定制逻辑，就可以上自定义验证器了。

@field_validator 有四种模式：

• mode='after'（默认）：Pydantic 内置校验跑完之后再执行，收到的是已经解析好的、带类型的值。
• mode='before'：在内置校验之前跑，收到的是原始输入（可能是字符串、dict 等）。
• mode='wrap'：包裹内置校验，可以做日志或错误转译。
• mode='plain'：完全替代内置校验，自己全权接管校验逻辑。

class User(BaseModel):
    username: str = Field(min_length=3, max_length=30)
    email: str

    @field_validator("username", mode="before")
    @classmethod
    def normalize_username(cls, v: object) -> str:
        if not isinstance(v, str):
            raise ValueError("Username must be a string")
        return v.strip().lower()

    @field_validator("email", mode="after")
    @classmethod
    def validate_email_domain(cls, v: str) -> str:
        if "@" not in v:
            raise ValueError("Invalid email: missing '@'")
        return v

上面的例子中，mode='before' 的验证器先执行，把输入的空格去掉并转小写，然后 Pydantic 才会检查 min_length=3 等约束。

如果需要验证依赖多个字段的逻辑（比如“开始日期必须早于结束日期”），就用 @model_validator：

class DateRange(BaseModel):
    start: date
    end: date
    label: str | None = None

    @model_validator(mode="after")
    def check_start_before_end(self) -> DateRange:
        if self.start >= self.end:
            raise ValueError(
                f"'start' ({self.start}) must be before 'end' ({self.end})"
            )
        return self

注意：After 模式的模型验证器必须 return self，否则返回 None 会导致不可空字段报 ValidationError。

如果你想在字段校验之前就重塑整个输入数据（比如让模型同时兼容元组和 dict），可以用 mode='before' 的模型验证器：

class Coordinate(BaseModel):
    x: float
    y: float

    @model_validator(mode="before")
    @classmethod
    def accept_tuple(cls, data: object) -> object:
        if isinstance(data, (list, tuple)) and len(data) == 2:
            return {"x": data[0], "y": data[1]}
        return data

print(Coordinate.model_validate((3.0, 4.0)))
# x=3.0 y=4.0

：通过 info.context 可以把每次调用的数据（如用户权限级别）传进验证器，而不需要把这些数据加到模型本身。这在实际业务中非常实用：

class Discount(BaseModel):
    price: float
    discount_pct: float

    @field_validator("discount_pct", mode="after")
    @classmethod
    def cap_discount(cls, v: float, info: ValidationInfo) -> float:
        max_discount = (info.context or {}).get("max_discount", 50.0)
        if v > max_discount:
            raise ValueError(f"Discount cannot exceed {max_discount}%")
        return v

Discount.model_validate(
    {"price": 100.0, "discount_pct": 30.0},
    context={"max_discount": 20.0},
)

自定义序列化器

@field_serializer 可以让你精确控制某个字段在导出时的格式。比如把一个 datetime 统一输出成 UTC 的 ISO 格式：

class LogEntry(BaseModel):
    message: str
    timestamp: datetime

    @field_serializer("timestamp")
    def serialize_timestamp(self, v: datetime) -> str:
        if v.tzinfo is None:
            v = v.replace(tzinfo=timezone.utc)
        return v.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")

嵌套模型与递归结构

一个模型直接作为另一个模型字段的类型注解，天然就能支持嵌套。Pydantic 会自动递归地校验每一层：

class Employee(BaseModel):
    name: str
    title: str
    employee_id: int = Field(gt=0)

class Department(BaseModel):
    name: str
    head: Employee
    members: list[Employee] = []

class Company(BaseModel):
    name: str
    founded: int
    departments: list[Department]

每个嵌套的 dict 都会按照对应的模型进行校验。如果 Bob 的 employee_id 传了 "not_a_number"，错误信息会精确指向 departments -> 0 -> members -> 0 -> employee_id，定位非常方便。

处理自引用结构（比如树）时，只需要加上 from __future__ import annotations：

from __future__ import annotations

class TreeNode(BaseModel):
    value: str
    children: list[TreeNode] = []

model_dump 和 model_dump_json

这两个方法是序列化的核心。它们有三种输出形态：

• model_dump() 输出原生的 Python dict（类型保持为 Python 对象，比如 datetime、Decimal）。
• model_dump(mode='json') 输出 JSON 兼容的值（所有类型都转成了字符串、数字等）。
• model_dump_json() 直接输出 JSON 字符串，绕过 json.dumps()，底层走 Rust 核心，性能更好。

三个方法都支持 exclude_unset、exclude_none、include、exclude_defaults 等过滤参数，灵活控制序列化结果。

输入侧同理：model_validate() 解析 dict，model_validate_json() 解析原始 JSON 字符串，后者也直接走 Rust 核心，速度更快。

别名机制有三类：alias（输入输出都用）、validation_alias（仅输入）、serialization_alias（仅输出）。配合 AliasPath 和 AliasChoices 可以处理更复杂的情况，比如嵌套访问或者多个候选字段名。

JSON Schema 生成

调用 Item.model_json_schema() 就能直接输出该模型的 JSON Schema。你在 Field() 里写的 title、description、examples 以及各种约束（如 min_length、gt）都会自动流入 schema 中，不用手动维护文档。

Pydantic Dataclasses 和 TypeAdapter

如果你喜欢用标准库的 @dataclass 语法，但想享受 Pydantic 的校验和约束，可以用 from pydantic.dataclasses import dataclass。它和 BaseModel 一样支持验证器和 Field，但没有 model_dump() 这些便捷方法。如果需要序列化，可以通过 TypeAdapter 来包装。

TypeAdapter 更强大的地方在于，它不需要定义任何模型就能直接验证独立类型，比如：

int_list_adapter = TypeAdapter(list[int])
int_list_adapter.validate_python(["1", "2", "3"])  # [1, 2, 3]
int_list_adapter.validate_json('[4, 5, 6]')       # [4, 5, 6]

它特别适合以下场景：验证函数参数、校验集合类型、为 API 类型生成 JSON Schema。

总结

最后用几个常见问题来收尾：

• field_validator 还是 model_validator？
  单字段校验用 @field_validator，精确且快。需要同时访问多个字段时用 @model_validator(mode='after')。

• BaseModel 与 @dataclass 的区别？
  BaseModel 功能全面（自带序列化、schema 等）。@dataclass 语法更接近标准库，但不带模型方法，序列化需要借助 TypeAdapter。

• 如何让字段可选且带默认值？
  直接写 field: str = "default" 或 field: str | None = None。

• 不建模型怎么验证 JSON？
  用 TypeAdapter(list[int]).validate_json('[1,2,3]')。

• 传了别名但验证器不跑？
  validation_alias 默认只吃别名，要同时接受原字段名可以加 ConfigDict(populate_by_name=True)。