Example data in schema in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this FastAPI schema example?

Given this Pydantic model with example data, what will the OpenAPI schema show for the example?

FastAPI

from pydantic import BaseModel, Field

class User(BaseModel):
    id: int = Field(..., example=123)
    name: str = Field(..., example="Alice")

user_example = User.schema()['properties']

A {"id": {"title": "Id", "type": "integer", "example": 123}, "name": {"title": "Name", "type": "string", "example": "Alice"}}

B {"id": {"title": "Id", "type": "string", "example": "123"}, "name": {"title": "Name", "type": "string", "example": "Alice"}}

C {"id": {"title": "Id", "type": "integer"}, "name": {"title": "Name", "type": "string"}}

D {"id": {"title": "Id", "type": "integer", "example": "Alice"}, "name": {"title": "Name", "type": "string", "example": 123}}

💡 Hint

Look at the Field example values and their types.

The example values in the schema match the Field example arguments with correct types.

📝 Syntax

intermediate

Which option correctly sets example data in a Pydantic schema?

Choose the code snippet that correctly uses Field to add example data for a Pydantic model.

A

class Item(BaseModel):
    price: float = Field(..., example=19.99)

B

class Item(BaseModel):
    price: float = Field(example=19.99)

C

class Item(BaseModel):
    price: float = Field(..., example='19.99')

D

class Item(BaseModel):
    price: float = Field(..., example=price)

💡 Hint

Example should match the field type and use ... for required fields.

Option A correctly uses Field with required marker ... and example as a float matching the type.

🔧 Debug

advanced

What error occurs with this example data in schema?

This Pydantic model has example data that does not match the field type. What error will FastAPI raise when generating docs?

FastAPI

from pydantic import BaseModel, Field

class Product(BaseModel):
    quantity: int = Field(..., example="ten")

A No error, example is accepted as string

B SyntaxError: invalid syntax in Field example

C ValidationError: example value is not valid for type int

D TypeError: example must be int, got str

💡 Hint

Example must match the declared field type.

Pydantic validates example values against the field type and raises ValidationError if mismatched.

❓ state_output

advanced

What is the example output in OpenAPI for nested Pydantic models?

Given nested models with example data, what does the OpenAPI example show for the nested field?

FastAPI

from pydantic import BaseModel, Field

class Address(BaseModel):
    city: str = Field(..., example="Paris")

class User(BaseModel):
    name: str = Field(..., example="Bob")
    address: Address = Field(...)

user_schema = User.schema()

A {"name": {"example": "Bob"}, "address": {}}

B {"name": {"example": "Bob"}, "address": {"$ref": "#/definitions/Address"}}

C {"name": {"example": "Bob"}, "address": {"example": "Paris"}}

D {"name": {"example": "Bob"}, "address": {"example": {"city": "Paris"}}}

💡 Hint

Nested models use $ref in schema, examples are inside referenced model.

The User schema references Address by $ref; example for nested fields is inside Address schema.

🧠 Conceptual

expert

How does FastAPI use example data in schema for API docs?

Why is setting example data in Pydantic models important for FastAPI-generated OpenAPI docs?

A It enforces runtime validation of incoming data to match the example values exactly.

B It automatically generates database seed data from the examples.

C It disables schema validation and trusts example data as the only valid input.

D It provides sample request and response data shown in the API docs to help users understand the API.

💡 Hint

Think about the purpose of examples in documentation.

Examples improve API docs by showing sample data, making it easier for users to test and understand endpoints.

Practice

1. What is the main purpose of adding example data in a FastAPI schema field?

easy

A. To automatically generate database tables

B. To validate the data type of the field at runtime

C. To encrypt the field data before sending

D. To show sample values for API fields to help users understand expected data

Solution

1. Step 1: Understand the role of example data in FastAPI

   Example data is used to provide sample values in API documentation, helping users know what to send or expect.

2. Step 2: Differentiate example data from validation or encryption

   Example data does not validate or encrypt; it only shows sample values in docs.

3. Final Answer:

   To show sample values for API fields to help users understand expected data -> Option D

4. Quick Check:

   Example data = sample values [OK]

Hint: Example data shows sample values in docs, not validation [OK]

Common Mistakes:

• Confusing example with validation
• Thinking example encrypts data
• Assuming example creates database schema

2. Which of the following is the correct way to add example data to a Pydantic model field in FastAPI?

easy

A. name: str = Field(example="John Doe")

B. name: str = Field(default="John Doe")

C. name: str = Field(description="John Doe")

D. name: str = Field(required=True)

Solution

1. Step 1: Recall the Field syntax for example data

   FastAPI uses Field(..., example=...) to add example data to schema fields.

2. Step 2: Identify the correct option

   name: str = Field(example="John Doe") uses Field(example="John Doe"), which is the correct syntax for example data.

3. Final Answer:

   name: str = Field(example="John Doe") -> Option A

4. Quick Check:

   Field(example=...) = correct syntax [OK]

Hint: Use Field(example=...) to add example data [OK]

Common Mistakes:

• Using default instead of example
• Confusing description with example
• Omitting Field() entirely

3. Given this Pydantic model in FastAPI:

from pydantic import BaseModel, Field

class User(BaseModel):
    username: str = Field(..., example="alice123")
    age: int = Field(..., example=30)

What example data will appear in the OpenAPI docs for the age field?

medium

A. "30"

B. 30

C. None

D. 0

Solution

1. Step 1: Check the example value assigned to the age field

   The age field has example=30, which is an integer value 30.

2. Step 2: Understand how example data is shown in docs

   FastAPI shows the example exactly as given, so the example for age will be 30 (integer).

3. Final Answer:

   30 -> Option B

4. Quick Check:

   Example for age = 30 [OK]

Hint: Example shows exact value given in Field(example=...) [OK]

Common Mistakes:

• Thinking example converts int to string
• Assuming example is None if not set
• Confusing example with default value

4. Identify the error in this FastAPI Pydantic model using example data:

from pydantic import BaseModel, Field

class Item(BaseModel):
    name: str = Field(example=123)
    price: float = Field(..., example="9.99")

medium

A. Example for name should be a string, not an integer

B. Missing default value for name field

C. Example for price should be a float, not a string

D. Field(...) is missing for name field

Solution

1. Step 1: Check example data types against field types

   The name field is str but example=123 (int) is allowed but not ideal; price is float but example="9.99" is a string, which is incorrect.

2. Step 2: Identify the type mismatch causing error

   Example for price should be a float (9.99), not a string "9.99"; this can cause schema confusion.

3. Final Answer:

   Example for price should be a float, not a string -> Option C

4. Quick Check:

   Example type must match field type [OK]

Hint: Match example type to field type exactly [OK]

Common Mistakes:

• Using string example for numeric fields
• Ignoring type mismatch warnings
• Omitting Field(...) for required fields

5. You want to create a FastAPI schema for a product with a nested model and provide example data for both levels. Which is the correct way to add example data for nested fields?

hard

A. Use example in Field() for each nested field separately

B. Add example data only to the top-level model, nested fields inherit automatically

C. Use example only in the nested model class, not in the parent

D. Example data cannot be added to nested models in FastAPI

Solution

1. Step 1: Understand example data usage in nested models

   Each field in nested models needs its own example data using Field(example=...) to show correct samples in docs.

2. Step 2: Confirm nested fields do not inherit example data

   Example data is not inherited; you must specify it explicitly for each nested field.

3. Final Answer:

   Use example in Field() for each nested field separately -> Option A

4. Quick Check:

   Example data must be set per field [OK]

Hint: Add example=... to every nested field explicitly [OK]

Common Mistakes:

• Assuming nested fields inherit example data
• Skipping example in nested models
• Thinking example data is only for top-level fields