Path parameters in FastAPI - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a path parameter in FastAPI?

A path parameter is a part of the URL path that acts as a variable. It lets you capture values from the URL and use them in your code, like getting an item ID from the URL.

beginner

How do you define a path parameter in a FastAPI route?

You add a variable name inside curly braces in the route path, like /items/{item_id}. Then, you add a function parameter with the same name to receive the value.

intermediate

Can path parameters have types in FastAPI? How?

Yes! You can specify the type of a path parameter by adding a type hint in the function parameter, like item_id: int. FastAPI will convert the value and check the type automatically.

intermediate

What happens if a path parameter value does not match the expected type in FastAPI?

FastAPI returns a 422 error (Unprocessable Entity) because the value cannot be converted to the expected type. This helps catch errors early and keeps your API safe.

beginner

Why are path parameters useful in building APIs?

They let you create dynamic URLs that can handle many different inputs, like fetching different items by ID. This makes your API flexible and easy to use.

How do you declare a path parameter named 'user_id' in FastAPI?

A Using /users/user_id in the route and user_id as a function parameter

B Using /users/{user_id} in the route and user_id as a function parameter

C Using /users/:user_id in the route and user_id as a function parameter

D Using /users?user_id in the route and user_id as a function parameter

Path parameters are declared inside curly braces in the route path, like /users/{user_id}.

What type hint would you use for a numeric path parameter 'item_id'?

A int

B float

C str

D bool

Use int to indicate the parameter should be an integer number.

What response does FastAPI give if a path parameter value cannot be converted to the expected type?

A 422 Unprocessable Entity

B 404 Not Found

C 200 OK

D 500 Internal Server Error

FastAPI returns a 422 error when the path parameter value type is invalid.

Which of these is a valid path parameter in FastAPI?

A /products?product_id

B /products/product_id

C /products/{product_id}

D /products/:product_id

Curly braces {} define path parameters in FastAPI routes.

Why use path parameters instead of query parameters for resource IDs?

A Query parameters are required

B Query parameters are faster

C Path parameters cannot be typed

D Path parameters make URLs cleaner and more RESTful

Path parameters create clean, meaningful URLs that follow REST principles.

Explain how to create a FastAPI route that accepts a path parameter and uses it inside the function.

Think about how the URL and function connect.

Describe what happens when a client sends a wrong type for a path parameter in FastAPI.

Focus on error handling and type safety.

Practice

1. What is the purpose of path parameters in FastAPI?

easy

A. To send data only in the request body

B. To define static routes without variables

C. To capture values directly from the URL path

D. To handle only query string parameters

Solution

1. Step 1: Understand what path parameters do

   Path parameters allow the API to accept dynamic values from the URL path itself, making routes flexible.

2. Step 2: Compare with other data sources

   Unlike query parameters or request bodies, path parameters are part of the URL path, not optional or in the body.

3. Final Answer:

   To capture values directly from the URL path -> Option C

4. Quick Check:

   Path parameters = URL path values [OK]

Hint: Path parameters are always inside curly braces {} in the URL [OK]

Common Mistakes:

• Confusing path parameters with query parameters
• Thinking path parameters come from request body
• Assuming path parameters are optional by default

2. Which of the following is the correct way to declare a path parameter named item_id in FastAPI?

easy

A. @app.get("/items/:item_id")

B. @app.get("/items/item_id")

C. @app.get("/items/<item_id>")

D. @app.get("/items/{item_id}")

Solution

1. Step 1: Recall FastAPI path parameter syntax

   FastAPI uses curly braces {} to declare path parameters inside route strings.

2. Step 2: Identify the correct syntax

   Only @app.get("/items/{item_id}") uses curly braces correctly: "/items/{item_id}".

3. Final Answer:

   @app.get("/items/{item_id}") -> Option D

4. Quick Check:

   Curly braces {} = path parameters [OK]

Hint: Use curly braces {} around parameter names in route paths [OK]

Common Mistakes:

• Using quotes or angle brackets instead of curly braces
• Forgetting to wrap parameter name in braces
• Using colon syntax like other frameworks

3. Given this FastAPI code snippet, what will be the output when accessing /users/42?

from fastapi import FastAPI
app = FastAPI()

@app.get("/users/{user_id}")
async def read_user(user_id: int):
    return {"user_id": user_id}

medium

A. {"user_id": 42}

B. TypeError because user_id is not a string

C. 404 Not Found error

D. {"user_id": "42"}

Solution

1. Step 1: Understand parameter type conversion

   The path parameter user_id is declared as int, so FastAPI converts the string "42" from the URL to integer 42.

2. Step 2: Check the returned JSON

   The function returns a dictionary with key "user_id" and value 42 as an integer, which FastAPI converts to JSON.

3. Final Answer:

   {"user_id": 42} -> Option A

4. Quick Check:

   Path param type int converts "42" to 42 [OK]

Hint: Check parameter type hints to know output data type [OK]

Common Mistakes:

• Assuming path parameters are always strings
• Expecting a 404 error without reason
• Confusing JSON string with Python dict

4. What is wrong with this FastAPI path parameter code?

from fastapi import FastAPI
app = FastAPI()

@app.get("/products/{product_id}")
async def get_product(product_id):
    return {"product": product_id}

medium

A. Function must be synchronous, not async

B. Missing type annotation for product_id

C. Incorrect route path syntax

D. Return statement must be a string, not dict

Solution

1. Step 1: Check function parameter declaration

   The parameter product_id lacks a type hint, so FastAPI treats it as a string by default but it's best practice to specify type.

2. Step 2: Identify the issue

   While the code runs, missing type annotation can cause unexpected behavior or lack of validation.

3. Final Answer:

   Missing type annotation for product_id -> Option B

4. Quick Check:

   Always add type hints for path parameters [OK]

Hint: Always add type hints to path parameters for validation [OK]

Common Mistakes:

• Ignoring type hints thinking they are optional
• Confusing async with sync function requirements
• Thinking route path syntax is wrong when it is correct

5. You want to create a FastAPI route that accepts two path parameters: category (string) and item_id (integer). Which of the following is the correct way to define this route and function?

hard

A. @app.get("/items/{category}/{item_id}")
async def read_item(category: str, item_id: int):
return {"category": category, "item_id": item_id}

B. @app.get("/items/{category}/{item_id}")
async def read_item(item_id: int, category: str):
return {"category": category, "item_id": item_id}

C. @app.get("/items/{category}/{item_id}")
async def read_item(category, item_id):
return {"category": category, "item_id": item_id}

D. @app.get("/items/{category}/{item_id}")
def read_item(category: str, item_id: int):
return {"category": category, "item_id": item_id}

Solution

1. Step 1: Match path parameters with function parameters

   The route declares two path parameters in order: category then item_id. The function parameters must match this order and names.

2. Step 2: Check type annotations and async usage

   @app.get("/items/{category}/{item_id}") async def read_item(category: str, item_id: int): return {"category": category, "item_id": item_id} correctly uses type hints (str and int) and async function, which is recommended in FastAPI.

3. Final Answer:

   @app.get("/items/{category}/{item_id}") async def read_item(category: str, item_id: int): return {"category": category, "item_id": item_id} -> Option A

4. Quick Check:

   Order and types must match route parameters [OK]

Hint: Order and names of parameters must match route path [OK]

Common Mistakes:

• Swapping parameter order in function
• Omitting type hints for path parameters
• Using sync function without reason