Why advanced patterns solve real problems in FastAPI - Challenge Your Understanding

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this FastAPI dependency injection example?

Consider this FastAPI code using dependency injection. What will the endpoint return when accessed?

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

def get_number():
    return 42

@app.get("/number")
async def read_number(num: int = Depends(get_number)):
    return {"number": num}

A {"number": null}

B {"number": "42"}

C {"num": 42}

D {"number": 42}

💡 Hint

Think about what the dependency function returns and how FastAPI injects it.

The dependency function get_number returns the integer 42. FastAPI injects this value into the endpoint parameter num. The endpoint returns a dictionary with key "number" and value 42.

📝 Syntax

intermediate

Which option correctly defines a FastAPI path operation with a query parameter?

Select the code snippet that correctly defines a GET endpoint with a required query parameter named 'q' of type string.

A

from fastapi import FastAPI
app = FastAPI()

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

B

from fastapi import FastAPI
app = FastAPI()

@app.get("/search")
async def search(q):
    return {"query": q}

C

from fastapi import FastAPI
app = FastAPI()

@app.get("/search")
async def search(q: int):
    return {"query": q}

D

from fastapi import FastAPI
app = FastAPI()

@app.get("/search")
async def search():
    return {"query": q}

💡 Hint

Query parameters need type annotations to work properly in FastAPI.

Option A correctly defines a query parameter 'q' with type string. Option A lacks type annotation, so FastAPI treats 'q' as a path parameter which is missing. Option A uses wrong type (int) if expecting string. Option A references 'q' without defining it.

🔧 Debug

advanced

Why does this FastAPI endpoint raise a validation error?

Examine the code and choose the reason why a POST request with JSON {"name": "Alice"} causes a validation error.

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.post("/items")
async def create_item(item: Item):
    return item

A The 'name' field is not a string, causing a type error.

B The endpoint method should be GET, not POST.

C The JSON is missing the required 'price' field, causing a validation error.

D The Pydantic model is missing a default value for 'price', causing a syntax error.

💡 Hint

Check the required fields in the Pydantic model and the JSON sent.

The Pydantic model Item requires both 'name' (string) and 'price' (float). The JSON only provides 'name', so validation fails because 'price' is missing.

❓ state_output

advanced

What is the output after calling this FastAPI endpoint twice?

Given this code, what will be the response of the second call to /counter?

FastAPI

from fastapi import FastAPI

app = FastAPI()
counter = 0

@app.get("/counter")
async def get_counter():
    global counter
    counter += 1
    return {"count": counter}

A {"count": 2}

B {"count": 0}

C {"count": 1}

D Raises a NameError due to global variable usage

💡 Hint

Think about how the global variable changes with each call.

The global variable counter starts at 0. Each call increments it by 1. The first call returns 1, the second call returns 2.

🧠 Conceptual

expert

Why do advanced FastAPI patterns like dependency injection improve real-world applications?

Choose the best explanation for why using advanced patterns such as dependency injection helps in building scalable FastAPI apps.

A They reduce the number of lines of code by automatically generating endpoints.

B They allow separating concerns, making code easier to test, maintain, and reuse across endpoints.

C They force all data to be stored in global variables for faster access.

D They eliminate the need for type annotations, simplifying function signatures.

💡 Hint

Think about how dependency injection affects code organization and testing.

Dependency injection helps separate concerns by letting you provide components like database connections or services to endpoints cleanly. This makes code easier to test, maintain, and reuse. Other options are incorrect or misleading.