Python Asyncio Tutorial


Asynchronous programming is an essential part of modern software development. It enables us to write concurrent code that can handle many input/output operations without blocking the execution of other tasks. Python provides a robust and efficient way of writing asynchronous code with asyncio.

Asyncio is a library in Python that allows you to write asynchronous code using coroutines, event loops, and other async-related constructs. It is built-in to Python 3.4 and above, making it easy to incorporate into your projects.

In this tutorial, we will cover the following topics:

1. Coroutines: How to define and use coroutines in asyncio.
2. Event Loops: How to create and use event loops in asyncio.
3. Tasks: How to create and manage tasks in asyncio.
4. Futures: How to use futures for asynchronous computation.
5. Synchronization Primitives: How to use locks, semaphores, and queues for synchronization in asyncio.

By the end of this tutorial, you will have a solid understanding of asyncio and be able to write efficient and scalable asynchronous programs in Python. Let’s get started!

What is Asyncio?

Asyncio is a Python library that allows for the implementation of asynchronous programming. Asyncio enables the creation of concurrent code that is more efficient and easier to read.

The traditional approach to concurrency in Python involves the use of threads. However, threads can be expensive and difficult to manage. Asyncio offers an alternative approach that is more lightweight and efficient.

Asyncio achieves concurrency through the use of coroutines. Coroutines are functions that can be paused and resumed at specific points during their execution. This allows multiple coroutines to run concurrently within a single thread.

To use Asyncio, we first need to define our coroutines using the `async def` syntax. Within our coroutine functions, we can use the `await` keyword to pause execution until a particular task completes.

Here’s an example of an Asyncio coroutine that sleeps for one second before printing a message:

import asyncio

async def my_coroutine():
    print("Starting coroutine")
    await asyncio.sleep(1)
    print("Coroutine finished")

In this example, we use the `asyncio.sleep()` function to pause execution of the coroutine for one second. This allows other coroutines to run in the meantime, resulting in more efficient and responsive code.

Asyncio also provides various utilities for managing tasks and event loops, such as `asyncio.gather()` for running multiple coroutines concurrently and `` for running the event loop until all tasks are complete.

Why use Asyncio?

Asynchronous programming is a programming paradigm that allows a program to perform multiple tasks concurrently. This can be especially useful in situations where a program needs to perform I/O bound operations such as network requests or file system operations. In Python, the Asyncio library provides an easy way to write asynchronous code.

One of the main reasons to use Asyncio is its ability to handle many tasks concurrently with a single thread. This can lead to significant performance improvements in I/O bound applications. By allowing the program to continue executing while waiting for I/O operations to complete, Asyncio can make better use of system resources and reduce overall latency.

Another benefit of using Asyncio is its ability to simplify complex concurrent code. Traditional concurrent programming models such as threads and processes can be difficult to reason about due to issues such as race conditions and deadlocks. With Asyncio, developers can write asynchronous code that is easier to understand and maintain.

Overall, the use of Asyncio in Python can lead to more efficient and simpler code for I/O bound applications.

Asyncio vs. Threads

In traditional programming, threads have been the go-to solution for handling concurrency. However, with the introduction of asyncio in Python 3.4, developers now have a new way to handle asynchronous programming that is more efficient and less error-prone than using threads.

The main difference between asyncio and threads is in how they handle concurrency. In a threaded program, each thread runs independently and can execute any code it needs to. This can lead to race conditions and other synchronization issues if not carefully managed.

On the other hand, asyncio uses a single event loop to manage all asynchronous tasks. Each task is registered with the event loop, which then schedules them for execution as needed. This approach allows for much more fine-grained control over how tasks are executed, making it easier to avoid common concurrency issues.

Another advantage of asyncio over threads is that it can handle many more concurrent tasks without running into resource constraints. Since threads require their own stack space and other resources, creating too many of them can cause performance issues or even crashes. With asyncio, however, only a single event loop is needed regardless of how many tasks are being handled.

Overall, while threads may still have some use cases where they are appropriate, asyncio provides a more modern and efficient way to handle asynchronous programming in Python. By using an event loop to manage tasks instead of relying on independent threads, developers can write more reliable and scalable code with fewer headaches along the way.

How to Use Asyncio

Asyncio is a library in Python that allows for asynchronous programming. It can be used to write concurrent code that performs multiple tasks simultaneously. Asyncio uses coroutines, which are special functions that allow for non-blocking I/O operations. In this section, we will cover the key concepts of asyncio including event loops, awaitables and coroutines, futures, tasks, and running asyncio code.

Event Loops:
An event loop is the core component of asyncio. It is responsible for managing all the asynchronous operations in an application. The event loop runs continuously and waits for events to occur. Whenever a new task is started, it is added to the event loop. The event loop then schedules the execution of these tasks in a non-blocking way.

Awaitables and Coroutines:
Awaitables are objects that can be awaited by coroutines. They include coroutines, Tasks, and Futures. Coroutines are special functions that can pause their execution at specific points using the “await” keyword until some operation completes. Coroutines can be defined using async/await syntax.

Futures represent the result of an asynchronous operation that has not yet completed. They are used to retrieve the result of an operation when it is ready. Futures can be created using asyncio.Future().

Tasks are high-level abstractions built on top of coroutines and futures. They represent a unit of work that needs to be executed asynchronously. Tasks are created using the asyncio.create_task() method.

Running Asyncio Code:
To run an asyncio program, you need to create an instance of the event loop using asyncio.get_event_loop(). You can then use this event loop to schedule all your tasks and awaitables. The main function should be wrapped inside an async function and executed using the run_until_complete() method of the event loop instance.

Here’s an example of how to use asyncio:

import asyncio

async def my_coroutine():
    print("Coroutine started")
    await asyncio.sleep(1)
    print("Coroutine ended")

async def main():
    task = asyncio.create_task(my_coroutine())
    await task

if __name__ == "__main__":
    loop = asyncio.get_event_loop()

In the above example, we define a coroutine `my_coroutine` that sleeps for one second and then prints a message. We then create a task using `create_task()` and wait for it to complete using `await`. Finally, we wrap the main function inside an async function and execute it using `run_until_complete()`. This will run the event loop until all tasks are completed.

Real-World Examples of Asyncio in Action

Python’s asyncio module is a powerful tool for writing asynchronous code. It can be used in various real-world applications where there is a need to handle multiple I/O-bound tasks concurrently. Here are some examples of how asyncio can be used in different domains:

1. Web Scraping: Web scraping involves extracting data from websites. This process can be time-consuming and requires handling multiple requests at once. Asyncio can help speed up web scraping by allowing multiple requests to be made concurrently without blocking the main thread. This means that while one request is being processed, other requests can also be executed in parallel.

Here’s an example of how asyncio can be used for web scraping:

import asyncio
import aiohttp

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

async def main():
    urls = ['', '']
    tasks = [asyncio.create_task(fetch(url)) for url in urls]
    results = await asyncio.gather(*tasks)

if __name__ == '__main__':

In this example, we first define a coroutine function `fetch` that takes a URL and returns the text content of the response. We then define another coroutine function `main` that creates tasks for each URL and executes them concurrently using `asyncio.gather`. The results of all the tasks are collected and printed.

2. Network Programming: Network programming involves communication between two or more devices over a network. Asyncio can help simplify network programming by allowing multiple connections to be handled concurrently without blocking the main thread.

Here’s an example of how asyncio can be used for network programming:

import asyncio
import socket

async def handle_client(client_reader, client_writer):
    data = await
    message = data.decode()
    addr = client_writer.get_extra_info('peername')
    print(f"Received {message!r} from {addr!r}")

async def main():
    server = await asyncio.start_server(handle_client, '', 8888)
    async with server:
        await server.serve_forever()

if __name__ == '__main__':

In this example, we first define a coroutine function `handle_client` that takes a reader and writer object for a client connection and reads the incoming data. We then define another coroutine function `main` that starts a server listening on localhost port 8888 and handles incoming connections using the `handle_client` function.

3. Data Streaming and Processing: Data streaming involves processing large amounts of data in real-time as it is generated. Asyncio can be used to handle data streams efficiently by allowing multiple streams to be processed concurrently without blocking the main thread.

Here’s an example of how asyncio can be used for data streaming:

import asyncio

async def process_stream(stream):
    async for data in stream:
        # process data

async def main():
    streams = [open(f'file_{i}.txt', 'r') for i in range(10)]
    tasks = [asyncio.create_task(process_stream(stream)) for stream in streams]
    await asyncio.gather(*tasks)

if __name__ == '__main__':

In this example, we first define a coroutine function `process_stream` that takes a stream object and processes the incoming data. We then define another coroutine function `main` that opens multiple files and creates tasks for each file stream to be processed concurrently using `asyncio.gather`.


In this tutorial, we have covered the basics of asynchronous programming in Python using the asyncio module. We learned about coroutines, tasks, and event loops, and how they work together to enable efficient execution of concurrent code.

We also explored some of the common use cases for asyncio, such as network I/O and CPU-bound tasks. With the help of some examples, we saw how to implement these use cases using asyncio.

Asynchronous programming can be a powerful tool for building high-performance applications that can handle large volumes of requests or perform computationally intensive tasks without blocking other operations. However, it requires careful design and implementation to avoid potential pitfalls such as race conditions or deadlocks.

Overall, asyncio provides a flexible and powerful framework for writing asynchronous code in Python. By mastering its concepts and techniques, you can build fast and scalable applications that take full advantage of modern hardware and network capabilities.
Interested in learning more? Check out our Introduction to Python course!

How to Become a Data Scientist PDF

Your FREE Guide to Become a Data Scientist

Discover the path to becoming a data scientist with our comprehensive FREE guide! Unlock your potential in this in-demand field and access valuable resources to kickstart your journey.

Don’t wait, download now and transform your career!

Pierian Training
Pierian Training
Pierian Training is a leading provider of high-quality technology training, with a focus on data science and cloud computing. Pierian Training offers live instructor-led training, self-paced online video courses, and private group and cohort training programs to support enterprises looking to upskill their employees.

You May Also Like

Data Science, Tutorials

Guide to NLTK – Natural Language Toolkit for Python

Introduction Natural Language Processing (NLP) lies at the heart of countless applications we use every day, from voice assistants to spam filters and machine translation. It allows machines to understand, interpret, and generate human language, bridging the gap between humans and computers. Within the vast landscape of NLP tools and techniques, the Natural Language Toolkit […]

Machine Learning, Tutorials

GridSearchCV with Scikit-Learn and Python

Introduction In the world of machine learning, finding the optimal set of hyperparameters for a model can significantly impact its performance and accuracy. However, searching through all possible combinations manually can be an incredibly time-consuming and error-prone process. This is where GridSearchCV, a powerful tool provided by Scikit-Learn library in Python, comes to the rescue. […]

Python Basics, Tutorials

Plotting Time Series in Python: A Complete Guide

Introduction Time series data is a type of data that is collected over time at regular intervals. It can be used to analyze trends, patterns, and behaviors over time. In order to effectively analyze time series data, it is important to visualize it in a way that is easy to understand. This is where plotting […]