Async path operations in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this async FastAPI endpoint?

Consider this FastAPI async endpoint. What will the client receive when calling /hello?

FastAPI

from fastapi import FastAPI
import asyncio

app = FastAPI()

@app.get('/hello')
async def say_hello():
    await asyncio.sleep(0.1)
    return {'message': 'Hello, async world!'}

A {"message": "Hello, async world!"}

B SyntaxError due to missing await

C {"message": "Hello, world!"}

D RuntimeError because asyncio.sleep is blocking

💡 Hint

Remember async functions can use await to pause without blocking.

The async endpoint uses await asyncio.sleep(0.1) to pause briefly without blocking. It then returns the JSON with the message 'Hello, async world!'.

📝 Syntax

intermediate

Which option correctly defines an async FastAPI path operation?

Select the option that correctly defines an async GET endpoint in FastAPI that returns a JSON with key 'status' and value 'ok'.

A

from fastapi import FastAPI
app = FastAPI()

@app.get('/status')
async def status():
    return {'status': 'ok'}

B

from fastapi import FastAPI
app = FastAPI()

@app.get('/status')
def status():
    await return {'status': 'ok'}

C

from fastapi import FastAPI
app = FastAPI()

@app.get('/status')
async def status():
    return await {'status': 'ok'}

D

from fastapi import FastAPI
app = FastAPI()

@app.get('/status')
async def status():
    await {'status': 'ok'}

💡 Hint

Only async functions can use await, and await must be used with awaitable objects.

Option A defines an async function that returns a dictionary directly. Options A, B, and D misuse await or have syntax errors.

❓ state_output

advanced

What is the output when calling this async endpoint twice quickly?

Given this FastAPI async endpoint, what will be the output of two quick calls to /counter?

FastAPI

from fastapi import FastAPI
import asyncio

app = FastAPI()
counter = 0

@app.get('/counter')
async def get_counter():
    global counter
    await asyncio.sleep(0.05)
    counter += 1
    return {'count': counter}

A [{"count": 1}, {"count": 1}]

B [{"count": 1}, {"count": 2}]

C [{"count": 2}, {"count": 3}]

D RuntimeError due to race condition

💡 Hint

Think about how async functions run and how global variables update.

Each call awaits 0.05 seconds, then increments the global counter. The first call returns 1, the second returns 2.

🔧 Debug

advanced

Which option causes a runtime error in this async FastAPI endpoint?

Identify which option will cause a runtime error when the endpoint /data is called.

FastAPI

from fastapi import FastAPI
app = FastAPI()

@app.get('/data')
async def get_data():
    data = {'a': 1, 'b': 2}
    result = await data.get('a')
    return {'result': result}

A SyntaxError due to missing colon

B Returns {'result': 1}

C TypeError: object int can't be used in 'await' expression

D KeyError because 'a' is missing

💡 Hint

Remember await only works with awaitable objects like coroutines.

The code tries to await an integer (data.get('a') returns 1), which is not awaitable, causing a TypeError.

🧠 Conceptual

expert

Why should FastAPI path operations be async when performing I/O?

Select the best explanation why defining FastAPI path operations as async functions is important when they perform I/O operations like database queries or HTTP calls.

A Async path operations automatically cache I/O results to speed up responses.

B Async path operations prevent any exceptions from occurring during I/O.

C Async path operations convert blocking I/O calls into CPU-bound tasks to speed up processing.

D Async path operations allow FastAPI to handle other requests while waiting for I/O, improving concurrency and throughput.

💡 Hint

Think about what happens when a server waits for slow tasks.

Async functions let the server pause on slow I/O without blocking other requests, improving efficiency and user experience.

Practice

1. What is the main benefit of using async def for path operations in FastAPI?

easy

A. It makes the code run faster by using multiple CPU cores automatically.

B. It allows the app to handle many requests at the same time without waiting.

C. It forces the app to run all requests one after another in order.

D. It disables the use of await inside the function.

Solution

1. Step 1: Understand async behavior in FastAPI

   Using async def allows the server to pause on waiting tasks and handle other requests meanwhile.

2. Step 2: Compare options

   It allows the app to handle many requests at the same time without waiting. correctly describes this concurrency benefit. Options B, C, and D are incorrect because async does not automatically use multiple CPU cores, does not force sequential execution, and does not disable await.

3. Final Answer:

   It allows the app to handle many requests at the same time without waiting. -> Option B

4. Quick Check:

   Async = concurrent handling [OK]

Hint: Async means handling many requests without waiting [OK]

Common Mistakes:

• Thinking async uses multiple CPU cores automatically
• Believing async forces sequential request handling
• Confusing async with disabling await

2. Which of the following is the correct way to define an async path operation in FastAPI?

easy

A. async def read_item(): return {'item': 'value'}

B. def read_item(): return {'item': 'value'}

C. async read_item(): return {'item': 'value'}

D. def async read_item(): return {'item': 'value'}

Solution

1. Step 1: Recall async function syntax in Python

   Async functions must be declared with async def followed by the function name and parentheses.

2. Step 2: Check each option

   async def read_item(): return {'item': 'value'} uses the correct syntax. def read_item(): return {'item': 'value'} is a normal function, not async. async read_item(): return {'item': 'value'} misses def. def async read_item(): return {'item': 'value'} incorrectly places async after def.

3. Final Answer:

   async def read_item(): return {'item': 'value'} -> Option A

4. Quick Check:

   Async function = async def [OK]

Hint: Async functions start with 'async def' [OK]

Common Mistakes:

• Omitting 'def' after 'async'
• Placing 'async' after 'def'
• Using normal def instead of async def

3. Given this FastAPI async path operation, what will be the output when calling /wait?

from fastapi import FastAPI
import asyncio
app = FastAPI()

@app.get('/wait')
async def wait_seconds():
    await asyncio.sleep(1)
    return {'message': 'Done waiting'}

medium

A. Immediate {'message': 'Done waiting'} without delay

B. Empty response with status 204

C. Error because asyncio.sleep cannot be awaited

D. {'message': 'Done waiting'} after 1 second delay

Solution

1. Step 1: Understand await with asyncio.sleep

   The function pauses for 1 second asynchronously before returning the message.

2. Step 2: Determine output behavior

   After 1 second delay, the JSON response {'message': 'Done waiting'} is returned. No error occurs because asyncio.sleep is awaitable.

3. Final Answer:

   {'message': 'Done waiting'} after 1 second delay -> Option D

4. Quick Check:

   Await sleep = delayed response [OK]

Hint: Await asyncio.sleep pauses before response [OK]

Common Mistakes:

• Thinking response is immediate without delay
• Assuming asyncio.sleep is not awaitable
• Expecting empty or error response

4. Identify the error in this FastAPI async path operation:

from fastapi import FastAPI
app = FastAPI()

@app.get('/data')
def get_data():
    await fetch_data()
    return {'status': 'ok'}

medium

A. Missing async keyword before function definition

B. Missing await keyword before fetch_data()

C. fetch_data() is not defined

D. Return statement is outside the function

Solution

1. Step 1: Check function declaration with await usage

   Using await inside a function requires the function to be declared with async def.

2. Step 2: Identify the error

   The function is declared with normal def but uses await, causing a syntax error. Missing async keyword before function definition correctly identifies this.

3. Final Answer:

   Missing async keyword before function definition -> Option A

4. Quick Check:

   Await needs async def [OK]

Hint: Await inside function needs async def [OK]

Common Mistakes:

• Forgetting to add async before def
• Thinking await can be used in normal functions
• Ignoring that fetch_data() might be undefined (not focus here)

5. You want to create an async FastAPI path operation that fetches user data from a database asynchronously and returns it. Which code snippet correctly combines async path operation with awaiting a database call?

hard

A. def get_user():
user = await fetch_user_from_db()
return user

B. def get_user():
user = fetch_user_from_db()
return user

C. async def get_user():
user = await fetch_user_from_db()
return user

D. async def get_user():
user = fetch_user_from_db()
return user

Solution

1. Step 1: Understand async and await usage

   To await an async database call, the function must be async and use await before the call.

2. Step 2: Analyze each option

   async def get_user(): user = await fetch_user_from_db() return user correctly uses async def and await. def get_user(): user = fetch_user_from_db() return user is synchronous and misses await. async def get_user(): user = fetch_user_from_db() return user is async but misses await. def get_user(): user = await fetch_user_from_db() return user uses await in a normal function, which is invalid.

3. Final Answer:

   async def get_user(): user = await fetch_user_from_db() return user -> Option C

4. Quick Check:

   Async def + await call = correct pattern [OK]

Hint: Async function must await async calls inside [OK]

Common Mistakes:

• Using await in non-async functions
• Forgetting to await async calls
• Mixing sync and async code incorrectly