List and set validation in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the correct Pydantic type for a list of strings.

FastAPI

from pydantic import BaseModel, [1]

class Item(BaseModel):
    tags: [1][str]

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

AList

BTuple

CDict

DSet

Attempts:

3 left

💡 Hint

Common Mistakes

Using Set instead of List when order matters.

Forgetting to import the type from Pydantic.

The List type from Pydantic is used to validate lists of items, such as strings.

2fill in blank

medium

Complete the code to import the correct Pydantic type for a set of integers.

FastAPI

from pydantic import BaseModel, [1]

class Numbers(BaseModel):
    unique_ids: [1][int]

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

ASet

BList

CDict

DTuple

Attempts:

3 left

💡 Hint

Common Mistakes

Using List when uniqueness is required.

Confusing Set with Dict.

The Set type from Pydantic is used to validate sets, which are unordered collections of unique items.

3fill in blank

hard

Fix the error in the code to correctly validate a list of strings using Pydantic.

FastAPI

from pydantic import BaseModel, [1]

class User(BaseModel):
    hobbies: [1][str]

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

ASet

BDict

CList

DTuple

Attempts:

3 left

💡 Hint

Common Mistakes

Using Set which does not preserve order.

Using Dict which expects key-value pairs.

To validate a list of strings, use List[str] from Pydantic.

4fill in blank

hard

Fill both blanks to define a Pydantic model with a list of strings and a set of integers.

FastAPI

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

class Data(BaseModel):
    names: [1][str]
    ids: [2][int]

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

AList

BSet

CDict

DTuple

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up List and Set types.

Forgetting to import both types.

List is used for ordered collections, and Set for unique unordered collections.

5fill in blank

hard

Fill all three blanks to create a Pydantic model with a list of strings, a set of integers, and a tuple of floats.

FastAPI

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

class Metrics(BaseModel):
    labels: [1][str]
    unique_codes: [2][int]
    scores: [3][float]

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

AList

BSet

CTuple

DDict

Attempts:

3 left

💡 Hint

Common Mistakes

Using Dict instead of Tuple for fixed-length sequences.

Not importing all required types.

Use List for ordered lists, Set for unique unordered sets, and Tuple for fixed-length ordered collections.

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