Async vs sync decision in FastAPI - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a synchronous FastAPI route handler.

FastAPI

from fastapi import FastAPI
app = FastAPI()

@app.get("/sync")
def [1]():
    return {"message": "Hello from sync"}

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

Aasync_handler

Bsync_handler

Chandle_async

Dasync_func

Attempts:

3 left

💡 Hint

Common Mistakes

Using async def for a synchronous route

Naming the function with async prefix when it's sync

The function is synchronous, so it should be a normal def function, here named sync_handler.

2fill in blank

medium

Complete the code to define an asynchronous FastAPI route handler.

FastAPI

from fastapi import FastAPI
app = FastAPI()

@app.get("/async")
async def [1]():
    return {"message": "Hello from async"}

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

Ahandle_sync

Bsync_handler

Casync_handler

Dsync_func

Attempts:

3 left

💡 Hint

Common Mistakes

Using def instead of async def for async routes

Naming the function with sync prefix when it's async

Asynchronous route handlers use async def, so the function name async_handler fits the async style.

3fill in blank

hard

Fix the error in the async route handler by completing the code.

FastAPI

from fastapi import FastAPI
app = FastAPI()

@app.get("/data")
async def get_data():
    data = await [1]()
    return data

async def fetch_data():
    return {"info": "sample"}

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

Adata_fetch

Bget_data

Cfetch

Dfetch_data

Attempts:

3 left

💡 Hint

Common Mistakes

Awaiting a non-async function

Calling a function that does not exist

The await keyword must be used with an async function, here fetch_data().

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that filters async results.

FastAPI

results = {item: value for item, value in data.items() if value [1] 10 and item.startswith([2])}

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

A>

B"a"

C<

D"z"

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong comparison operator

Forgetting quotes around string literals

The comprehension filters items with value greater than 10 and keys starting with "a".

5fill in blank

hard

Fill all three blanks to create an async function that fetches and filters data.

FastAPI

async def process_data():
    raw = await [1]()
    filtered = {k: v for k, v in raw.items() if v [2] 5 and k.[3]("b")}
    return filtered

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

Afetch_data

B>

Cstartswith

Dget_data

Attempts:

3 left

💡 Hint

Common Mistakes

Not awaiting the async function

Using wrong operators or methods in filtering

The async function awaits fetch_data(), then filters items with value greater than 5 and keys starting with "b".

Practice

1. In FastAPI, when should you choose an async function over a def synchronous function?

easy

A. When the task is CPU-heavy and requires intense calculations

B. When the task involves waiting for external resources like databases or APIs

C. When you want the function to run slower

D. When you want to block other tasks until this finishes

Solution

1. Step 1: Understand async purpose in FastAPI

   Async functions let your app wait for external tasks like database calls without stopping other work.

2. Step 2: Match task type to function type

   Waiting for external resources is I/O-bound, so async is best to avoid blocking.

3. Final Answer:

   When the task involves waiting for external resources like databases or APIs -> Option B

4. Quick Check:

   Async = I/O-bound tasks [OK]

Hint: Use async for waiting tasks, sync for CPU tasks [OK]

Common Mistakes:

• Choosing async for CPU-heavy tasks
• Thinking async makes code slower
• Using sync for I/O-bound tasks

2. Which of the following is the correct way to define an asynchronous route handler in FastAPI?

easy

A. async get_data def(): return {'msg': 'Hello'}

B. def async get_data(): return {'msg': 'Hello'}

C. def get_data() async: return {'msg': 'Hello'}

D. async def get_data(): return {'msg': 'Hello'}

Solution

1. Step 1: Recall Python async function syntax

   Async functions start with async def followed by the function name and parentheses.

2. Step 2: Check each option's syntax

   Only async def get_data(): return {'msg': 'Hello'} uses the correct async def syntax; others are invalid Python syntax.

3. Final Answer:

   async def get_data(): return {'msg': 'Hello'} -> Option D

4. Quick Check:

   Async function syntax = async def [OK]

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

Common Mistakes:

• Placing async keyword after def
• Using 'def async' instead of 'async def'
• Incorrect order of keywords

3. Consider this FastAPI code snippet:

from fastapi import FastAPI
import time

app = FastAPI()

@app.get('/sync')
def sync_endpoint():
    time.sleep(2)
    return {'message': 'Done'}

@app.get('/async')
async def async_endpoint():
    await some_async_task()
    return {'message': 'Done'}

What is the main difference in behavior between /sync and /async endpoints?

medium

A. Both block other requests equally

B. /async blocks other requests; /sync allows concurrency

C. /sync blocks other requests during sleep; /async allows concurrent handling

D. Both allow full concurrency without blocking

Solution

1. Step 1: Understand sync endpoint behavior

   The sync_endpoint uses time.sleep(2), which blocks the thread and stops handling other requests during that time.

2. Step 2: Understand async endpoint behavior

   The async_endpoint uses await on an async task, allowing the server to handle other requests while waiting.

3. Final Answer:

   /sync blocks other requests during sleep; /async allows concurrent handling -> Option C

4. Quick Check:

   Sync blocks, async allows concurrency [OK]

Hint: Sync blocks during wait; async frees server to handle others [OK]

Common Mistakes:

• Assuming sync allows concurrency
• Thinking async blocks like sync
• Confusing await with blocking

4. You wrote this FastAPI route:

@app.get('/data')
async def get_data():
    result = time.sleep(1)
    return {'result': result}

What is the problem with this code?

medium

A. Using time.sleep inside async blocks the event loop, causing delays

B. Missing await keyword before time.sleep

C. Function should not be async if it returns a dictionary

D. No problem; code works fine

Solution

1. Step 1: Identify blocking call in async function

   time.sleep(1) is a blocking call that pauses the whole thread, including the async event loop.

2. Step 2: Understand async best practices

   In async functions, use non-blocking calls like await asyncio.sleep(1) to avoid blocking the event loop.

3. Final Answer:

   Using time.sleep inside async blocks the event loop, causing delays -> Option A

4. Quick Check:

   Blocking calls in async cause delays [OK]

Hint: Never use time.sleep in async; use await asyncio.sleep instead [OK]

Common Mistakes:

• Trying to await time.sleep
• Ignoring blocking effect of time.sleep
• Thinking async auto makes code non-blocking

5. You have a FastAPI app that fetches data from a slow external API and then processes it heavily with CPU calculations. How should you design your endpoint for best performance?

hard

A. Make the endpoint async to await the API call, then run CPU work in a separate thread or process

B. Make the endpoint fully async and run CPU work directly inside it

C. Make the endpoint synchronous and run both API call and CPU work sequentially

D. Use synchronous endpoint but call the API asynchronously

Solution

1. Step 1: Separate I/O-bound and CPU-bound tasks

   Fetching data from an external API is I/O-bound and benefits from async to avoid blocking.

2. Step 2: Handle CPU-heavy work properly

   CPU-heavy processing blocks the event loop if run directly in async code, so it should run in a separate thread or process.

3. Step 3: Combine async I/O with offloaded CPU work

   Use async endpoint to await API call, then offload CPU work to thread/process to keep responsiveness.

4. Final Answer:

   Make the endpoint async to await the API call, then run CPU work in a separate thread or process -> Option A

5. Quick Check:

   Async for I/O + thread/process for CPU [OK]

Hint: Async for waiting; thread/process for CPU work [OK]

Common Mistakes:

• Running CPU work directly in async code
• Making endpoint fully sync causing blocking
• Mixing async and sync calls incorrectly