Basic query parameter declaration in FastAPI - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a query parameter in FastAPI?

A query parameter is a value sent in the URL after a question mark (?) that the server can read and use. In FastAPI, you declare it as a function parameter in your path operation function.

beginner

How do you declare a basic query parameter in FastAPI?

You add a function parameter with a default value or type annotation in your path operation function. For example:
def read_item(q: str = None): declares a query parameter named 'q'.

beginner

What happens if you don't provide a default value for a query parameter in FastAPI?

FastAPI treats it as a required query parameter. The client must send it in the URL, or FastAPI will return an error.

beginner

Example: What does this FastAPI function do?
@app.get('/items/')
def read_items(q: str = None):
return {'q': q}

It declares a GET endpoint '/items/' that accepts an optional query parameter 'q'. If 'q' is sent in the URL, it returns it in a dictionary. If not sent, it returns {'q': None}.

beginner

Why use query parameters instead of path parameters?

Query parameters are good for optional or filtering data without changing the URL structure. Path parameters are for required parts of the URL that identify a resource.

How do you declare an optional query parameter named 'search' in FastAPI?

A def read(search: str = None):

B def read(search: str):

C def read(search):

D def read(search: int = 0):

Declaring with a default value None makes the query parameter optional.

What happens if a required query parameter is missing in the request?

A FastAPI returns an error response.

B FastAPI uses a default value.

C FastAPI ignores the parameter.

D FastAPI crashes.

FastAPI expects required query parameters and returns an error if missing.

Which symbol starts query parameters in a URL?

A &

B #

C ?

D /

Query parameters start after a question mark (?) in the URL.

In FastAPI, how do you access the value of a query parameter inside your function?

A Using request.body().

B By declaring a function parameter with the same name.

C Using global variables.

D Using environment variables.

FastAPI matches query parameters to function parameters by name.

Which of these is a valid query parameter declaration in FastAPI?

A def get_items(limit):

B def get_items():

C def get_items(limit: str):

D def get_items(limit: int = 10):

Declaring with a default value and type is valid and makes the parameter optional.

Explain how to declare and use a basic query parameter in FastAPI.

Think about how the function parameter relates to the URL query string.

Describe the difference between required and optional query parameters in FastAPI.

Consider what happens if the client does not send the parameter.

Practice

1. In FastAPI, how do you declare a query parameter that is optional with a default value?

easy

A. By importing Query from fastapi and not setting a default value

B. By using a special decorator like @query_param

C. By defining the parameter inside the request body

D. By adding a function parameter with a default value, e.g., def read_item(q: str = None)

Solution

1. Step 1: Understand query parameter declaration

   In FastAPI, query parameters are declared as function parameters in path operation functions.

2. Step 2: Recognize optional parameters

   If a parameter has a default value (like None), it becomes optional and is treated as a query parameter.

3. Final Answer:

   By adding a function parameter with a default value, e.g., def read_item(q: str = None) -> Option D

4. Quick Check:

   Optional query param = default value [OK]

Hint: Optional query params have default values in function signature [OK]

Common Mistakes:

• Thinking a decorator is needed for query params
• Confusing query params with request body
• Not setting a default value makes param required

2. Which of the following is the correct syntax to declare a required query parameter named item_id of type int in FastAPI?

easy

A. def read_item(item_id: int):

B. def read_item(item_id):

C. def read_item(item_id: str = 'default'):

D. def read_item(item_id: int = None):

Solution

1. Step 1: Identify required query parameter syntax

   A required query parameter has no default value and must have a type annotation.

2. Step 2: Check each option

   def read_item(item_id: int): declares item_id as an int without a default, making it required.

3. Final Answer:

   def read_item(item_id: int): -> Option A

4. Quick Check:

   Required param = no default value [OK]

Hint: No default means required query param [OK]

Common Mistakes:

• Setting default None makes param optional
• Using wrong type annotation
• Omitting type annotation makes param a path param

3. What will be the output if you call the FastAPI endpoint defined as below without any query parameters?

from fastapi import FastAPI
app = FastAPI()

@app.get('/items/')
def read_items(q: str = 'default'):
    return {'q': q}

medium

A. {'q': None}

B. Error: missing required query parameter

C. {'q': 'default'}

D. {'q': ''}

Solution

1. Step 1: Analyze the function parameter

   The parameter q has a default value of 'default', so it is optional.

2. Step 2: Understand the call without query params

   When no query parameter is provided, FastAPI uses the default value 'default'.

3. Final Answer:

   {'q': 'default'} -> Option C

4. Quick Check:

   Default value used when query param missing [OK]

Hint: Default param value is returned if query missing [OK]

Common Mistakes:

• Expecting None instead of default
• Thinking missing param causes error
• Assuming empty string is default

4. Identify the error in this FastAPI query parameter declaration:

from fastapi import FastAPI
app = FastAPI()

@app.get('/users/')
def get_user(user_id: int = None):
    return {'user_id': user_id}

medium

A. Default value None is invalid for int type without Optional

B. No error, this is a valid optional query parameter

C. Type hint should be Optional[int] from typing

D. Query parameter must be declared with Query()

Solution

1. Step 1: Check parameter declaration

   Declaring user_id: int = None makes it optional with default None.

2. Step 2: Verify FastAPI behavior

   FastAPI accepts this and treats user_id as an optional query parameter.

3. Final Answer:

   No error, this is a valid optional query parameter -> Option B

4. Quick Check:

   Default None with int type is allowed [OK]

Hint: Default None with int type is valid in FastAPI [OK]

Common Mistakes:

• Assuming Optional[int] is required
• Thinking Query() is mandatory
• Confusing type hints with runtime errors

5. You want to declare two query parameters in FastAPI: q which is optional with default None, and limit which is required and an integer. Which is the correct function signature?

hard

A. def read_items(limit: int, q: str = None):

B. def read_items(q: str = None, limit: int):

C. def read_items(q: str, limit: int = None):

D. def read_items(q: str = None, limit: int = 10):

Solution

1. Step 1: Understand parameter order rules

   In Python, parameters without defaults must come before those with defaults.

2. Step 2: Apply to FastAPI query params

   limit is required (no default), so it must come before optional q with default None.

3. Final Answer:

   def read_items(limit: int, q: str = None): -> Option A

4. Quick Check:

   Required params before optional ones [OK]

Hint: Put required params before optional ones in function signature [OK]

Common Mistakes:

• Placing optional param before required causes syntax error
• Assigning default to required param
• Mixing parameter order incorrectly