Explore what asynchronous programming is, when it should be used, how Python supports it, and measure its performance as compared to synchronous programming.
In the era of data-driven applications and network-intensive systems, writing efficient, scalable Python code is more important than ever. When working with tasks like downloading files, calling APIs, or reading from databases, performance can take a hit if your program spends most of its time waiting.
This is where asynchronous programming shines. It is a way of writing code where tasks that take time — like file downloads or network requests — don’t block the entire program while they finish. Instead, your program continues doing other things.
This model is especially powerful for I/O-bound tasks, where your CPU spends time waiting for external responses (like servers or disks), rather than doing computations.
When should you use it?
Asynchronous programming is most beneficial when:
- Your application performs many network or disk I/O operations.
- You’re working with concurrent user requests (e.g., in a web server).
- You want to optimise waiting time in data pipelines or API calls.
- You’re building apps that need to scale to thousands of tasks concurrently.
However, if your tasks are CPU-heavy (like model training or image processing), multithreading or multiprocessing is more appropriate.
How Python supports asynchronous programming
Python provides native support for async workflows using:
- async and await keywords to define asynchronous functions (coroutines).
- asyncio: The standard library for running async tasks and managing the event loop.
- aiohttp: A non-blocking HTTP client/server built on top of asyncio.
Use case: Downloading a 10MB file 10 times
To demonstrate the efficiency of asynchronous programming, we conducted an experiment where a 10MB file was downloaded from the internet ten times—first using sequential code and then using asynchronous code, as illustrated in Figure 1. The time taken for each method is compared in Figure 4.
The test file used is publicly available at https://speed.hetzner.de/10MB.bin.
Sequential approach (synchronous downloading)
In a sequential (or synchronous) approach, each file download begins only after the previous one has completed as shown in Figure 2. This method is simple to implement and easy to understand, making it a common choice for beginners. However, it has a significant downside when dealing with I/O-bound tasks like network requests — it leads to inefficient use of time and system resources. The total time taken becomes the sum of all individual wait times, which can be substantial when downloading multiple large files. Figure 2 illustrates this approach using Python’s requests library.
Asynchronous approach (using asyncio + aiohttp)
In contrast to the sequential method, the asynchronous approach allows multiple file downloads to proceed concurrently without waiting for each one to finish before starting the next as shown in Figure 3. Python’s asyncio framework, combined with the aiohttp library, provides a powerful and efficient way to perform non-blocking HTTP requests. By leveraging the event loop and coroutines, this approach overlaps the waiting time for network responses, significantly reducing the total execution time. Figure 3 demonstrates how asynchronous programming enables scalable and time-efficient file downloading in Python.
Measuring the benefits of asynchronous programming
To clearly observe the performance difference, the same 10MB file was downloaded 10 times using both sequential and asynchronous approaches. The sequential method took approximately 11.96 seconds, as each download was processed one after the other. In contrast, the asynchronous method completed all downloads in just 1.30 seconds by launching all tasks concurrently using Python’s asyncio and aiohttp libraries.
This performance gain is visually represented in Figure 4, where the bar graph compares the total execution times for both methods. The dramatic reduction in time highlights the power of asynchronous programming in efficiently handling I/O-bound operations.
Asynchronous programming is not just a clever optimisation — it is a foundational approach to building modern, scalable, and responsive Python applications. Whether you’re developing a web server, creating a data pipeline, or writing a high-performance script that interacts with the network or filesystem, async techniques can help you do more in less time.
This article demonstrated that the benefits of async are not theoretical. The experiment of downloading a 10MB file ten times revealed how asynchronous programming can drastically reduce execution time, showing a nearly 10x improvement over sequential execution.
So the key takeaways are:
- Asynchronous code overlaps waiting time, reducing bottlenecks.
- It enables high-concurrency programs with minimal overhead.
- Achieves parallel-like performance without threads or multiprocessing.
In an I/O-bound world, mastering async is not optional — it’s essential.
