Pydantic V2: Essentials from Udemy

This is an advanced level course on using the Pydantic V2 library. This course is not for beginners.

I have worked with Pydantic (starting with v1) for many years, and use that experience to bring you a course that focuses on the essential parts of Pydantic you will need to know to use it professionally, effectively and to leverage it's full potential.

Pydantic provides a very flexible framework for modeling, validating and parsing data in Python.

Although Pydantic is often associated with frameworks such FastAPI, it has far broader applications well beyond just From modeling and validating data in databases (like Redis, DynamoDB, Clickhouse), queues (like SQS, ElasticMQ, RabbitMQ), and even CSV files, to even providing argument validation for your custom Python functions.

Pydantic is a very flexible, fast-to-develop, and easy-to-understand data modeling framework that belongs in every serious Python developer's toolkit.

Anytime you have a Python project that contains a fair amount of data validation and modeling into Python classes, Pydantic can be leveraged very effectively.

You can think of Pydantic as somewhat similar to Python's dataclasses, but with an advanced and flexible data validation layer, as well as the easy ability to deserialize (load) and serialize (output) these Python/Pydantic classes into plain dictionaries and JSON. Just like dataclasses, Pydantic uses Python's type hinting capabilities to define data models, but then adds in validation and serialization/deserialization capabilities, which are all fully customizable.

What's inside

Learning objectives

Create advanced pydantic v2 models
Custom validators and serializers
Leverage annotated types with pydantic

Aliases, properties and computed fields
Pydantic applications, including validating python function arguments

Create advanced pydantic v2 models
Custom validators and serializers
Leverage annotated types with pydantic
Aliases, properties and computed fields
Pydantic applications, including validating python function arguments

Syllabus

Introduction

Course Goals and Prerequisites

Course Curriculum Overview

Using the Companion GitHub Repository

The basics of Pydantic models

Validation Aliases

Creating a Pydantic Model

Deserialization

Serialization

Type Coercion

Required vs Optional Fields

Nullable Fields

Combining Nullable and Optional

Inspecting Fields

JSON Schema Generation

Project

Project Solution

Custom Serializers

Learn the most important model level configurations that allows us to tweak Pydantic's default behaviors

Handling Extra Fields

Strict vs Lax Type Coercion

Validating Default Values

Validating Assignments

Mutability

Coercing Numbers to Strings

Standardizing Strings

Handling Python Enums

Before Validators

Learn about field aliases, how to deserialize and serialize with aliases, and custom serializers

Field Aliases and Default Values

Alias Generator Functions

Deserializing by Field Name or Alias

Serialization Aliases

Combining Before and After Validators

Learn about some specialized data types provided by Pydantic, and where to see a complete list of them

Custom Validators using Annotated Types

PositiveInt

Constrained Lists

UUID

Date Related Types

Network Types

Dependent Field Validations

Additional functionality provided by the Field constraints

Numerical Constraints

String Constraints

Default Factories

Additional Field Configurations

Model Composition

Learn how to use properties or cached properties to create calculated fields in your Pydantic models

Learn how Pydantic uses annotated types for maximum reusability

Pydantic and Annotated Types

Annotated Types and Type Variables

Model Inheritance

Learn how to write your own custom validators to go beyond what Pydantic provides

After Validators

Properties

Computed Fields

Final Project Solution Recap

Learn how to attach custom serializers to types using type annotations

The end!

Custom Serializers with Annotated Types

Conclusion

Learn how to use inheritance and composition to create complex nested Pydantic models

Learn how to leverage Pydantic in a variety of scenarios

Consuming a REST API

Ingesting a CSV File

Validating Function Arguments

Model Code Generators

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Pydantic V2: Essentials with these activities:

Review Python Type Hints

Show steps

Review Python's type hinting system to better understand how Pydantic leverages it for data validation and model definition.

Browse courses on Type Hints

Show steps

Read the official Python documentation on type hints.
Practice using type hints in simple Python functions.
Experiment with different type hint annotations.

Review "Python Data Science Handbook"

Show steps

Study data science tools in Python to better understand data manipulation, which is essential for understanding Pydantic's role in data validation and modeling.

View Python Data Science Handbook: Essential Tools... on Amazon

Show steps

Read the chapters on Pandas and NumPy.
Practice data manipulation using Pandas DataFrames.
Experiment with numerical computations using NumPy arrays.

Review "FastAPI Documentation"

Show steps

Study the FastAPI documentation to understand how Pydantic is used in a real-world API development context.

View Melania on Amazon

Show steps

Read the sections on data validation and request body handling.
Study the examples of using Pydantic models with FastAPI.
Experiment with building a simple API using FastAPI and Pydantic.

Four other activities

Expand to see all activities and additional details

Show all seven activities

Build a Data Validation API

Show steps

Create a simple API using FastAPI and Pydantic to validate incoming data, reinforcing your understanding of Pydantic's role in web development.

Show steps

Set up a FastAPI project.
Define Pydantic models for request and response data.
Implement API endpoints that use Pydantic models for validation.
Test the API with various valid and invalid data inputs.

Write a Blog Post on Pydantic Custom Validators

Show steps

Explain how to create custom validators in Pydantic, solidifying your understanding of this advanced feature.

Show steps

Research different types of custom validators in Pydantic.
Write example code demonstrating custom validator implementation.
Explain the purpose and benefits of custom validators.
Publish the blog post on a platform like Medium or personal blog.

Contribute to Pydantic's Documentation

Show steps

Contribute to the Pydantic open-source project by improving documentation, fixing bugs, or adding new features, deepening your understanding of the library's internals.

Show steps

Explore the Pydantic GitHub repository.
Identify areas where documentation can be improved.
Submit a pull request with your changes.
Respond to feedback from the Pydantic maintainers.

Create a Pydantic Code Generator

Show steps

Develop a tool that automatically generates Pydantic models from data schemas (e.g., JSON Schema, database schemas), demonstrating advanced understanding of Pydantic's capabilities.

Show steps

Choose a data schema format (e.g., JSON Schema).
Implement a parser for the chosen schema format.
Generate Pydantic model code based on the parsed schema.
Test the code generator with various schema examples.

Career center

Learners who complete Pydantic V2: Essentials will develop knowledge and skills that may be useful to these careers:

Pydantic V2

Essentials

What's inside

Learning objectives

Syllabus

Save this course

Activities

Career center

Reading list

Share

Similar courses