Dependencies with parameters in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this FastAPI dependency with parameter?

Consider this FastAPI dependency that takes a parameter and returns a greeting message. What will be the response when accessing /hello?name=Alice?

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

def greet(name: str):
    return f"Hello, {name}!"

@app.get("/hello")
async def hello(message: str = Depends(greet)):
    return {"message": message}

A {"message": "Hello, Alice!"}

B {"message": "Hello, name!"}

C {"message": "Hello!"}

D {"message": "Hello, None!"}

💡 Hint

Think about how the Depends function injects the parameter from the query string.

The dependency greet takes the query parameter name. FastAPI automatically passes the query parameter name=Alice to greet. So the returned message is "Hello, Alice!".

📝 Syntax

intermediate

Which option correctly defines a FastAPI dependency with a default parameter value?

Choose the correct way to define a dependency function that takes an optional parameter lang with default value "en".

A

def get_language(lang: str):
    if not lang:
        lang = "en"
    return lang

B

def get_language(lang: str = "en"):
    return lang

C

def get_language(lang: str = Query("en")):
    return lang

D

def get_language(lang: str = Depends("en")):
    return lang

💡 Hint

Remember to use FastAPI's Query for default query parameters in dependencies.

Option C uses Query("en") to set a default query parameter value for lang. Option C sets a Python default but does not integrate with FastAPI's query system. Option C lacks FastAPI parameter declaration. Option C misuses Depends.

🔧 Debug

advanced

Why does this FastAPI dependency with parameter cause a runtime error?

Examine the code below. Why does calling /items cause a runtime error?

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

def get_multiplier(factor: int):
    return lambda x: x * factor

@app.get("/items")
async def read_items(multiplier = Depends(get_multiplier)):
    return {"result": multiplier(5)}

A RuntimeError because get_multiplier requires a parameter but FastAPI cannot provide it automatically

B TypeError because multiplier is not callable

C KeyError because 'factor' is missing in request

D No error, returns {"result": 25}

💡 Hint

Think about how FastAPI injects parameters into dependencies.

The dependency function get_multiplier requires a parameter factor, but FastAPI does not know how to provide it automatically. This causes a runtime error because the dependency cannot be resolved.

🧠 Conceptual

advanced

How does FastAPI handle dependencies with parameters that have default values?

Which statement best describes how FastAPI resolves dependencies with parameters that have default values?

A FastAPI raises an error if the parameter has a default value

B FastAPI always requires the parameter to be provided in the request, ignoring defaults

C FastAPI ignores default values and sets parameters to None

D FastAPI uses the default value if the parameter is not provided in the request

💡 Hint

Think about how query parameters with defaults behave in FastAPI.

FastAPI uses the default value for dependency parameters if the client does not provide them in the request. This allows optional parameters with defaults.

❓ state_output

expert

What is the output of this FastAPI dependency chain with parameters?

Given the following code, what is the JSON response when accessing /compute?value=3?

FastAPI

from fastapi import FastAPI, Depends, Query

app = FastAPI()

def double(value: int = Query(...)):
    return value * 2

def add_five(number: int = Depends(double)):
    return number + 5

@app.get("/compute")
async def compute(result: int = Depends(add_five)):
    return {"result": result}

A {"result": 8}

B {"result": 11}

C {"result": 16}

D {"result": 10}

💡 Hint

Trace the dependency calls and their returned values step-by-step.

The query parameter value=3 is passed to double, which returns 6. Then add_five receives 6 and returns 11. The endpoint returns {"result": 11}.