Home / Python / Day 10: Advanced Python / Asynchronous Programming with asyncio

Asynchronous Programming with asyncio

Asynchronous programming with asyncio allows a single thread to efficiently handle many I/O-bound tasks concurrently using coroutines.

What is Asynchronous Programming?

Async programming lets a program start a task, move on to other work while waiting for it to complete, and come back to it later — all within a single thread. Python's asyncio module provides this through coroutines.

Coroutines and async/await

A coroutine is a special function defined with async def. Inside a coroutine, await pauses execution at a slow operation (like a network call) and lets other coroutines run, without blocking the whole program.

The Event Loop

The asyncio event loop manages and schedules coroutines, running them concurrently by switching between them whenever one hits an await on something not yet ready.

Running Coroutines

Use asyncio.run(main()) to start the event loop and run a top-level coroutine. Use asyncio.gather() to run multiple coroutines concurrently and wait for all of them.

async vs threading

Both help with I/O-bound concurrency, but asyncio uses a single thread with cooperative multitasking (coroutines voluntarily yield control), while threading uses OS-level threads. asyncio generally has lower overhead for large numbers of concurrent I/O tasks.

Real-World Use Cases

Async is widely used for web servers, chat applications, and making many simultaneous API requests efficiently (e.g., with aiohttp instead of requests).

Syntax

<pre><code>import asyncio

async def fetch_data(name, delay):
    print(f"Start fetching {name}")
    await asyncio.sleep(delay)  # non-blocking wait
    print(f"Finished fetching {name}")
    return f"{name} result"

async def main():
    # Run sequentially (slow: total time = sum of delays)
    result1 = await fetch_data("A", 2)
    result2 = await fetch_data("B", 1)

    # Run concurrently (fast: total time = max of delays)
    results = await asyncio.gather(
        fetch_data("C", 2),
        fetch_data("D", 1),
        fetch_data("E", 3)
    )
    print(results)

# Start the event loop
asyncio.run(main())

# Example: fetching multiple URLs concurrently (conceptual, needs aiohttp)
# import aiohttp
# async def fetch_url(session, url):
#     async with session.get(url) as response:
#         return await response.json()
#
# async def fetch_all(urls):
#     async with aiohttp.ClientSession() as session:
#         tasks = [fetch_url(session, url) for url in urls]
#         return await asyncio.gather(*tasks)
</code></pre>

Revision Notes

• async def defines a coroutine; await pauses it without blocking the program
• asyncio.run(main()) starts the event loop
• asyncio.gather() runs multiple coroutines concurrently
• Single-threaded but handles many I/O tasks efficiently via cooperative multitasking
• Use aiohttp (not requests) for async HTTP calls
• Best for high-concurrency I/O (web servers, many API calls)

Run Multiple Async Tasks Concurrently

Medium

Write an async function fetch_all(delays) where delays is a list of numbers. For each delay, create a coroutine that awaits asyncio.sleep(delay) and then returns that delay value. Use asyncio.gather() to run all coroutines concurrently and return a list of results in the same order as the input.

Input:

[0.01, 0.02, 0.005]

Output:

[0.01, 0.02, 0.005]

Show Hint

Define an inner async function "async def task(delay): await asyncio.sleep(delay); return delay", then use asyncio.gather(*(task(d) for d in delays)).

Solve this Challenge

Show Solution

import asyncio

async def fetch_all(delays):
    async def task(delay):
        await asyncio.sleep(delay)
        return delay

    return await asyncio.gather(*(task(d) for d in delays))

result = asyncio.run(fetch_all([0.01, 0.02, 0.005]))
print(result)

Multithreading in Python Python Performance Optimization