Asynchronous Python

What you'll learn

Async lets a single thread juggle thousands of I/O operations by switching between them whenever one is waiting. No threads, no locks, no race conditions — just cooperative pauses at await.

By the end of this lesson you'll be able to:

• Explain what problem async solves and how the event loop works
• Write coroutines with async def and await
• Run many coroutines concurrently with asyncio.gather
• Group related tasks safely with asyncio.TaskGroup
• Know when async is the right tool — and when it isn't

What async solves

Threads work for concurrency, but each thread carries memory and switching overhead — a few thousand is a lot. Async runs on one thread and an event loop: whenever a task hits an await on something slow, the loop parks it and runs another ready task. This scales to tens of thousands of simultaneous connections, which is why web servers and network tools love it.

Coroutines: async & await

A function defined with async def is a coroutine. Calling it doesn't run it — it returns a coroutine object you must await (or hand to the event loop with asyncio.run). await means "pause here until this finishes, and let other work run meanwhile."

import asyncio

async def greet(name):
    print(f"hello {name}")
    await asyncio.sleep(1)        # give control back while "waiting"
    print(f"bye {name}")

asyncio.run(greet("Ada"))         # run the coroutine to completion

Running many at once

The payoff appears when you await many things together. asyncio.gather starts all the coroutines and waits for them concurrently — three one-second calls finish in about one second, not three:

import asyncio, time

async def fetch(n):
    await asyncio.sleep(1)        # simulate a 1s network call
    return n * 10

async def main():
    start = time.perf_counter()
    results = await asyncio.gather(fetch(1), fetch(2), fetch(3))
    print(results, f"in {time.perf_counter() - start:.0f}s")

asyncio.run(main())

Structured concurrency

Modern asyncio (Python 3.11+) prefers asyncio.TaskGroup: it starts tasks and guarantees they all complete before the async with block exits. If any task raises, the group cancels the rest and propagates the error — no silently lost tasks.

import asyncio

async def work(n):
    await asyncio.sleep(0.1)
    return n * n

async def main():
    async with asyncio.TaskGroup() as tg:   # Python 3.11+
        t1 = tg.create_task(work(2))
        t2 = tg.create_task(work(3))
    # the block exits only when every task is done
    print(t1.result(), t2.result())

asyncio.run(main())

When to use async

Async shines for high-concurrency I/O: many network calls, web servers, chat, scraping. The catch is that everything must cooperate — one blocking call freezes the entire loop.

import asyncio, time

async def bad():
    time.sleep(1)          # WRONG: blocks the whole event loop!

async def good():
    await asyncio.sleep(1) # RIGHT: yields control while waiting

Recap & quick check

You can now write fast, concurrent code. Next we make sure it's correct code — and stays that way. Next up: Module 32 — Testing.