Why routing organizes endpoints in FastAPI - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the FastAPI class.

FastAPI

from fastapi import [1]
app = FastAPI()

Drag options to blanks, or click blank then click option'

AResponse

BRequest

CFastAPI

DDepends

Attempts:

3 left

💡 Hint

Common Mistakes

Importing Request or Response instead of FastAPI.

The FastAPI class is imported to create the app instance which handles routing.

2fill in blank

medium

Complete the code to define a GET endpoint at path '/'.

FastAPI

@app.[1]("/")
def read_root():
    return {"message": "Hello World"}

Drag options to blanks, or click blank then click option'

Aget

Bpost

Cput

Ddelete

Attempts:

3 left

💡 Hint

Common Mistakes

Using post or put instead of get for a read endpoint.

The GET method defines an endpoint that responds to HTTP GET requests.

3fill in blank

hard

Fix the error in the route decorator to correctly organize the endpoint.

FastAPI

@app.[1]("/items/{item_id}")
def read_item(item_id: int):
    return {"item_id": item_id}

Drag options to blanks, or click blank then click option'

Apost

Bget

Cpatch

Dput

Attempts:

3 left

💡 Hint

Common Mistakes

Using post or put which are for creating or updating data.

The GET method is appropriate for reading an item by its ID in the URL path.

4fill in blank

hard

Fill both blanks to create a POST endpoint that accepts JSON data.

FastAPI

@app.[1]("/users")
async def create_user(user: [2]):
    return user

Drag options to blanks, or click blank then click option'

Apost

Bget

Cdict

Dint

Attempts:

3 left

💡 Hint

Common Mistakes

Using GET instead of POST or wrong parameter type.

POST is used to create resources. The user parameter is typed as dict to accept JSON data.

5fill in blank

hard

Fill all three blanks to organize endpoints with path and query parameters.

FastAPI

@app.[1]("/search")
async def search_items(q: [2] = None, limit: [3] = 10):
    return {"query": q, "limit": limit}

Drag options to blanks, or click blank then click option'

Aget

Bstr

Cint

Dpost

Attempts:

3 left

💡 Hint

Common Mistakes

Using POST for search or wrong parameter types.

GET method is used for searching. Query parameter q is a string, limit is an integer with default 10.

Practice

1. Why does FastAPI use routing to organize endpoints in an application?

easy

A. To create user interfaces without HTML

B. To make the app run faster by skipping functions

C. To connect specific URLs to the functions that handle them

D. To store data in a database automatically

Solution

1. Step 1: Understand routing purpose

   Routing links URLs (web addresses) to the code that runs when those URLs are visited.

2. Step 2: Match routing with function handling

   FastAPI uses routing to tell which function should respond to each URL.

3. Final Answer:

   To connect specific URLs to the functions that handle them -> Option C

4. Quick Check:

   Routing = URL to function link [OK]

Hint: Routing links URLs to functions handling requests [OK]

Common Mistakes:

• Thinking routing speeds up the app by skipping code
• Confusing routing with database storage
• Believing routing creates user interfaces

2. Which of the following is the correct way to define a GET route in FastAPI for the URL /items/?

easy

A. @app.get('/items')
def get_items():
return {'items': []}

B. @app.route('/items/')
def get_items():
return {'items': []}

C. @app.get_items('/items/')
def get_items():
return {'items': []}

D. @app.get('/items/')
def get_items():
return {'items': []}

Solution

1. Step 1: Identify FastAPI route decorator

   FastAPI uses @app.get() to define GET routes, not @app.route() or @app.get_items().

2. Step 2: Check URL syntax

   Both /items/ and /items work, but the question asks for /items/ exactly, so the decorator must match.

3. Final Answer:

   @app.get('/items/') def get_items(): return {'items': []} -> Option D

4. Quick Check:

   Use @app.get() for GET routes [OK]

Hint: Use @app.get() decorator for GET routes [OK]

Common Mistakes:

• Using @app.route() which is not FastAPI syntax
• Using incorrect decorator names like @app.get_items()
• Missing trailing slash when required

3. What will be the output when accessing the URL /hello in this FastAPI app?

from fastapi import FastAPI
app = FastAPI()

@app.get('/hello')
def say_hello():
    return {'message': 'Hello, FastAPI!'}

medium

A. {"message": "Hello, FastAPI!"}

B. Hello, FastAPI!

C. 404 Not Found error

D. SyntaxError

Solution

1. Step 1: Identify route and function output

   The route /hello returns a dictionary with key 'message' and value 'Hello, FastAPI!'.

2. Step 2: Understand FastAPI response format

   FastAPI automatically converts dictionaries to JSON responses, so the output is JSON with the message.

3. Final Answer:

   {"message": "Hello, FastAPI!"} -> Option A

4. Quick Check:

   Dict return = JSON response [OK]

Hint: FastAPI returns dicts as JSON automatically [OK]

Common Mistakes:

• Expecting plain text instead of JSON
• Thinking the route does not exist (404)
• Assuming syntax errors without checking code

4. Identify the error in this FastAPI route definition:

from fastapi import FastAPI
app = FastAPI()

@app.get('/users')
def get_users():
return {'users': ['Alice', 'Bob']}

medium

A. Incorrect decorator name @app.get

B. Missing indentation for the function body

C. Route URL should be '/users/' with trailing slash

D. Function must return a list, not a dictionary

Solution

1. Step 1: Check Python syntax indentation

   The function body must be indented under the function definition. Here, return is not indented, causing a syntax error.

2. Step 2: Verify decorator and return type

   The decorator @app.get is correct, and returning a dictionary is valid for JSON response.

3. Final Answer:

   Missing indentation for the function body -> Option B

4. Quick Check:

   Python requires indentation for function bodies [OK]

Hint: Check indentation after function definitions [OK]

Common Mistakes:

• Ignoring Python indentation rules
• Changing correct decorator names
• Thinking trailing slash is mandatory

5. You want to organize your FastAPI app with multiple routes for users and items. Which approach best keeps your code clean and easy to maintain?

hard

A. Use FastAPI's APIRouter to group related routes and include them in the main app

B. Define all routes directly in the main app file without grouping

C. Write all route functions inside a single large function

D. Create separate Python files but do not connect them to the main app

Solution

1. Step 1: Understand code organization needs

   When an app grows, grouping related routes helps keep code clean and easier to read.

2. Step 2: Use APIRouter for grouping

   FastAPI provides APIRouter to group routes logically and then include them in the main app, improving structure and maintenance.

3. Final Answer:

   Use FastAPI's APIRouter to group related routes and include them in the main app -> Option A

4. Quick Check:

   APIRouter groups routes for clean code [OK]

Hint: Group routes with APIRouter for clean structure [OK]

Common Mistakes:

• Putting all routes in one file without grouping
• Writing all routes inside one function
• Not connecting separate files to the main app