Why request bodies carry structured data in FastAPI - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why do request bodies carry structured data in FastAPI?

In FastAPI, why is it important that request bodies carry structured data like JSON objects instead of plain text?

A Because structured data allows FastAPI to automatically validate and convert the data into Python objects.

B Because plain text is faster to process but less secure than structured data.

C Because FastAPI only accepts XML data in request bodies, not JSON or plain text.

D Because structured data is required to make the request body smaller in size.

💡 Hint

Think about how FastAPI uses data models to handle incoming data.

FastAPI uses structured data like JSON to automatically check if the data matches expected types and shapes. This helps catch errors early and makes it easy to work with the data as Python objects.

❓ component_behavior

intermediate

What happens when FastAPI receives a structured request body?

Consider a FastAPI endpoint expecting a JSON body matching a Pydantic model. What does FastAPI do when it receives the request?

A It rejects the request if the JSON is valid but does not match the model exactly.

B It stores the JSON as a plain string and passes it to the endpoint without validation.

C It parses the JSON, validates it against the model, and passes a Python object to the endpoint function.

D It converts the JSON into XML before passing it to the endpoint.

💡 Hint

Think about how FastAPI uses Pydantic models.

FastAPI automatically parses and validates the JSON body against the Pydantic model, then provides a Python object to the endpoint function for easy use.

📝 Syntax

advanced

Identify the correct FastAPI endpoint to accept structured JSON data

Which FastAPI endpoint code correctly accepts a JSON request body matching the User model and returns the user's name?

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    name: str
    age: int

@app.post("/user")
def create_user(user: User):
    return {"user_name": user.name}

A The code is missing @app.get decorator instead of @app.post.

B The code is correct and will accept JSON matching User and return the name.

C The User model should inherit from object, not BaseModel.

D The function should return user.age instead of user.name.

💡 Hint

Check the decorator and model inheritance.

The code uses @app.post to accept POST requests with JSON matching the User model. The function returns the user's name correctly.

🔧 Debug

advanced

Why does this FastAPI endpoint fail to parse the request body?

Given this FastAPI code, why does sending a JSON body cause a validation error? from fastapi import FastAPI from pydantic import BaseModel app = FastAPI() class Item(BaseModel): id: int description: str @app.post("/items") def create_item(item: Item): return item Sent JSON body: {"id": "123", "description": "A book"}

A Because the id field is a string in JSON but expected as int in the model, causing validation error.

B Because the description field is missing in the JSON body.

C Because FastAPI requires XML format, not JSON.

D Because the endpoint uses @app.get instead of @app.post.

💡 Hint

Check the data types in the JSON vs the model.

The id field is sent as a string "123" but the model expects an int. FastAPI's validation fails because of this type mismatch.

❓ state_output

expert

What is the output of this FastAPI endpoint with nested structured data?

Given this FastAPI code, what will be the JSON response when posting the shown JSON body? from fastapi import FastAPI from pydantic import BaseModel app = FastAPI() class Address(BaseModel): city: str zip_code: str class User(BaseModel): name: str address: Address @app.post("/users") def create_user(user: User): return {"city": user.address.city, "name": user.name} JSON body sent: {"name": "Alice", "address": {"city": "Wonderland", "zip_code": "12345"}}

A {"city": null, "name": "Alice"}

B {"city": "12345", "name": "Alice"}

C {"city": "Wonderland", "name": null}

D {"city": "Wonderland", "name": "Alice"}

💡 Hint

Look at how nested models are accessed in the return statement.

The endpoint returns the city from the nested address and the user's name as provided in the JSON body.