List and set validation in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when validating a list of integers with FastAPI?

Consider this FastAPI endpoint that expects a list of integers. What will be the response if the client sends the JSON body: {"numbers": [1, 2, "3", 4]}?

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel
from typing import List

app = FastAPI()

class NumbersModel(BaseModel):
    numbers: List[int]

@app.post("/validate")
async def validate_numbers(data: NumbersModel):
    return {"sum": sum(data.numbers)}

A Returns {"sum": 10} because "3" is automatically converted to int 3

B Raises a validation error because "3" is a string, not an int

C Returns {"sum": 7} ignoring the string "3" in the list

D Raises a runtime error during sum() because of mixed types

💡 Hint

Pydantic automatically coerces strings like "3" to int 3 in List[int].

Pydantic performs automatic type coercion for compatible values. The string "3" is converted to int 3, so the list validates as [1, 2, 3, 4] and the sum is 10.

📝 Syntax

intermediate

Which code correctly validates a set of unique strings in FastAPI?

You want to accept a set of unique strings in a POST request body. Which of these Pydantic model definitions is correct?

A

class Model(BaseModel):
    items: Set[str]

B

class Model(BaseModel):
    items: set[str]

C

class Model(BaseModel):
    items: list[str]

D

class Model(BaseModel):
    items: Set

💡 Hint

Remember to import the correct type and use proper capitalization.

The correct way is to import Set from typing and use Set[str]. Using lowercase 'set' works in Python 3.9+, but Pydantic recommends typing.Set for clarity. Option A uses lowercase set which is valid in Python 3.9+, but since the question is about correctness in FastAPI with Pydantic, option A is the best practice.

❓ state_output

advanced

What is the output of this FastAPI endpoint when validating a set with duplicates?

Given this endpoint and input, what will be the output? Input JSON: {"tags": ["python", "fastapi", "python"]}

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel
from typing import Set

app = FastAPI()

class TagModel(BaseModel):
    tags: Set[str]

@app.post("/tags")
async def get_tags(data: TagModel):
    return {"count": len(data.tags), "tags": sorted(data.tags)}

A {"count": 3, "tags": ["fastapi", "python", "python"]}

B {"count": 1, "tags": ["python"]}

C Validation error because input is a list, not a set

D {"count": 2, "tags": ["fastapi", "python"]}

💡 Hint

Think about how sets handle duplicates and how Pydantic converts lists to sets.

Pydantic converts the input list to a set, removing duplicates. So the duplicate "python" is removed, leaving two unique tags.

🔧 Debug

advanced

Why does this FastAPI endpoint raise a validation error?

Examine the code and input. Why does validation fail? Input JSON: {"values": [1, 2, 3.5]} Code: from fastapi import FastAPI from pydantic import BaseModel from typing import List app = FastAPI() class ValuesModel(BaseModel): values: List[int] @app.post("/values") async def values_endpoint(data: ValuesModel): return {"sum": sum(data.values)}

A Because List[int] does not accept any numbers

B Because sum() cannot add floats and ints together

C Because 3.5 is a float, not an int, causing validation to fail

D Because the endpoint is missing async keyword

💡 Hint

Check the types inside the list and how Pydantic validates them.

Pydantic expects all items to be ints. A float 3.5 is not an int, so validation fails before the endpoint runs.

🧠 Conceptual

expert

How does Pydantic handle default values for sets in models?

Consider this Pydantic model: class MyModel(BaseModel): items: Set[str] = set() What is a potential problem with this code when used in FastAPI endpoints?

A The code raises a syntax error because set() cannot be used as a default

B All instances share the same default set object, causing unexpected shared state

C FastAPI rejects the model because sets cannot have default values

D Pydantic automatically creates a new set for each instance, so no problem

💡 Hint

Think about how mutable default arguments behave in Python functions and classes.

Using a mutable default like set() directly as a default value causes all instances to share the same set, leading to bugs. The correct way is to use default_factory.

Practice

1. In FastAPI, when should you use List instead of Set for request data validation?

easy

A. When you want to store only unique items without order

B. When you want to automatically remove duplicates

C. When you want to validate a single item only

D. When the order of items matters and duplicates are allowed

Solution

1. Step 1: Understand List characteristics

   A List keeps the order of items and allows duplicates.

2. Step 2: Compare with Set characteristics

   A Set removes duplicates and does not guarantee order.

3. Final Answer:

   When the order of items matters and duplicates are allowed -> Option D

4. Quick Check:

   List = ordered with duplicates [OK]

Hint: Use List for ordered duplicates, Set for unique unordered [OK]

Common Mistakes:

• Confusing Set with List and expecting order
• Using Set when duplicates are needed
• Thinking List removes duplicates automatically

2. Which of the following is the correct way to declare a FastAPI endpoint expecting a set of integers in the request body?

easy

A. def endpoint(items: List[int]):

B. def endpoint(items: Set[int]):

C. def endpoint(items: dict[int]):

D. def endpoint(items: tuple[int]):

Solution

1. Step 1: Identify the correct type for unique collection

   Set[int] is used to declare a set of integers with unique values.

2. Step 2: Verify other options

   List[int] allows duplicates, dict[int] is invalid syntax, tuple[int] is fixed-length and ordered.

3. Final Answer:

   def endpoint(items: Set[int]): -> Option B

4. Quick Check:

   Set[int] = unique integer collection [OK]

Hint: Use Set[int] for unique integer collections in FastAPI [OK]

Common Mistakes:

• Using dict[int] which is invalid syntax
• Using tuple[int] which expects fixed length
• Confusing List with Set for uniqueness

3. Given this FastAPI endpoint code snippet, what will be the output if the input JSON is {"items": [1, 2, 2, 3]}?

from fastapi import FastAPI
from pydantic import BaseModel
from typing import Set

app = FastAPI()

class Data(BaseModel):
    items: Set[int]

@app.post("/unique")
def unique_items(data: Data):
    return {"unique_items": list(data.items)}

medium

A. {"unique_items": [1, 2, 3]}

B. {"unique_items": [1, 2, 2, 3]}

C. ValidationError due to duplicate items

D. {"unique_items": []}

Solution

1. Step 1: Understand Set validation in Pydantic

   Pydantic converts the input list to a set, removing duplicates automatically.

2. Step 2: Analyze the input and output

   Input has duplicates [1, 2, 2, 3], output converts to unique set [1, 2, 3].

3. Final Answer:

   {"unique_items": [1, 2, 3]} -> Option A

4. Quick Check:

   Set removes duplicates automatically [OK]

Hint: Set input removes duplicates, output shows unique items [OK]

Common Mistakes:

• Expecting ValidationError on duplicates
• Assuming output keeps duplicates
• Confusing List and Set behavior

4. Identify the error in this FastAPI model using List and Set:

from pydantic import BaseModel
from typing import List, Set

class Model(BaseModel):
    names: List[str]
    unique_ids: List[int]

    def __init__(self, **data):
        super().__init__(**data)
        self.unique_ids = set(self.unique_ids)

medium

A. No error, code works fine

B. Using List instead of Set for unique_ids is correct

C. Assigning a set to a List field breaks Pydantic validation

D. Missing type annotation for unique_ids

Solution

1. Step 1: Check field type and assignment

   unique_ids is declared as List[int] but assigned a set in __init__, causing type mismatch.

2. Step 2: Understand Pydantic validation rules

   Pydantic expects unique_ids to be a list; assigning a set breaks validation and type consistency.

3. Final Answer:

   Assigning a set to a List field breaks Pydantic validation -> Option C

4. Quick Check:

   Field type must match assigned value [OK]

Hint: Match field type with assigned value to avoid validation errors [OK]

Common Mistakes:

• Assigning set to List field without changing type
• Ignoring Pydantic's type enforcement
• Assuming __init__ can override field types safely

5. You want to create a FastAPI endpoint that accepts a list of tags but ensures no empty or duplicate tags. Which is the best way to validate this using Pydantic?

hard

A. Use tags: Set[str] and add a validator to reject empty strings

B. Use tags: List[str] and manually check duplicates and empties in the endpoint

C. Use tags: List[str] with a validator that converts to set and removes empties

D. Use tags: Set[str] without any validator

Solution

1. Step 1: Ensure uniqueness with Set

   Using Set[str] automatically removes duplicates.

2. Step 2: Add validator to reject empty strings

   Since Set only ensures uniqueness, a validator is needed to reject empty tags.

3. Final Answer:

   Use tags: Set[str] and add a validator to reject empty strings -> Option A

4. Quick Check:

   Set + validator = unique + no empty tags [OK]

Hint: Use Set for uniqueness and validator for empties [OK]

Common Mistakes:

• Using List without uniqueness enforcement
• Not validating empty strings in Set
• Relying on manual checks in endpoint instead of validators