List and set validation in FastAPI - Step-by-Step Execution

Concept Flow - List and set validation

Receive input data

↓

Check if data is list or set

Yes↓

Validate each item type

↓

Accept data

↓

End

The flow checks if input is a list or set, then validates each item type, accepting or rejecting accordingly.

Execution Sample

FastAPI

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

class DataModel(BaseModel):
    items_list: List[int]
    items_set: Set[str]

Defines a FastAPI model validating a list of integers and a set of strings.

Execution Table

Step	Input Data	Validation Check	Result	Action
1	{"items_list": [1, 2, 3], "items_set": ["a", "b"]}	Is items_list a list? Yes	Pass	Check each item is int
2	[1, 2, 3]	Are all items int? Yes	Pass	items_list valid
3	["a", "b"]	Is items_set a set? No	Fail	Return validation error for items_set
4	["a", "b"]	Are all items str? Yes	Pass	items_set valid
5	{"items_list": [1, "two", 3], "items_set": ["a", "b"]}	Is items_list a list? Yes	Pass	Check each item is int
6	[1, "two", 3]	Are all items int? No	Fail	Return validation error for items_list
7	{"items_list": [1, 2, 3], "items_set": ["a", 2]}	Is items_set a set? No	Fail	Return validation error for items_set
8	["a", 2]	Are all items str? No	Fail	Return validation error for items_set

💡 Validation stops when any item fails type check, returning error.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 6	After Step 8
items_list	None	[1, 2, 3]	[1, 2, 3]	[1, "two", 3]	[1, 2, 3]
items_set	None	["a", "b"]	["a", "b"]	["a", "b"]	["a", 2]

Key Moments - 3 Insights

Why does validation fail when one item in the list is the wrong type?

Because FastAPI checks each item in the list individually (see steps 2 and 6). If any item is not the expected type, validation fails immediately.

Can the input accept a list where items are strings if the model expects integers?

No, the model strictly requires integers in the list (step 2). Strings cause validation errors (step 6).

Why is a set used for items_set instead of a list?

A set ensures unique items and FastAPI validates it as a set type (steps 3 and 7). This affects how duplicates are handled.

Visual Quiz - 3 Questions

Look at the execution table, what is the result of validating items_list at step 6?

A Pass

B Skipped

C Fail

D Error ignored

💡 Hint

Check the 'Result' column at step 6 in the execution_table.

At which step does validation confirm all items in items_set are strings?

A Step 3

B Step 4

C Step 7

D Step 8

💡 Hint

Look for the step where items_set items are checked for type in the execution_table.

If items_list had a float instead of an int, how would the validation result change at step 2?

A It would fail because float is not int

B It would pass because float is a number

C It would skip validation

D It would convert float to int automatically

💡 Hint

Refer to how strict type checking is shown in steps 2 and 6 of the execution_table.

Concept Snapshot

FastAPI validates lists and sets by checking the container type first.
Then it validates each item inside for the correct type.
If any item fails, validation returns an error.
Use List[type] for ordered collections, Set[type] for unique items.
This ensures input data matches expected structure and types.

Full Transcript

This visual execution trace shows how FastAPI validates list and set inputs using Pydantic models. First, it checks if the input data is the correct container type (list or set). Then it validates each item inside for the expected type, such as integers for a list or strings for a set. If all items pass, the data is accepted. If any item fails type validation, FastAPI returns an error immediately. This ensures the API receives data in the correct format and type, preventing bugs and errors later. The trace includes examples of valid and invalid inputs, showing exactly when and why validation passes or fails.

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