Pydantic Field Reference

Quick-lookup reference for Pydantic v2 BaseModel definitions, Field constraints, validators, model_config options, and serialization/deserialization methods.

Learning Focus

By the end of this reference you can: quickly recall Pydantic v2 syntax for models, fields, validators, config, and the v1→v2 migration map.

BaseModel Definition

from pydantic import BaseModel, Field, ConfigDict

class MyModel(BaseModel):
    model_config = ConfigDict(
        from_attributes=True,    # ORM mode
        populate_by_name=True,   # Allow field name + alias
        str_strip_whitespace=True,
        use_enum_values=True,
        extra="ignore",          # "ignore" | "allow" | "forbid"
    )

Field Types

str             String
int             Integer
float           Float
bool            Boolean
bytes           Raw bytes
datetime        ISO 8601 string auto-parsed
date            Date string
time            Time string
UUID            UUID string validated
Decimal         Precise decimal
list[T]         Typed list
tuple[T, ...]   Typed tuple
dict[str, T]    Typed dict
set[T]          Typed set
T | None        Optional T
Union[T, U]     T or U
Literal["a","b"] Exact values
EmailStr        Validated email (email-validator)
HttpUrl         Validated URL
AnyUrl          Any URL

Field() Constraints

Field(...)              Required field (no default)
Field(default)          Optional with default
Field(default_factory=list)  Callable default

# String constraints
min_length=N
max_length=N
pattern=r"regex"
strip_whitespace=True

# Numeric constraints
gt=N    # >
ge=N    # >=
lt=N    # <
le=N    # <=
multiple_of=N

# Other
alias="externalName"
serialization_alias="outputName"
exclude=True         # Never serialized
title="Field Title"
description="Description"
examples=["example"]

Validators

from pydantic import field_validator, model_validator

# Field validator
@field_validator("username")
@classmethod
def validate_username(cls, v: str) -> str:
    return v.lower()

# Model validator (after all fields)
@model_validator(mode="after")
def check_passwords(self) -> "Model":
    if self.password != self.confirm_password:
        raise ValueError("Passwords must match")
    return self

# Computed field
from pydantic import computed_field

@computed_field
@property
def full_name(self) -> str:
    return f"{self.first_name} {self.last_name}"

Serialization

model = MyModel(...)

model.model_dump()                        # dict
model.model_dump(mode="json")             # JSON-safe dict
model.model_dump(by_alias=True)           # Use aliases as keys
model.model_dump(exclude={"password"})    # Exclude fields
model.model_dump(include={"id", "name"}) # Include only these
model.model_dump(exclude_none=True)       # Omit None values
model.model_dump(exclude_unset=True)      # Omit unset fields

model.model_dump_json()                   # JSON string

# Parse from dict/object
MyModel.model_validate(data_dict)         # From dict
MyModel.model_validate(orm_object)        # From ORM (from_attributes=True)
MyModel.model_validate_json(json_str)     # From JSON string

Common Pydantic v1 → v2 Changes

.dict()           → .model_dump()
.json()           → .model_dump_json()
.parse_obj()      → .model_validate()
.parse_raw()      → .model_validate_json()
class Config      → model_config = ConfigDict(...)
orm_mode=True     → from_attributes=True
@validator        → @field_validator
@root_validator   → @model_validator
schema_extra      → json_schema_extra

Common Pitfalls

Pitfall	Cause / Symptom	Fix
`model.dict()` raises `AttributeError`	Using Pydantic v1 API on v2	Use `model.model_dump()` instead
`from_attributes` not working	Forgot `model_config` or used v1 `orm_mode`	Set `model_config = ConfigDict(from_attributes=True)`
Extra fields silently accepted	Default `extra="ignore"` in Pydantic v2	Set `extra="forbid"` to reject unknown fields

Hands-On Practice

quick-pydantic-test.py
from pydantic import BaseModel, Field, field_validator, ConfigDict

class OrderItem(BaseModel):
    model_config = ConfigDict(from_attributes=True, extra="forbid")
    product: str = Field(..., min_length=1)
    quantity: int = Field(..., ge=1)
    price: float = Field(..., gt=0)

    @field_validator("product")
    @classmethod
    def strip_product(cls, v: str) -> str:
        return v.strip()

item = OrderItem(product="  Widget  ", quantity=2, price=19.99)
print(item.model_dump())  # {'product': 'Widget', 'quantity': 2, 'price': 19.99}

# Verify validation
try:
    OrderItem(product="", quantity=2, price=19.99)
    print("Should have raised ValidationError")
except Exception as e:
    print(f"Validation caught: {type(e).__name__}")

BaseModel Definition​

Field Types​

Field() Constraints​

Validators​

Serialization​

Common Pydantic v1 → v2 Changes​

Common Pitfalls​

Hands-On Practice​

What's Next​