Pydantic model definition in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a Pydantic model with a single field 'name' of type string.

FastAPI

from pydantic import BaseModel

class User([1]):
    name: str

Drag options to blanks, or click blank then click option'

ABaseModel

BModel

CSchema

DDataModel

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong base class name like Model or Schema.

Not inheriting from any class.

The Pydantic model must inherit from BaseModel to work properly.

2fill in blank

medium

Complete the code to add an integer field 'age' to the Pydantic model.

FastAPI

from pydantic import BaseModel

class Person(BaseModel):
    name: str
    age: [1]

Drag options to blanks, or click blank then click option'

Abool

Bstring

Cfloat

Dint

Attempts:

3 left

💡 Hint

Common Mistakes

Using string or float for age.

Using bool by mistake.

The field age should be an integer, so use int as the type.

3fill in blank

hard

Fix the error in the Pydantic model by completing the missing import.

FastAPI

from pydantic import [1]

class Product(BaseModel):
    id: int
    price: float

Drag options to blanks, or click blank then click option'

AField

BSchema

CBaseModel

DModel

Attempts:

3 left

💡 Hint

Common Mistakes

Importing wrong classes like Schema or Model.

Forgetting to import BaseModel.

The BaseModel class must be imported from Pydantic to define models.

4fill in blank

hard

Fill both blanks to define a Pydantic model with a required string field 'title' and an optional integer field 'year'.

FastAPI

from pydantic import BaseModel

from typing import [1]

class Movie(BaseModel):
    title: str
    year: [2][int] = None

Drag options to blanks, or click blank then click option'

AOptional

BList

CDict

DSet

Attempts:

3 left

💡 Hint

Common Mistakes

Using List or Dict instead of Optional.

Not importing Optional.

Use Optional from typing to mark year as optional.

5fill in blank

hard

Fill all three blanks to define a Pydantic model with a field 'tags' that is a list of strings with a default empty list.

FastAPI

from pydantic import BaseModel, [1]
from typing import [2]

class BlogPost(BaseModel):
    tags: [2][str] = [3](default_factory=list)

Drag options to blanks, or click blank then click option'

AField

BList

Clist[str]

DOptional

Attempts:

3 left

💡 Hint

Common Mistakes

Using plain list[str] without importing List.

Not using Field for default values.

Use Field to set defaults and List from typing to type the list of strings.

Practice

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

easy

A. To specify the expected data structure and validate incoming data automatically

B. To create database tables automatically

C. To style the API responses with CSS

D. To handle user authentication

Solution

1. Step 1: Understand Pydantic model role

   Pydantic models define the shape and types of data expected in requests or responses.

2. Step 2: Identify validation feature

   They automatically check if incoming data matches the defined types and structure.

3. Final Answer:

   To specify the expected data structure and validate incoming data automatically -> Option A

4. Quick Check:

   Data validation = C [OK]

Hint: Pydantic models shape and check data automatically [OK]

Common Mistakes:

• Confusing Pydantic models with database models
• Thinking Pydantic handles styling or authentication
• Assuming Pydantic models run code logic

2. Which of the following is the correct way to define a Pydantic model with a required string field name and an optional integer field age?

easy

A. class User(BaseModel): name: str; age: int = None

B. class User(BaseModel): name: str; age: Optional[int] = None

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

D. class User(BaseModel): name: str = None; age: int

Solution

1. Step 1: Check required and optional fields syntax

   Required fields have type only, optional fields use Optional[type] with default None.

2. Step 2: Identify correct syntax

   class User(BaseModel): name: str; age: Optional[int] = None uses name: str (required) and age: Optional[int] = None (optional), which is correct.

3. Final Answer:

   class User(BaseModel): name: str; age: Optional[int] = None -> Option B

4. Quick Check:

   Optional fields use Optional[type] = None [OK]

Hint: Use Optional[type] = None for optional fields [OK]

Common Mistakes:

• Using plain type with default None without Optional
• Assigning type with equals sign incorrectly
• Setting required fields with default None

3. Given this Pydantic model:

from pydantic import BaseModel

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

item = Item(id='5', name='Book', price=12.99)

What will be the type of item.id after creation?

medium

A. TypeError raised

B. str with value '5'

C. float with value 5.0

D. int with value 5

Solution

1. Step 1: Understand Pydantic type coercion

   Pydantic automatically converts compatible types to the declared type if possible.

2. Step 2: Analyze input and conversion

   The string '5' can be converted to int 5, so item.id becomes int 5.

3. Final Answer:

   int with value 5 -> Option D

4. Quick Check:

   Pydantic converts compatible types automatically [OK]

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

Common Mistakes:

• Assuming input type must match exactly without conversion
• Expecting a TypeError for string input
• Thinking the value stays as string

4. What is wrong with this Pydantic model definition?

from pydantic import BaseModel

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

medium

A. Missing import for Optional

B. Class must inherit from object, not BaseModel

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

D. Field names cannot be lowercase

Solution

1. Step 1: Check field types and default values

   The field price expects a float but is given a string default 'free'.

2. Step 2: Understand Pydantic validation

   Pydantic will raise a validation error because 'free' cannot be converted to float.

3. Final Answer:

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

4. Quick Check:

   Default value type must match field type [OK]

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

Common Mistakes:

• Assigning default values of wrong type
• Confusing inheritance requirements
• Thinking field names have naming restrictions

5. You want to create a Pydantic model User with a required username (string), an optional email (string), and a roles list of strings that defaults to an empty list. Which is the correct way to define it?

hard

A. class User(BaseModel): username: str; email: Optional[str] = None; roles: list[str] = Field(default_factory=list)

B. class User(BaseModel): username: str; email: str = None; roles: list[str] = []

C. class User(BaseModel): username: str; email: Optional[str]; roles: list[str] = None

D. class User(BaseModel): username: str; email: Optional[str] = None; roles: list[str] = []

Solution

1. Step 1: Identify optional email field syntax

   Email is optional, so use Optional[str] = None to allow missing value.

2. Step 2: Handle mutable default for roles list

   Using roles: list[str] = [] is unsafe because lists are mutable defaults shared across instances. Use Field(default_factory=list) to create a new list each time.

3. Final Answer:

   class User(BaseModel): username: str; email: Optional[str] = None; roles: list[str] = Field(default_factory=list) -> Option A

4. Quick Check:

   Use Field(default_factory=list) for mutable defaults [OK]

Hint: Use Field(default_factory=list) for empty list defaults [OK]

Common Mistakes:

• Using mutable empty list as default directly
• Not marking optional fields with Optional and default None
• Assigning None to non-optional list fields