Optional query parameters in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when no query parameter is provided?

Consider this FastAPI endpoint that uses an optional query parameter with a default value. What will be the response if the client calls the endpoint without any query parameters?

FastAPI

from fastapi import FastAPI
from typing import Optional

app = FastAPI()

@app.get('/items/')
async def read_items(q: Optional[str] = None):
    if q:
        return {'query': q}
    return {'query': 'No query provided'}

A {"query": "No query provided"}

B {"query": null}

C 404 Not Found error

D 500 Internal Server Error

💡 Hint

Think about what happens when the optional parameter is not sent by the client.

The parameter 'q' is optional and defaults to None. When no query parameter is sent, 'q' is None, so the function returns {'query': 'No query provided'}.

📝 Syntax

intermediate

Which option correctly declares an optional query parameter with a default value?

You want to declare an optional query parameter named 'page' that defaults to 1. Which of the following FastAPI endpoint parameter declarations is correct?

A async def read_items(page: Optional[int] = 1):

B async def read_items(page: int = 1):

C async def read_items(page: int):

D async def read_items(page: Optional[int]):

💡 Hint

Remember how to set default values for parameters in Python functions.

Declaring 'page: int = 1' makes 'page' optional with a default value of 1. Using Optional[int] without a default value makes it required.

❓ state_output

advanced

What is the response when multiple optional query parameters are missing?

Given this FastAPI endpoint with two optional query parameters, what will be the JSON response if the client calls the endpoint without any query parameters?

FastAPI

from fastapi import FastAPI
from typing import Optional

app = FastAPI()

@app.get('/search/')
async def search(q: Optional[str] = None, limit: Optional[int] = 10):
    return {'q': q, 'limit': limit}

A {"q": null, "limit": 10}

B {"q": "", "limit": 0}

C {"q": null, "limit": null}

D 422 Unprocessable Entity error

💡 Hint

Check the default values assigned to the parameters.

Parameter 'q' defaults to None (null in JSON), and 'limit' defaults to 10. So the response includes these values.

🔧 Debug

advanced

Why does this FastAPI endpoint raise a validation error?

Examine the following FastAPI endpoint. Why does it raise a 422 validation error when called without query parameters?

FastAPI

from fastapi import FastAPI
from typing import Optional

app = FastAPI()

@app.get('/items/')
async def read_items(q: Optional[str]):
    return {'query': q}

A Because the return statement is missing a default value.

B Because Optional[str] is not allowed in FastAPI parameters.

C Because the endpoint must have at least one required parameter.

D Because 'q' is Optional but has no default value, so it is required.

💡 Hint

Think about how Python treats parameters without default values.

In Python, parameters without default values are required. 'q: Optional[str]' without '= None' means 'q' is required, so calling without it causes validation error.

🧠 Conceptual

expert

How does FastAPI handle optional query parameters with default values in OpenAPI docs?

When you declare an optional query parameter with a default value in FastAPI, how does it appear in the generated OpenAPI documentation?

A The parameter is marked as required with no default value shown.

B The parameter is hidden from the OpenAPI docs.

C The parameter is marked as optional with the default value shown in the docs.

D The parameter is shown as required but with the default value.

💡 Hint

Think about how default values affect API documentation.

FastAPI uses the default value to mark the parameter as optional in OpenAPI docs and shows the default value to API users.

Practice

1. What does it mean when a query parameter in FastAPI is optional?

easy

A. The parameter is required but can be empty

B. The parameter must always be included in the request

C. The user can choose to include it or not in the request

D. The parameter is ignored by FastAPI

Solution

1. Step 1: Understand optional parameters in APIs

   Optional means the user does not have to provide the parameter for the request to work.

2. Step 2: Apply to FastAPI query parameters

   FastAPI allows parameters to be optional by giving them a default value like None.

3. Final Answer:

   The user can choose to include it or not in the request -> Option C

4. Quick Check:

   Optional query parameter = user choice [OK]

Hint: Optional means user may skip it without error [OK]

Common Mistakes:

• Thinking optional means parameter is always required
• Confusing optional with ignored parameters
• Assuming optional means empty string is required

2. Which of the following is the correct way to declare an optional query parameter named q of type str in FastAPI?

easy

A. def read_items(q: Optional[str] = None):

B. def read_items(q: str = None):

C. def read_items(q: str):

D. def read_items(q: Optional[str]):

Solution

1. Step 1: Recall syntax for optional query parameters

   FastAPI uses Optional[type] with a default value None to mark parameters optional.

2. Step 2: Check each option

   def read_items(q: Optional[str] = None): uses Optional[str] and default None, which is correct syntax.

3. Final Answer:

   def read_items(q: Optional[str] = None): -> Option A

4. Quick Check:

   Optional[str] + = None = correct syntax [OK]

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

Common Mistakes:

• Omitting the default None value
• Using Optional without import
• Setting type to str without Optional

3. Given this FastAPI endpoint code:

from typing import Optional
from fastapi import FastAPI

app = FastAPI()

@app.get("/items/")
async def read_items(q: Optional[str] = None):
    if q:
        return {"query": q}
    return {"query": "No query"}

What will be the JSON response when the client calls /items/ without any query parameters?

medium

A. {"query": null}

B. {"query": "No query"}

C. An error occurs because q is missing

D. {"query": ""}

Solution

1. Step 1: Understand default value of q

   q is Optional[str] with default None, so if missing, q is None.

2. Step 2: Check the if condition

   If q is None (falsey), the function returns {"query": "No query"}.

3. Final Answer:

   {"query": "No query"} -> Option B

4. Quick Check:

   Missing q returns "No query" [OK]

Hint: Missing optional param uses default None [OK]

Common Mistakes:

• Expecting error when param is missing
• Assuming null is returned instead of string
• Confusing empty string with None

4. Identify the error in this FastAPI endpoint code that tries to make q optional:

from fastapi import FastAPI

app = FastAPI()

@app.get("/search/")
def search(q: str = None):
    return {"q": q}

medium

A. q should be typed as Optional[str] when default is None

B. Function must be async to use optional parameters

C. Missing import of Optional from typing

D. Default value None is not allowed for query parameters

Solution

1. Step 1: Check parameter typing and default

   q has type str but default None, which conflicts because None is not str.

2. Step 2: Correct typing for optional parameter

   Use Optional[str] from typing to allow None as a valid default.

3. Final Answer:

   q should be typed as Optional[str] when default is None -> Option A

4. Quick Check:

   Type must match default None with Optional[str] [OK]

Hint: Match type with default None using Optional[type] [OK]

Common Mistakes:

• Not importing Optional but using it
• Making function async unnecessarily
• Using None default without Optional type

5. You want to create a FastAPI endpoint that accepts an optional integer query parameter page with a default of 1, but if the user sends page=0, it should return an error. How would you declare page to achieve this behavior?

hard

A. page: Optional[int] = 1 with extra validation to reject 0

B. page: int without default and require user to send page > 0

C. page: Optional[int] = None and set page = 1 inside function if None

D. page: int = 1 and check inside function if page == 0 to raise error

Solution

1. Step 1: Understand default and validation needs

   Default 1 means page is not optional, but user can omit it to get 1.

2. Step 2: Handle invalid value 0

   Use int with default 1, then inside function check if page == 0 and raise error.

3. Final Answer:

   page: int = 1 and check inside function if page == 0 to raise error -> Option D

4. Quick Check:

   Default + validation inside function = page: int = 1 and check inside function if page == 0 to raise error [OK]

Hint: Use default param + check value inside function [OK]

Common Mistakes:

• Making page Optional[int] = 1 (invalid syntax)
• Not validating 0 value inside function
• Requiring page without default when default needed