Topic 25024 min readStructured Tutorial

Async Programming in Python

Quick Answer

Async Programming explains async programming is a powerful technique in Python that allows you to write concurrent code using the async and await keywords.

Learning Objectives

Explain the purpose of Async Programming in a practical learning context.
Identify the main ideas, terms, and decisions involved in Async Programming.
Apply Async Programming in a simple real-world scenario or practice task.

Introduction

Async programming is a powerful technique in Python that allows you to write concurrent code using the async and await keywords.

This tutorial introduces you to the core concepts of async programming, helping you write efficient and responsive Python applications.

Concurrency is not parallelism. – Rob Pike

What is Async Programming?

Async programming enables a program to handle multiple tasks seemingly at the same time without using multiple threads or processes.

It is especially useful for I/O-bound operations like network requests, file reading, or database queries where waiting times can be significant.

Improves application responsiveness
Efficiently manages I/O-bound tasks
Uses cooperative multitasking instead of preemptive

Core Concepts of Async in Python

Python's async programming is built around the async and await keywords, coroutines, and the event loop.

Understanding these concepts is key to writing effective async code.

Coroutine: A special function declared with async def that can pause and resume execution.
await: Used to pause a coroutine until an awaitable completes.
Event Loop: The core that runs asynchronous tasks and callbacks, managing their execution.

Coroutines

Coroutines are functions defined with async def and can be paused and resumed, allowing other tasks to run during waiting periods.

Declared with async def
Return coroutine objects when called
Executed by the event loop

The Event Loop

The event loop is responsible for scheduling and running coroutines and callbacks.

It manages asynchronous tasks and ensures they run efficiently without blocking the program.

Runs in a single thread
Handles task switching
Coordinates I/O operations

Writing Async Code in Python

To write async code, define coroutines with async def and use await to pause execution until an asynchronous operation completes.

The asyncio module provides the event loop and utilities to run async code.

Use async def to declare coroutines
Use await to call other coroutines or awaitables
Run the main coroutine using asyncio.run()

Practical Example: Async HTTP Requests

Let's see how async programming can be used to perform multiple HTTP requests concurrently, improving performance.

Practical Example

This example defines a coroutine that prints 'Hello', waits asynchronously for 1 second, then prints 'World'.

This example fetches multiple URLs concurrently using aiohttp and asyncio.gather to run tasks in parallel.

Examples

Basic Async Coroutine Example

import asyncio

async def say_hello():
    print('Hello')
    await asyncio.sleep(1)
    print('World')

asyncio.run(say_hello())

This example defines a coroutine that prints 'Hello', waits asynchronously for 1 second, then prints 'World'.

Async HTTP Requests with aiohttp

import asyncio
import aiohttp

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = ['https://example.com', 'https://python.org', 'https://asyncio.org']
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        for content in results:
            print(f'Fetched {len(content)} characters')

asyncio.run(main())

This example fetches multiple URLs concurrently using aiohttp and asyncio.gather to run tasks in parallel.

Best Practices

Use async programming for I/O-bound and high-level structured network code.
Avoid blocking calls inside async functions; use async equivalents.
Use asyncio.run() to execute the main coroutine in Python 3.7+.
Handle exceptions in coroutines to prevent silent failures.
Use asyncio.gather() to run multiple coroutines concurrently.

Common Mistakes

Calling async functions without await, resulting in coroutine objects not being executed.
Mixing blocking code with async code, causing the event loop to freeze.
Not properly closing asynchronous resources like sessions or connections.
Using threading or multiprocessing unnecessarily with async code.
Ignoring exception handling in async tasks.

Hands-on Exercise

Create an Async Countdown

Write an async function that counts down from 5 to 1, waiting one second between each number, then prints 'Lift off!'.

Expected output: Numbers 5 to 1 printed one per second, followed by 'Lift off!'.

Hint: Use asyncio.sleep() to wait asynchronously.

Fetch Multiple URLs Concurrently

Use aiohttp and asyncio to fetch the content of three different websites concurrently and print the length of each response.

Expected output: Printed lengths of the content fetched from each URL.

Hint: Use asyncio.gather() to run fetch tasks concurrently.

Interview Questions

What is the difference between threading and async programming in Python?

Interview

Threading uses multiple threads to achieve concurrency, which can involve context switching and synchronization overhead. Async programming uses a single-threaded event loop to manage multiple tasks cooperatively, making it more efficient for I/O-bound operations.

How do you define a coroutine in Python?

Interview

A coroutine is defined using the async def syntax. Calling it returns a coroutine object that must be awaited or scheduled in an event loop.

What is the role of the event loop in async programming?

Interview

The event loop schedules and runs asynchronous tasks and callbacks, managing their execution without blocking the program.