The Secret Life of Python: Introduction to Asyncio

- April 28, 2026

The Secret Life of Python: Introduction to Asyncio

A practical guide to coroutines, the event loop, and cooperative multitasking

#Python #Asyncio #AsyncAwait #ConcurrentProgramming

Margaret is a senior software engineer. Timothy is her junior colleague. They work in a grand Victorian library in London — the kind of place where code quality is the unspoken objective, and craftsmanship is the only thing that matters.

Episode 40

Timothy was looking at his Chess Club server. It was popular—so popular that he now had 5,000 players trying to connect at once to check their match rankings.

"I tried using Threads," Timothy told Margaret, "but with 5,000 threads, my laptop started screaming. Then I tried Processes, but my memory ran out after just a few dozen. How am I supposed to handle thousands of people at once if I can't afford the 'workers' to watch them?"

Margaret stood up and picked up three tennis balls. She started to juggle.

"You’ve been trying to hire 5,000 workers to stand and wait for 5,000 phone calls," she said, keeping the balls in the air. "That's expensive. Most of those workers are just sitting there doing nothing while the person on the other end of the line is typing."

"You don't need 5,000 workers," she said, catching the balls. "You need one Grand Juggler."

The Juggler’s Loop

"In the world of Asyncio," Margaret explained, "we don't create new parallel universes. We stay on a single thread, on a single core. But we change how we spend our time."

"Think of an Event Loop," she said. "The Juggler (Python) starts a task. The moment that task has to 'wait'—like waiting for a database to respond or a player to click a button—the Juggler doesn't sit and wait with it. They put that ball in the air and immediately grab the next one."

Timothy looked at the new syntax. Functions defined with async def are called coroutines. They look like Python, but they have a special power: they can be paused and resumed.

import asyncio

async def check_ranking(player_name):
    print(f"Juggler: Starting request for {player_name}...")
    
    # 'await' is the moment the Juggler throws the ball in the air.
    # Note: We use asyncio.sleep, NOT time.sleep. 
    # asyncio.sleep is 'cooperative'—it lets the Juggler move to other balls.
    # If we used time.sleep(1) here, the Juggler would freeze for EVERYONE!
    await asyncio.sleep(1) 
    
    print(f"Juggler: Finished request for {player_name}!")
    return f"{player_name} is Rank #1"

async def main():
    players = ["Alice", "Bob", "Charlie"]
    print("--- The Grand Juggler is starting ---")
    
    # 'gather' tells the Juggler to keep all these balls in the air at once
    results = await asyncio.gather(
        check_ranking("Alice"),
        check_ranking("Bob"),
        check_ranking("Charlie")
    )
    print(results)

# The one line that starts the Event Loop (Requires Python 3.7+)
if __name__ == "__main__":
    asyncio.run(main())

The Power of the Pause

Timothy watched the output. All three "Starting" messages appeared instantly, then a one-second pause, and then all three "Finished" messages appeared together.

"It took one second total," Timothy noted. "If this were normal code, it would have taken three seconds. But there’s only one thread! How did it do three things at once?"

"It didn't do them at once," Margaret corrected. "It waited for them at once. The Juggler is so fast at switching between balls that it feels like they are all moving. This is how a single Python server can handle thousands of players—by never, ever sitting still."

The Specialist’s Warning: The Juggler’s Weakness

"So this is the ultimate tool?" Timothy asked. "Can I use it for my Grandmaster Analysis math, too?"

Margaret shook her head. "No. Remember the Juggler's hands. If a task is 'heavy'—like a complex math problem—the Juggler has to hold onto that ball and can't throw it in the air. While they are doing math, the whole Loop stops. Every other player's ranking would freeze."

Timothy realized the distinction. Threads are for small waits. Processes are for big muscles. Asyncio is for the Grand Juggler who needs to handle the whole world at once.

Margaret’s Cheat Sheet: Intro to Asyncio

The Concurrency Toolbox

Threads
Best for: Small I/O waits
The Cost: Memory per thread

Processes
Best for: Heavy CPU Math
The Cost: High memory & CPU usage

Asyncio
Best for: Thousands of I/O waits
The Cost: Single-Threaded discipline

The Vocabulary

Coroutine: A function defined with async def. It can be paused and resumed.
await: The "Yield" point. It tells Python: "I’m waiting on the outside world; go do something else while I wait."
asyncio.run(): The standard way to start your event loop (requires Python 3.7+).

The Specialist's Wisdom

Cooperative Multitasking: Asyncio relies on you being a good citizen. You must use await to give the Juggler a chance to move to the next task.
Don't Block the Juggler: Never use time.sleep() inside an async function. time.sleep is a "selfish" sleep—it stops the whole thread, which means the Juggler stops juggling for everyone. Always use await asyncio.sleep().

Aaron Rose is a software engineer and technology writer at tech-reader.blog.

Catch up on the latest explainer videos, podcasts, and industry discussions below.

Search This Blog

Tech-Reader.blog