Default values in FastAPI - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of default values in FastAPI path or query parameters?

Default values allow parameters to be optional by providing a fallback value if the client does not send that parameter. This makes the API more flexible and user-friendly.

beginner

How do you set a default value for a query parameter in FastAPI?

You assign a value to the parameter in the function definition, for example: def read_items(q: str = "default"). If the client omits q, FastAPI uses "default".

intermediate

Can default values be used with path parameters in FastAPI?

No, path parameters are required by design and cannot have default values. Only query parameters and request body fields can have defaults.

beginner

What happens if a client sends a value for a parameter that has a default value in FastAPI?

FastAPI uses the client-provided value instead of the default. The default is only used when the client omits the parameter.

intermediate

How can you make a query parameter optional without a default value in FastAPI?

You can use Optional from typing and set the default to None, like q: Optional[str] = None. This means the parameter can be missing or null.

In FastAPI, what does setting a default value for a query parameter do?

A Makes the parameter optional with a fallback value

B Makes the parameter required

C Removes the parameter from the API

D Changes the parameter type

Setting a default value makes the parameter optional and uses the default if the client does not provide it.

Can you set a default value for a path parameter in FastAPI?

A Yes, always

B No, path parameters are always required

C Only if you use a special decorator

D Only for integer path parameters

Path parameters are required and cannot have default values in FastAPI.

What is the correct way to make a query parameter optional without a default value in FastAPI?

A Use a default empty string

B Set the parameter type to int

C Remove the parameter from the function

D Set the parameter type to Optional and default to None

Using Optional[type] with default None makes the parameter optional without a fixed default.

If a client sends a value for a parameter that has a default in FastAPI, what happens?

A An error is raised

B The default value is used

C The client value is used

D The parameter is ignored

FastAPI uses the client-provided value, overriding the default.

Which of these is a valid default value for a FastAPI query parameter?

A "hello"

B A required path parameter

C A missing parameter

D A function without a return

Default values can be strings, numbers, or other valid types, like "hello".

Explain how default values work for query parameters in FastAPI and why they are useful.

Think about how you might want to let users skip some inputs.

Describe the difference between path parameters and query parameters regarding default values in FastAPI.

Consider how URLs are structured and what parts must always be present.

Practice

1. In FastAPI, what is the main purpose of setting a default value for a function parameter in an endpoint?

easy

A. To automatically convert the parameter to a string

B. To make the parameter optional and provide a fallback value if not supplied

C. To disable the endpoint if the parameter is missing

D. To force the client to always send a value for that parameter

Solution

1. Step 1: Understand default values in FastAPI

   Default values allow parameters to be optional by providing a fallback if the client does not send a value.

2. Step 2: Identify the effect on endpoint behavior

   When a default is set, the endpoint works even if the parameter is missing, using the default instead.

3. Final Answer:

   To make the parameter optional and provide a fallback value if not supplied -> Option B

4. Quick Check:

   Default value = optional parameter [OK]

Hint: Default values make parameters optional with fallback [OK]

Common Mistakes:

• Thinking default forces client to send value
• Assuming default disables endpoint if missing
• Confusing default with type conversion

2. Which of the following is the correct way to set a default value of 10 for a query parameter named limit in a FastAPI endpoint?

easy

A. def read_items(limit: int = 10):

B. def read_items(limit: int = Query(10)):

C. def read_items(limit: Query = 10):

D. def read_items(limit: int Query(10)):

Solution

1. Step 1: Recall Python default parameter syntax

   Default values are set by assigning a value with = after the parameter name and type.

2. Step 2: Check FastAPI query parameter defaults

   For simple defaults, just use limit: int = 10. Using Query() is optional for extra validation.

3. Final Answer:

   def read_items(limit: int = 10): -> Option A

4. Quick Check:

   Default value syntax = param: type = value [OK]

Hint: Use param: type = default for simple defaults [OK]

Common Mistakes:

• Misplacing Query() without import or wrong syntax
• Using Query without type annotation
• Missing = sign for default assignment

3. Consider this FastAPI endpoint code:

from fastapi import FastAPI
app = FastAPI()

@app.get("/items/")
async def read_items(skip: int = 0, limit: int = 5):
    return {"skip": skip, "limit": limit}

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

medium

A. {"skip": "0", "limit": "5"}

B. {"skip": null, "limit": null}

C. Error: missing required parameters

D. {"skip": 0, "limit": 5}

Solution

1. Step 1: Identify default values for parameters

   Both skip and limit have default values: 0 and 5 respectively.

2. Step 2: Understand behavior when no query parameters sent

   FastAPI uses default values when parameters are missing, so skip=0 and limit=5 are used.

3. Final Answer:

   {"skip": 0, "limit": 5} -> Option D

4. Quick Check:

   Defaults used when no query params [OK]

Hint: No query params? Defaults fill in automatically [OK]

Common Mistakes:

• Expecting null instead of default values
• Confusing string vs integer in response
• Assuming error if parameters missing

4. What is wrong with this FastAPI endpoint code?

from fastapi import FastAPI
app = FastAPI()

@app.get("/users/")
def get_users(limit: int = Query(10)):
    return {"limit": limit}

medium

A. Missing import for Query

B. Default value must be a constant, not Query()

C. Function must be async

D. Query() cannot be used for default values

Solution

1. Step 1: Check imports for Query

   The code uses Query(10) but does not import Query from fastapi.

2. Step 2: Understand effect of missing import

   Without importing Query, Python raises a NameError because Query is undefined.

3. Final Answer:

   Missing import for Query -> Option A

4. Quick Check:

   Use from fastapi import Query if using Query() [OK]

Hint: Always import Query when using Query() defaults [OK]

Common Mistakes:

• Forgetting to import Query
• Thinking Query() is invalid default
• Assuming async required for all endpoints

5. You want to create a FastAPI endpoint that accepts an optional query parameter category with a default value of "all". However, if the client sends an empty string "", you want to treat it as None (no category filter). Which approach correctly implements this behavior?

hard

A. def read_items(category: Optional[str] = None):
if category is None:
category = "all"
return {"category": category}

B. def read_items(category: str = Query(default="all", min_length=1)):
return {"category": category}

C. def read_items(category: str = "all"):
if category == "":
category = None
return {"category": category}

D. def read_items(category: str = Query(default="all")):
if category == "all":
category = None
return {"category": category}

Solution

1. Step 1: Understand the requirement for empty string handling

   The parameter should default to "all" but treat empty string "" as None.

2. Step 2: Analyze each option's logic

   def read_items(category: str = "all"): if category == "": category = None return {"category": category} sets default to "all" and explicitly checks if category is "", then sets it to None, matching the requirement.

3. Final Answer:

   def read_items(category: str = "all"): if category == "": category = None return {"category": category} -> Option C

4. Quick Check:

   Check empty string and convert to None manually [OK]

Hint: Check for empty string and convert to None inside function [OK]

Common Mistakes:

• Relying on Query() to handle empty string conversion
• Setting default None but not handling empty string
• Confusing default "all" with None logic