Async Python

Learning Objectives

Asynchronous programming becomes particularly useful when an application spends a lot of time waiting for external operations such as network requests, databases, files, or other services.

What Is Asynchronous Programming?

In normal synchronous programming, operations generally execute one after another.

If one operation has to wait for a slow external resource, the program may remain idle until that operation finishes.

Asynchronous programming provides a way to allow other work to progress while an asynchronous operation is waiting.

This makes asynchronous programming especially valuable for I/O-bound applications.

Synchronous vs Asynchronous

Synchronous execution

def task_one():
    print("Task one")


def task_two():
    print("Task two")


task_one()
task_two()

The second function starts after the first function completes.

Asynchronous execution

import asyncio


async def task_one():
    await asyncio.sleep(2)
    print("Task one finished")


async def task_two():
    await asyncio.sleep(1)
    print("Task two finished")


async def main():

    await asyncio.gather(
        task_one(),
        task_two()
    )


asyncio.run(main())

Both coroutines can make progress during their waiting periods.

Blocking Operations

A blocking operation prevents the current execution flow from making progress until that operation finishes.

For example, a normal sleep call blocks the current thread:

import time

time.sleep(3)

In an asynchronous program, you normally use:

await asyncio.sleep(3)

Coroutines

A coroutine is an asynchronous function or coroutine object that can pause at an await point and later continue execution.

async def greet():

    print("Hello")

    await asyncio.sleep(1)

    print("Goodbye")

Calling an async function does not immediately execute the entire function like a normal function call.

result = greet()

The expression produces a coroutine object that must be awaited or scheduled for execution.

The async def Keyword

Use async def to define an asynchronous function.

async def download_data():

    print("Downloading data...")

    return "Data received"

An asynchronous function can contain one or more await expressions.

async def process():

    data = await download_data()

    print(data)

The await expression tells Python that the coroutine may need to pause while waiting for an asynchronous operation.

The await Keyword

await is used inside asynchronous code to wait for an awaitable operation to produce its result.

import asyncio


async def get_data():

    await asyncio.sleep(2)

    return "Data received"


async def main():

    result = await get_data()

    print(result)


asyncio.run(main())

The Event Loop

The event loop is a central part of Python's asynchronous execution model.

It manages asynchronous tasks and resumes them when their awaited operations are ready to continue.

You normally do not need to manually implement an event loop for everyday asyncio applications. High-level APIs such as asyncio.run() handle much of the setup for you.

The asyncio Module

Python's standard library includes the asyncio module for asynchronous programming.

import asyncio

It provides tools for working with:

• Coroutines
• Tasks
• Event loops
• Timers
• Synchronization primitives
• Concurrent asynchronous operations

One of the most common high-level functions is:

asyncio.run()

asyncio.run()

asyncio.run() is a convenient way to execute an asynchronous main coroutine.

import asyncio


async def main():

    print("Application started")

    await asyncio.sleep(1)

    print("Application finished")


asyncio.run(main())

The usual pattern is:

async def main():
    ...


asyncio.run(main())

Creating Tasks

A task schedules a coroutine to run within the event loop.

import asyncio


async def work(name, seconds):

    await asyncio.sleep(seconds)

    print(name, "finished")


async def main():

    task1 = asyncio.create_task(
        work("Task 1", 2)
    )

    task2 = asyncio.create_task(
        work("Task 2", 1)
    )

    await task1
    await task2


asyncio.run(main())

Once scheduled, the tasks can make progress concurrently when they reach awaitable operations.

asyncio.gather()

asyncio.gather() is a convenient way to execute multiple awaitable operations concurrently and collect their results.

import asyncio


async def get_price(product):

    await asyncio.sleep(1)

    return f"{product}: price received"


async def main():

    results = await asyncio.gather(
        get_price("Laptop"),
        get_price("Phone"),
        get_price("Tablet")
    )

    for result in results:
        print(result)


asyncio.run(main())

Instead of waiting for each operation independently, the three operations can overlap their waiting time.

asyncio.sleep()

asyncio.sleep() suspends the current coroutine without blocking the event loop in the same way a normal blocking sleep would.

import asyncio


async def countdown():

    print("Starting...")

    await asyncio.sleep(2)

    print("Two seconds passed")


asyncio.run(countdown())

It is extremely useful for demonstrating asynchronous execution, timers, retry delays, and scheduling concepts.

Concurrency

Concurrency means that multiple tasks can make progress during overlapping periods.

Consider three network operations that each spend two seconds waiting for a response.

Running them strictly one after another could take around six seconds in a simplified example.

If their waiting periods can overlap asynchronously, the overall elapsed time may be closer to the slowest individual operation rather than their total.

Async I/O

Asynchronous programming is particularly useful for input/output operations.

The important principle is that the library performing the operation must support asynchronous usage if you want to await it directly.

async def fetch_data():

    response = await some_async_operation()

    return response

Exceptions in Async Code

Asynchronous functions can raise exceptions just like normal functions.

import asyncio


async def risky_operation():

    await asyncio.sleep(1)

    raise ValueError("Something went wrong")


async def main():

    try:

        await risky_operation()

    except ValueError as error:

        print("Error:", error)


asyncio.run(main())

You should handle exceptions at a level where the application can make an appropriate decision.

Timeouts

Network and external operations should not necessarily wait forever.

Python provides asynchronous timeout tools that allow applications to stop waiting after a defined period.

import asyncio


async def slow_operation():

    await asyncio.sleep(5)

    return "Finished"


async def main():

    try:

        async with asyncio.timeout(2):

            result = await slow_operation()

            print(result)

    except TimeoutError:

        print("Operation timed out")


asyncio.run(main())

Task Cancellation

An asynchronous task can be cancelled when the application no longer needs its result.

import asyncio


async def long_task():

    try:

        await asyncio.sleep(10)

        print("Task completed")

    except asyncio.CancelledError:

        print("Task was cancelled")

        raise


async def main():

    task = asyncio.create_task(
        long_task()
    )

    await asyncio.sleep(1)

    task.cancel()

    try:

        await task

    except asyncio.CancelledError:

        print("Cancellation confirmed")


asyncio.run(main())

Cancellation is especially useful when requests disappear, timeouts occur, or a larger operation is no longer needed.

Async Generators

Python also supports asynchronous generators using async def together with yield.

import asyncio


async def numbers():

    for number in range(1, 4):

        await asyncio.sleep(1)

        yield number


async def main():

    async for number in numbers():

        print(number)


asyncio.run(main())

Notice the use of async for rather than the normal for loop.

Async Python with FastAPI

In the previous lesson, you learned that FastAPI supports asynchronous endpoints.

from fastapi import FastAPI

app = FastAPI()


@app.get("/products")
async def products():

    return {
        "message": "Products loaded"
    }

Async endpoints become especially useful when the endpoint needs to await asynchronous I/O.

import asyncio

from fastapi import FastAPI

app = FastAPI()


@app.get("/report")
async def report():

    await asyncio.sleep(1)

    return {
        "status": "Report ready"
    }

Common Async Python Mistakes

result = get_data()

result = await get_data()

time.sleep(5)

await asyncio.sleep(5)

Practice Exercises

Mini Challenge — Async Ecommerce Data Collector

Build a small asynchronous program that simulates collecting information from multiple ecommerce services.

Starter Code

import asyncio


async def fetch_store_data(store, delay, sales):

    await asyncio.sleep(delay)

    return {
        "store": store,
        "sales": sales
    }


async def main():

    results = await asyncio.gather(

        fetch_store_data(
            "Store A",
            2,
            1200
        ),

        fetch_store_data(
            "Store B",
            1,
            1800
        ),

        fetch_store_data(
            "Store C",
            3,
            950
        ),

        fetch_store_data(
            "Store D",
            1.5,
            2200
        )
    )

    print(results)


asyncio.run(main())

Knowledge Check

Test your understanding of asynchronous Python.

Lesson Summary

Asynchronous programming allows Python applications to efficiently manage tasks that spend significant time waiting for external operations.