Data Modeling with Pydantic

Applications constantly exchange and process data. Whether the data comes from user input, configuration files, APIs, or databases, ensuring that it is valid and correctly typed is essential. Pydantic is a modern Python library that simplifies data modeling and validation using Python’s type annotations. It automatically validates data, converts compatible types, and produces meaningful validation errors.

Topics Covered

In this module, you’ll learn:

Why Pydantic?
Creating Data Models
Type Validation
Default Values
Optional Fields
Field Validation
Using Annotated
Nested Models
Serialization
Deserialization
Type-safe Programming
Integrating Pydantic with Applications
Best Practices

Try Yourself: 💻 VS Code | 🚀 Colab | 📥 Download
Verify Solutions: 💻 VS Code | 🚀 Colab | 📥 Download

By the end of this module, you’ll be able to create robust, type-safe data models, validate incoming data, serialize and deserialize models, and integrate Pydantic into modern Python applications.

Why Pydantic?

Suppose we want to represent a student. Using a dictionary,

student = {
    "name": "Alice",
    "age": "20"
}

print(student)

Although age should be an integer, Python accepts it as a string. As applications grow, manually validating every field becomes repetitive and error-prone. Pydantic solves this problem by automatically:

Validating input data
Converting compatible data types
Producing informative validation errors
Creating easy-to-use data models

Instead of working with dictionaries, we work with models.

Installing Pydantic

Using uv

uv add pydantic

Using pip

pip install pydantic

Import the base model.

from pydantic import BaseModel

Every Pydantic model inherits from BaseModel.

Python Type Hinting & Generics

Before creating Pydantic models, you must understand how Python conveys data types. Python uses Type Hints (Type Annotations) to declare the expected data types of variables, function arguments, and return values.

Basic Type Hinting Syntax

To annotate a variable or class attribute, use the colon (:) syntax:

name: str = "Alice"
age: int = 20
is_active: bool = True
gpa: float = 3.8

Type Hinting Generics (Collections)

Modern Python (Python 3.9+) supports generic type hinting for collections directly using built-in classes:

Lists (list[type]): Represents a list where all items match a specific type.
scores: list[int] = [90, 85, 95]
Dictionaries (dict[key_type, value_type]): Represents a dictionary with specific key and value types.
metadata: dict[str, int] = {"student_id": 101, "age": 20}
Tuples (tuple[type1, type2, ...]): Represents a tuple with fixed positions and types.
coordinate: tuple[float, float] = (17.385, 78.486)
Sets (set[type]): Represents a unique collection of items of a specific type.
unique_tags: set[str] = {"python", "fastapi"}

Pydantic reads these exact standard type annotations at runtime to parse and validate incoming data dynamically.

Creating Your First Model

A Pydantic model looks similar to a regular Python class.

from pydantic import BaseModel

class Student(BaseModel):

    name: str
    age: int

Creating an object.

student = Student(
    name="Alice",
    age=20
)

print(student)

Output ?

Show Output

name='Alice' age=20

Notice that we didn’t define an __init__() method. Pydantic automatically creates the constructor based on the declared fields.

Accessing Fields

Fields are accessed just like attributes of a regular Python object.

student = Student(
    name="Alice",
    age=20
)

print(student.name)
print(student.age)

Output ?

Show Output

Alice
20

Exercise 1

Create a Book model with the following fields:

title
author
price

Sample Input

book = Book(
    title="Python Essentials",
    author="John",
    price=499.0
)

Expected Output

Python Essentials
John
499.0

Solution

from pydantic import BaseModel

class Book(BaseModel):

    title: str
    author: str
    price: float

book = Book(
    title="Python Essentials",
    author="John",
    price=499.0
)

print(book.title)
print(book.author)
print(book.price)

Exercise 2

Create an Employee model with the following fields:

id
name
department

Sample Input

employee = Employee(
    id=101,
    name="Rahul",
    department="IT"
)

Expected Output

101
Rahul
IT

Solution

from pydantic import BaseModel

class Employee(BaseModel):

    id: int
    name: str
    department: str

employee = Employee(
    id=101,
    name="Rahul",
    department="IT"
)

print(employee.id)
print(employee.name)
print(employee.department)

Type Validation

One of Pydantic’s biggest advantages is automatic type validation.

from pydantic import BaseModel

class Student(BaseModel):

    name: str
    age: int

student = Student(
    name="Alice",
    age="20"
)

print(student)

Output ?

Show Output

name='Alice' age=20

Pydantic automatically converts compatible values whenever possible. If conversion is not possible, a validation error is raised.

student = Student(
    name="Alice",
    age="twenty"
)

Output ?

Show Output

ValidationError

Exercise 1

Create a Product model with the following fields:

name
price

Pass the price as a string. Observe the result.

Solution

from pydantic import BaseModel

class Product(BaseModel):

    name: str
    price: float

product = Product(
    name="Laptop",
    price="49999"
)

print(product)

Exercise 2

Create a Student model with an integer field age. Pass "abc" as the value. Observe the validation error.

Solution

from pydantic import BaseModel

class Student(BaseModel):

    age: int

Student(age="abc")

Default Values

Fields can have default values.

from pydantic import BaseModel

class Student(BaseModel):

    name: str
    course: str = "Python"

student = Student(
    name="Alice"
)

print(student)

Output ?

Show Output

name='Alice' course='Python'

Exercise 1

Create an Employee model with a default country of "India". Expected Output

name='Rahul' country='India'

Solution

from pydantic import BaseModel

class Employee(BaseModel):

    name: str
    country: str = "India"

employee = Employee(
    name="Rahul"
)

print(employee)

Exercise 2

Create a Product model with a default quantity of 1.

Solution

from pydantic import BaseModel

class Product(BaseModel):

    name: str
    quantity: int = 1

product = Product(
    name="Keyboard"
)

print(product)

Optional Fields

Some fields are optional. Modern Python uses the union operator (|) to indicate optional values.

from pydantic import BaseModel

class Student(BaseModel):

    name: str
    email: str | None = None

student = Student(
    name="Alice"
)

print(student)

Output ?

Show Output

name='Alice' email=None

Providing the optional value.

student = Student(
    name="Alice",
    email="alice@example.com"
)

print(student)

Output ?

Show Output

name='Alice' email='alice@example.com'

Exercise 1

Create a Book model with an optional ISBN field.

Solution

from pydantic import BaseModel

class Book(BaseModel):

    title: str
    isbn: str | None = None

book = Book(
    title="Python Essentials"
)

print(book)

Exercise 2

Create an Employee model with an optional phone number.

Solution

from pydantic import BaseModel

class Employee(BaseModel):

    name: str
    phone: str | None = None

employee = Employee(
    name="Rahul"
)

print(employee)

Field Validation

Pydantic allows you to define validation rules for individual fields using the Field() function. Some commonly used validation constraints are:

Constraint	Description
`gt`	Greater than
`ge`	Greater than or equal to
`lt`	Less than
`le`	Less than or equal to
`min_length`	Minimum string length
`max_length`	Maximum string length
`pattern`	Regular expression

Example

from pydantic import BaseModel, Field

class Student(BaseModel):

    name: str = Field(min_length=3, max_length=30)
    age: int = Field(ge=18, le=60)

student = Student(
    name="Alice",
    age=22
)

print(student)

Output ?

Show Output

name='Alice' age=22

Providing invalid data raises a validation error.

Student(
    name="Al",
    age=16
)

Output ?

Show Output

ValidationError

Exercise 1

Create a Product model. Requirements:

Name should contain at least 3 characters.
Price should be greater than 0.

Sample Input

product = Product(
    name="Laptop",
    price=45000
)

Expected Output

name='Laptop' price=45000.0

Solution

from pydantic import BaseModel, Field

class Product(BaseModel):

    name: str = Field(min_length=3)
    price: float = Field(gt=0)

product = Product(
    name="Laptop",
    price=45000
)

print(product)

Exercise 2

Create an Employee model. Requirements:

Age between 18 and 60.

Solution

from pydantic import BaseModel, Field

class Employee(BaseModel):

    name: str
    age: int = Field(ge=18, le=60)

employee = Employee(
    name="Rahul",
    age=30
)

print(employee)

Using `Annotated` (Recommended)

Pydantic v2 recommends using Annotated to separate type information from validation metadata. Instead of

name: str = Field(min_length=3)

the modern approach is

from typing import Annotated
from pydantic import Field

name: Annotated[
    str,
    Field(min_length=3)
]

This keeps the type declaration clean and improves compatibility with IDEs and type checkers.

Example

from typing import Annotated
from pydantic import BaseModel, Field

class Product(BaseModel):

    name: Annotated[
        str,
        Field(min_length=3, max_length=50)
    ]

    price: Annotated[
        float,
        Field(gt=0)
    ]

product = Product(
    name="Keyboard",
    price=999
)

print(product)

Output ?

Show Output

name='Keyboard' price=999.0

Why Prefer `Annotated`?

Keeps the type separate from validation rules.
Recommended in Pydantic v2.
Extensively used in FastAPI.
Improves readability.

Exercise 1

Create a Book model. Requirements:

Title should contain at least 3 characters.
Price should be greater than 0.

Sample Input

book = Book(
    title="Python",
    price=499
)

Expected Output

title='Python' price=499.0

Solution

from typing import Annotated
from pydantic import BaseModel, Field

class Book(BaseModel):

    title: Annotated[
        str,
        Field(min_length=3)
    ]

    price: Annotated[
        float,
        Field(gt=0)
    ]

book = Book(
    title="Python",
    price=499
)

print(book)

Exercise 2

Create a Student model. Requirements:

Age between 18 and 30.

Solution

from typing import Annotated
from pydantic import BaseModel, Field

class Student(BaseModel):

    name: str

    age: Annotated[
        int,
        Field(ge=18, le=30)
    ]

student = Student(
    name="Alice",
    age=22
)

print(student)

Nested Models

Real-world data often contains other objects. Pydantic allows one model to contain another model.

from pydantic import BaseModel

class Address(BaseModel):

    city: str
    state: str


class Student(BaseModel):

    name: str
    address: Address


student = Student(
    name="Alice",
    address={
        "city": "Hyderabad",
        "state": "Telangana"
    }
)

print(student)

Output ?

Show Output

name='Alice' address=Address(city='Hyderabad', state='Telangana')

Notice that Pydantic automatically converts the dictionary into an Address object.

Exercise 1

Create a Company model and use it inside an Employee model. Sample Input

employee = Employee(
    name="Rahul",
    company={
        "name": "OpenAI",
        "location": "San Francisco"
    }
)

Solution

from pydantic import BaseModel

class Company(BaseModel):

    name: str
    location: str


class Employee(BaseModel):

    name: str
    company: Company

employee = Employee(
    name="Rahul",
    company={
        "name": "OpenAI",
        "location": "San Francisco"
    }
)

print(employee)

Exercise 2

Create a Course model inside a Student model.

Solution

from pydantic import BaseModel

class Course(BaseModel):

    title: str
    duration: int


class Student(BaseModel):

    name: str
    course: Course

student = Student(
    name="Alice",
    course={
        "title": "Python",
        "duration": 30
    }
)

print(student)

Collections of Models

A field can also contain multiple nested models.

from pydantic import BaseModel

class Book(BaseModel):

    title: str


class Library(BaseModel):

    books: list[Book]


library = Library(
    books=[
        {"title": "Python"},
        {"title": "FastAPI"}
    ]
)

print(library)

Output ?

Show Output

books=[Book(title='Python'), Book(title='FastAPI')]

Exercise 1

Create a Department model containing multiple employees.

Solution

from pydantic import BaseModel

class Employee(BaseModel):

    name: str


class Department(BaseModel):

    employees: list[Employee]

department = Department(
    employees=[
        {"name": "Alice"},
        {"name": "Bob"}
    ]
)

print(department)

Exercise 2

Create an Order model containing multiple products.

Solution

from pydantic import BaseModel

class Product(BaseModel):

    name: str


class Order(BaseModel):

    products: list[Product]

order = Order(
    products=[
        {"name": "Laptop"},
        {"name": "Mouse"}
    ]
)

print(order)

Serialization

Serialization is the process of converting a Python object into a format that can be stored or transmitted. Pydantic provides the model_dump() method to convert a model into a Python dictionary.

Example

from pydantic import BaseModel

class Student(BaseModel):

    name: str
    age: int

student = Student(
    name="Alice",
    age=20
)

print(student.model_dump())

Output ?

Show Output

{'name': 'Alice', 'age': 20}

Converting to JSON

Use model_dump_json() to generate a JSON string.

student = Student(
    name="Alice",
    age=20
)

print(student.model_dump_json(indent=4))

Output ?

Show Output

{
    "name": "Alice",
    "age": 20
}

Exercise 1

Create an Employee model and convert it into a dictionary.

Solution

from pydantic import BaseModel

class Employee(BaseModel):

    id: int
    name: str

employee = Employee(
    id=101,
    name="Rahul"
)

print(employee.model_dump())

Exercise 2

Convert a Book model into JSON.

Solution

from pydantic import BaseModel

class Book(BaseModel):

    title: str
    price: float

book = Book(
    title="Python",
    price=499
)

print(book.model_dump_json(indent=4))

Deserialization

Deserialization is the process of creating a model from external data.

Creating a Model from a Dictionary

Use model_validate().

from pydantic import BaseModel

class Student(BaseModel):

    name: str
    age: int

data = {
    "name": "Alice",
    "age": "20"
}

student = Student.model_validate(data)

print(student)

Output ?

Show Output

name='Alice' age=20

Creating a Model from JSON

Use model_validate_json().

from pydantic import BaseModel

class Student(BaseModel):

    name: str
    age: int

data = """
{
    "name":"Alice",
    "age":20
}
"""

student = Student.model_validate_json(data)

print(student)

Output ?

Show Output

name='Alice' age=20

Exercise 1

Create an Employee model from a dictionary.

Solution

from pydantic import BaseModel

class Employee(BaseModel):

    id: int
    name: str

employee = Employee.model_validate(
    {
        "id":101,
        "name":"Rahul"
    }
)

print(employee)

Exercise 2

Create a Book model from a JSON string.

Solution

from pydantic import BaseModel

class Book(BaseModel):

    title: str
    price: float

book = Book.model_validate_json(
"""
{
    "title":"Python",
    "price":499
}
"""
)

print(book)

Type-safe Programming

Pydantic encourages type-safe programming by ensuring that data always conforms to the expected model. Instead of working with dictionaries,

student = {
    "name":"Alice",
    "age":20
}

we work with objects.

student = Student(
    name="Alice",
    age=20
)

print(student.name)

This provides several benefits:

Better code completion in IDEs.
Early error detection.
Improved readability.
Self-documenting code.
Easier refactoring.

Example

from pydantic import BaseModel

class Product(BaseModel):

    name: str
    price: float

product = Product(
    name="Keyboard",
    price=999
)

print(product.price)

Output ?

Show Output

999.0

Exercise 1

Create a Customer model and access its fields using dot notation.

Solution

from pydantic import BaseModel

class Customer(BaseModel):

    name: str
    city: str

customer = Customer(
    name="Alice",
    city="Hyderabad"
)

print(customer.name)
print(customer.city)

Exercise 2

Create an Order model and display the product name.

Solution

from pydantic import BaseModel

class Order(BaseModel):

    product: str
    quantity: int

order = Order(
    product="Laptop",
    quantity=2
)

print(order.product)

Integrating Pydantic with Applications

Pydantic models are widely used in modern Python applications. Common use cases include:

Validating user input.
Reading configuration.
Working with APIs.
Processing JSON data.
Request and response models in FastAPI.

Example

Suppose an application receives user information.

from pydantic import BaseModel

class User(BaseModel):

    name: str
    email: str

data = {
    "name":"Alice",
    "email":"alice@example.com"
}

user = User.model_validate(data)

print(user)

Output ?

Show Output

name='Alice' email='alice@example.com'

Instead of manually validating every field, Pydantic performs the validation automatically. This makes applications simpler, safer, and easier to maintain.

Exercise 1

Create a LoginRequest model and validate a dictionary.

Solution

from pydantic import BaseModel

class LoginRequest(BaseModel):

    username: str
    password: str

request = LoginRequest.model_validate(
    {
        "username":"admin",
        "password":"secret"
    }
)

print(request)

Exercise 2

Create a RegistrationRequest model and validate incoming data.

Solution

from pydantic import BaseModel

class RegistrationRequest(BaseModel):

    name: str
    email: str

request = RegistrationRequest.model_validate(
    {
        "name":"Alice",
        "email":"alice@example.com"
    }
)

print(request)

Best Practices

Prefer Annotated with Field() for validation.
Use meaningful model names.
Group related fields into nested models.
Reuse models whenever possible.
Keep validation rules close to the fields.
Prefer Pydantic models over plain dictionaries for structured data.
Use model_dump() and model_dump_json() for serialization.
Use model_validate() and model_validate_json() for deserialization.
Design models that accurately represent your application’s data.

Practice

To reinforce what you’ve learned in this section, practice with the interactive follow-along notebook:

Follow-Along Practice

Practice creating BaseModel schemas, field validations with Field(), separating types with Annotated, nested models, and model serialization.💻 VS Code | 🚀 Colab | 📥 Download

Summary

In this module, you learned how Pydantic simplifies data modeling and validation in modern Python applications.

Key Concepts Covered

Why Pydantic?
Creating Data Models
Type Validation
Default Values
Optional Fields
Field Validation
Using Annotated
Nested Models
Collections of Models
Serialization
Deserialization
Type-safe Programming
Integrating Pydantic with Applications
Best Practices

Pydantic combines Python’s type annotations with automatic validation, making it easy to build reliable, maintainable, and type-safe applications. It has become a fundamental library in the modern Python ecosystem and is extensively used in frameworks such as FastAPI.

​Data Modeling with Pydantic

​Topics Covered

​Why Pydantic?

​Installing Pydantic

​Python Type Hinting & Generics

​Basic Type Hinting Syntax

​Type Hinting Generics (Collections)

​Creating Your First Model

​Accessing Fields

​Exercise 1

​Exercise 2

​Type Validation

​Exercise 1

​Exercise 2

​Default Values

​Exercise 1

​Exercise 2

​Optional Fields

​Exercise 1

​Exercise 2

​Field Validation

​Example

​Exercise 1

​Exercise 2

​Using Annotated (Recommended)

​Example

​Why Prefer Annotated?

​Exercise 1

​Exercise 2

​Nested Models

​Exercise 1

​Exercise 2

​Collections of Models

​Exercise 1

​Exercise 2

​Serialization

​Example

​Converting to JSON

​Exercise 1

​Exercise 2

​Deserialization

​Creating a Model from a Dictionary

​Creating a Model from JSON

​Exercise 1

​Exercise 2

​Type-safe Programming

​Example

​Exercise 1

​Exercise 2

​Integrating Pydantic with Applications

​Example

​Exercise 1

​Exercise 2

​Best Practices

​Practice

Follow-Along Practice

​Summary

​Key Concepts Covered

Data Modeling with Pydantic

Topics Covered

Why Pydantic?

Installing Pydantic

Python Type Hinting & Generics

Basic Type Hinting Syntax

Type Hinting Generics (Collections)

Creating Your First Model

Accessing Fields

Exercise 1

Exercise 2

Type Validation

Exercise 1

Exercise 2

Default Values

Exercise 1

Exercise 2

Optional Fields

Exercise 1

Exercise 2

Field Validation

Example

Exercise 1

Exercise 2

Using `Annotated` (Recommended)

Example

Why Prefer `Annotated`?

Exercise 1

Exercise 2

Nested Models

Exercise 1

Exercise 2

Collections of Models

Exercise 1

Exercise 2

Serialization

Example

Converting to JSON

Exercise 1

Exercise 2

Deserialization

Creating a Model from a Dictionary

Creating a Model from JSON

Exercise 1

Exercise 2

Type-safe Programming

Example

Exercise 1

Exercise 2

Integrating Pydantic with Applications

Example

Exercise 1

Exercise 2

Best Practices

Practice

Summary

Key Concepts Covered