First FastAPI application - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this FastAPI endpoint?

Consider this FastAPI app code. What will the endpoint /hello return when accessed?

FastAPI

from fastapi import FastAPI

app = FastAPI()

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

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

B "Hello, FastAPI!"

C {"hello": "message"}

D 404 Not Found error

💡 Hint

Look at the dictionary returned by the endpoint function.

The endpoint returns a JSON response with a key 'message' and value 'Hello, FastAPI!'. FastAPI automatically converts the dictionary to JSON.

📝 Syntax

intermediate

Which option will cause a syntax error in this FastAPI app?

Identify the option that will cause a syntax error when running this FastAPI app code snippet.

FastAPI

from fastapi import FastAPI

app = FastAPI()

@app.get('/items/{item_id}')
async def read_item(item_id: int):
    return {"item_id": item_id}

A Using async def with a return statement

B Removing the colon after the function definition line

C Changing the route decorator to @app.get('/items/{item_id}') without quotes

D Returning a dictionary from the function

💡 Hint

Check Python function syntax carefully.

Python functions require a colon at the end of the definition line. Removing it causes a SyntaxError.

❓ state_output

advanced

What is the value of counter after 3 requests?

Given this FastAPI app, what will be the value of counter after three separate requests to /count?

FastAPI

from fastapi import FastAPI

app = FastAPI()
counter = 0

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

A Raises an error due to global variable

B 1

C 3

D 0

💡 Hint

Think about how global variables behave in a running FastAPI app.

The global variable increments by 1 on each request, so after 3 requests it will be 3.

🔧 Debug

advanced

Why does this FastAPI app raise a runtime error?

Examine the code and select the reason for the runtime error when accessing /data.

FastAPI

from fastapi import FastAPI

app = FastAPI()

@app.get('/data')
def get_data():
    return await fetch_data()

def fetch_data():
    return {"data": 123}

A Using await inside a non-async function

B Missing return statement in fetch_data

C Route decorator syntax is incorrect

D fetch_data is not defined

💡 Hint

Check if the function using await is declared async.

You cannot use await inside a regular function; it must be inside an async function.

🧠 Conceptual

expert

Which option best describes FastAPI's automatic data validation?

FastAPI automatically validates request data using which feature?

A Manual checks inside endpoint functions

B Custom middleware that intercepts requests

C Using Python's built-in type hints without extra libraries

D Pydantic models that define data schemas

💡 Hint

Think about how FastAPI knows what data to expect and how to check it.

FastAPI uses Pydantic models to define and validate data automatically based on schemas.

Practice

1. What does the @app.get("/") decorator do in a FastAPI application?

easy

A. It starts the FastAPI server automatically.

B. It imports the FastAPI library into the project.

C. It defines a route that responds to HTTP GET requests at the root URL.

D. It creates a database connection for the app.

Solution

1. Step 1: Understand the decorator role

   The @app.get("/") decorator tells FastAPI to listen for GET requests at the root URL path.

2. Step 2: Connect decorator to route handling

   When a user visits the root URL with a GET request, the function below this decorator runs and returns a response.

3. Final Answer:

   It defines a route that responds to HTTP GET requests at the root URL. -> Option C

4. Quick Check:

   Route decorator = defines GET route [OK]

Hint: Decorators like @app.get define routes for HTTP GET requests [OK]

Common Mistakes:

• Thinking @app.get starts the server
• Confusing route decorators with imports
• Assuming it creates database connections

2. Which of the following is the correct way to create a FastAPI app instance?

easy

A. app = FastAPI.create()

B. app = FastAPI()

C. app = FastAPI

D. app = fastapi()

Solution

1. Step 1: Recall FastAPI app creation syntax

   The FastAPI app is created by calling the FastAPI class with parentheses: FastAPI().

2. Step 2: Check each option for correctness

   app = FastAPI() correctly calls FastAPI(). app = fastapi() uses lowercase which is incorrect. app = FastAPI misses parentheses, so it is a class reference, not an instance. app = FastAPI.create() uses a non-existent method.

3. Final Answer:

   app = FastAPI() -> Option B

4. Quick Check:

   FastAPI instance = FastAPI() [OK]

Hint: Create app with FastAPI() including parentheses [OK]

Common Mistakes:

• Omitting parentheses when creating app
• Using lowercase 'fastapi' instead of 'FastAPI'
• Trying to call a non-existent create() method

3. Given this FastAPI code snippet, what will be the JSON response when accessing /hello?

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. {"say_hello": "Hello, FastAPI!"}

D. 404 Not Found error

Solution

1. Step 1: Identify route and return value

   The route /hello is defined with a GET method. The function returns a dictionary with key "message" and value "Hello, FastAPI!".

2. Step 2: Understand FastAPI response format

   FastAPI automatically converts returned dictionaries to JSON responses. So the response will be JSON with the same key-value pair.

3. Final Answer:

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

4. Quick Check:

   Returned dict = JSON response [OK]

Hint: Returned dict becomes JSON response automatically [OK]

Common Mistakes:

• Expecting plain string instead of JSON
• Confusing function name as JSON key
• Assuming route does not exist causing 404

4. What is wrong with this FastAPI code?

from fastapi import FastAPI
app = FastAPI()

@app.get("/items")
def read_items():
return {"items": [1, 2, 3]}

medium

A. The import statement is incorrect.

B. The route path should be '/item' not '/items'.

C. FastAPI does not support returning lists in JSON.

D. The function read_items is missing an indentation for the return statement.

Solution

1. Step 1: Check Python syntax indentation

   Python requires the return statement inside the function to be indented. Here, return is not indented, causing a syntax error.

2. Step 2: Verify other parts

   The route path '/items' is valid, returning lists is supported, and the import is correct.

3. Final Answer:

   The function read_items is missing an indentation for the return statement. -> Option D

4. Quick Check:

   Python indentation error = missing indent [OK]

Hint: Indent return inside function to avoid syntax errors [OK]

Common Mistakes:

• Ignoring Python indentation rules
• Thinking route path must be singular
• Believing FastAPI can't return lists

5. You want to create a FastAPI app that returns a greeting with a user name from the URL path, like /greet/Alice. Which code correctly implements this?

hard

A. from fastapi import FastAPI
app = FastAPI()

@app.get("/greet/{name}")
def greet(name: str):
return {"greeting": f"Hello, {name}!"}

B. from fastapi import FastAPI
app = FastAPI()

@app.get("/greet")
def greet(name: str):
return {"greeting": f"Hello, {name}!"}

C. from fastapi import FastAPI
app = FastAPI()

@app.get("/greet/{name}")
def greet():
return {"greeting": "Hello!"}

D. from fastapi import FastAPI
app = FastAPI()

@app.get("/greet/{name}")
def greet(name):
return {"greeting": "Hello, name!"}

Solution

1. Step 1: Use path parameter in route

   The route must include {name} in the path to capture the user name from the URL.

2. Step 2: Define function with typed parameter and return greeting

   The function should accept name: str and return a dictionary with a greeting using an f-string to insert the name.

3. Step 3: Check other options for errors

   from fastapi import FastAPI app = FastAPI() @app.get("/greet") def greet(name: str): return {"greeting": f"Hello, {name}!"} misses the path parameter in the route. from fastapi import FastAPI app = FastAPI() @app.get("/greet/{name}") def greet(): return {"greeting": "Hello!"} does not accept the name parameter. from fastapi import FastAPI app = FastAPI() @app.get("/greet/{name}") def greet(name): return {"greeting": "Hello, name!"} does not use f-string, so it returns the literal text "name".

4. Final Answer:

   Uses path parameter and returns personalized greeting. -> Option A

5. Quick Check:

   Path param + f-string = personalized greeting [OK]

Hint: Use {param} in route and f-string to insert it in response [OK]

Common Mistakes:

• Not including path parameter in route string
• Forgetting to type the function parameter
• Returning literal string instead of formatted string