Pydantic model basics in FastAPI - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a Pydantic model in FastAPI?

A Pydantic model is a Python class used to define data structures with type annotations. It validates and parses data automatically, ensuring the data matches the expected types.

beginner

How do you define a simple Pydantic model with a name (string) and age (integer)?

You create a class that inherits from BaseModel and add attributes with types, like:<br><pre>from pydantic import BaseModel

class Person(BaseModel):
    name: str
    age: int</pre>

beginner

What happens if you pass wrong data types to a Pydantic model?

Pydantic will raise a validation error explaining which fields have incorrect types. This helps catch mistakes early and keeps data safe.

intermediate

How does Pydantic help with data parsing in FastAPI?

Pydantic automatically converts input data (like JSON) into Python objects with the right types, so you can work with clean, validated data in your code.

intermediate

Can Pydantic models have default values? How?

Yes! You can assign default values to fields in the model class. For example:<br><pre>class Person(BaseModel):
    name: str
    age: int = 30  # default age</pre>

What base class must a Pydantic model inherit from?

A DataModel

B BaseModel

C ModelBase

D Model

Pydantic models always inherit from BaseModel to get validation and parsing features.

If a Pydantic model field is declared as age: int, what happens if you pass a string like '25'?

A It raises an error immediately.

B It stores the string as is.

C It converts the string '25' to integer 25 automatically.

D It ignores the field.

Pydantic tries to convert compatible types automatically, so '25' becomes integer 25.

Which of these is NOT a feature of Pydantic models?

A Data validation

B Default values for fields

C Automatic data parsing

D Database querying

Pydantic does not handle database queries; it focuses on data validation and parsing.

How do you specify an optional field in a Pydantic model?

A Use <code>Optional[type]</code> from typing and provide a default value.

B Just omit the field from the model.

C Use <code>nullable=True</code> in the field definition.

D Use <code>required=False</code> in the class.

Optional fields use typing.Optional and usually have a default value like None.

What will this code output?

from pydantic import BaseModel

class User(BaseModel):
    username: str

user = User(username=123)

A User object with username as string '123'

B Error because username must be string

C User object with username as integer 123

D None

Pydantic converts the integer 123 to string '123' automatically.

Explain how Pydantic models help in validating and parsing data in FastAPI.

Think about how Pydantic checks and converts data for you.

Describe how to define default and optional fields in a Pydantic model.

Defaults and optional fields make your model flexible.

Practice

1. What is the main purpose of a Pydantic model in FastAPI?

easy

A. To validate and organize data automatically

B. To create HTML templates

C. To manage database connections

D. To handle user authentication

Solution

1. Step 1: Understand Pydantic model role

   Pydantic models are designed to check and organize data by validating types and structure. This matches "To validate and organize data automatically".

2. Final Answer:

   To validate and organize data automatically -> Option A

3. Quick Check:

   Pydantic = Data validation and organization [OK]

Hint: Pydantic models are for data validation, not UI or DB [OK]

Common Mistakes:

• Confusing Pydantic with template engines
• Thinking Pydantic manages databases
• Assuming Pydantic handles authentication

2. Which of the following is the correct way to define a simple Pydantic model with a required string field name?

easy

A. class User:
name = str

B. def User():
name: str

C. class User(BaseModel):
name: str

D. class User(BaseModel):
name = 'str'

Solution

1. Step 1: Recall Pydantic model syntax

   A Pydantic model must inherit from BaseModel and define fields with type annotations like class User(BaseModel): name: str. Other options miss inheritance or use assignment instead of type annotation.

2. Final Answer:

   class User(BaseModel):\n name: str -> Option C

3. Quick Check:

   BaseModel + type annotation = correct model [OK]

Hint: Use BaseModel and type annotations for fields [OK]

Common Mistakes:

• Not inheriting from BaseModel
• Using assignment instead of type annotation
• Defining model as a function

3. Given this Pydantic model and code:

from pydantic import BaseModel

class Item(BaseModel):
    id: int
    name: str

item = Item(id='10', name='Book')
print(item.id, type(item.id))

What will be the output?

medium

A. 10

B. '10'

C. Error: id must be int

D. 10

Solution

1. Step 1: Understand Pydantic type coercion

   Pydantic automatically converts compatible types like string '10' to int 10, so print(item.id, type(item.id)) outputs 10 <class 'int'>.

2. Final Answer:

   10 <class 'int'> -> Option D

3. Quick Check:

   Pydantic converts compatible types automatically [OK]

Hint: Pydantic converts strings to int if possible [OK]

Common Mistakes:

• Expecting a type error for string input
• Assuming no conversion happens
• Confusing output type with input type

4. What is wrong with this Pydantic model definition?

from pydantic import BaseModel

class Product(BaseModel):
    price: float = 'free'

medium

A. Class name should be lowercase

B. Default value 'free' is a string, but price expects a float

C. Missing import for BaseModel

D. Field price must be an integer

Solution

1. Step 1: Check field type and default value

   price: float = 'free' is invalid because the string 'free' cannot be converted to float, causing a validation error.

2. Final Answer:

   Default value 'free' is a string, but price expects a float -> Option B

3. Quick Check:

   Field type and default must match [OK]

Hint: Default values must match field types exactly [OK]

Common Mistakes:

• Using wrong default value types
• Ignoring type mismatch errors
• Thinking class names must be lowercase

5. You want to create a Pydantic model User with an optional age field that defaults to 18 if not provided. Which is the correct way?

hard

A. class User(BaseModel):
age: int = 18

B. class User(BaseModel):
age: Optional[int]

C. class User(BaseModel):
age: int = None

D. class User(BaseModel):
age: int

Solution

1. Step 1: Understand optional field with default

   To make age optional with default 18, use age: int = 18. age: Optional[int] lacks default (required but allows None), age: int = None is invalid (None not int), age: int requires a value.

2. Final Answer:

   class User(BaseModel):\n age: int = 18 -> Option A

3. Quick Check:

   Default value makes field optional [OK]

Hint: Assign default value to make field optional [OK]

Common Mistakes:

• Using Optional without default
• Assigning None to non-optional int
• Forgetting to assign default value