Asyncio & the Event Loop Race Track

In typical web development, your CPU spends 99% of its time doing nothing: waiting for database queries, network APIs, or disk reads.

Synchronous code sits and blocks like someone waiting in line. Asynchronous code places an order, steps aside to serve the next customer, and comes back when the food is ready.

When you prefix a function with async def, it becomes a coroutine. When you call it, Python pauses and gives you an unstarted promise. The await keyword is how you hand control over to the event loop.

async def get_price(item):
    await asyncio.sleep(1)
    return 49.99

# In your main function:
price = get_price("laptop")  # ⚠️ No await!
print(price)

Is Asyncio multithreading? No! Asyncio uses a single thread with cooperative multitasking. Compare the three concurrency models below:

Because the event loop runs on one thread, any synchronous blocking function stops all other coroutines from ticking. Never call time.sleep() or synchronous requests.get() inside async functions!

# IDIOMATIC ASYNC:
import asyncio

async def worker():
    # Yields control back to event loop!
    await asyncio.sleep(2)  # ⏩ Other tasks keep running!

To fire multiple requests at the exact same time, use asyncio.gather() or Python 3.11's TaskGroup:

# Modern Python 3.11+ Structured Concurrency:
async with asyncio.TaskGroup() as tg:
    task1 = tg.create_task(fetch_user(user_id))
    task2 = tg.create_task(fetch_orders(user_id))
    task3 = tg.create_task(fetch_settings(user_id))

# When the block exits, all 3 tasks have finished cleanly!
print(task1.result(), task2.result(), task3.result())

Test your understanding of the event loop, coroutines, non-blocking I/O, and concurrency pitfalls. Score 5/5 to complete Chapter 9!

import asyncio

async def fetch(name, delay):
    await asyncio.sleep(delay)
    return f"{name} ready"

results = await asyncio.gather(fetch("A", 0.01), fetch("B", 0.01))
print(results)

1import asyncio
2 
3async def fetch(name, delay):
4    await asyncio.sleep(delay)
5    return f"{name} ready"
6 
7results = await asyncio.gather(fetch("A", 0.01), fetch("B", 0.01))
8print(results)

Run the code to see its output.

Run and measure the concurrent API aggregator in the Python Playground (code preloaded).

• Event Loop: A cooperative single-threaded scheduler that juggles I/O tasks while they wait.
• async def: Returns a coroutine object; it will not execute until awaited or scheduled.
• await: Pauses the current coroutine and yields execution back to the loop.
• Never Block: Use asyncio.sleep() and httpx/aiohttp, never time.sleep() or requests.
• asyncio.gather / TaskGroup: Run multiple coroutines concurrently and bundle results cleanly.