Python Asyncio – A Guide to Asynchronous Programming

in

First: what is asyncio? It’s the Python library that allows us to write concurrent code using the async/await syntax. That might sound like gibberish at first, but trust me, it’s not as complicated as it seems. In fact, it’s pretty ***** simple!

Let’s start with a basic example:

# Import the asyncio library
import asyncio

# Define a function called main, which is marked as asynchronous
async def main():
    print('Hello ...') # Print 'Hello ...' to the console
    await asyncio.sleep(1) # Wait for 1 second before continuing
    print('... World!') # Print '... World!' to the console

# Run the main function using the asyncio library
asyncio.run(main())

This code defines a function called `main()`, which prints “Hello…” and then waits for one second using the `asyncio.sleep()` function. After that, it prints “… World!” and exits. Pretty straightforward, right?

But what’s going on under the hood here? Well, asyncio uses an event loop to handle multiple tasks simultaneously without blocking the main thread of execution. This means that while `main()` is waiting for one second using `asyncio.sleep(1)`, other tasks can still be executed in parallel.

Now let’s take a closer look at how this works. When we call `asyncio.run(main())`, asyncio starts an event loop and runs the function `main()` asynchronously. The `await` keyword tells Python to pause execution of the current task until another task is ready to be executed (in our case, that’s after one second).

So what does this mean for us? Well, it means we can write more efficient and scalable code by taking advantage of asyncio’s concurrency features. For example:

# This script uses asyncio to asynchronously download web pages from two different URLs and print the results.

# Import necessary libraries
import asyncio # asyncio is a library for writing asynchronous code
import time # time is a library for working with time-related functions
from urllib.request import urlopen # urllib is a library for working with URLs

# Define a function to fetch a URL asynchronously
async def fetch_url(url):
    response = await asyncio.get(url) # use the built-in `asyncio.get()` function to download a web page asynchronously
    return await response.read() # return the downloaded web page

# Define the main function
async def main():
    tasks = [fetch_url('https://www.google.com'), fetch_url('https://www.facebook.com')] # create two concurrent tasks that will run simultaneously
    results = [] # create an empty list to store the results
    for task in asyncio.as_completed(tasks): # iterate through the tasks as they are completed
        result = await task # wait for each task to complete and add the result to a list
        results.append(result)
    print('Results:')
    for result in results: # iterate through the results and print them
        print(result.decode()) # decode the result to convert it from bytes to a string

asyncio.run(main()) # run the main function asynchronously

In this example, we define two functions `fetch_url()` and `main()`. The `fetch_url()` function uses the built-in `asyncio.get()` function to download a web page asynchronously (i.e., without blocking the main thread of execution). The `main()` function creates two concurrent tasks that will run simultaneously, waits for each task to complete using `asyncio.as_completed(tasks)`, and then prints out the results.

Asyncio is a powerful tool for writing asynchronous code in Python. It’s easy to use, efficient, and scalable. Give it a try and see how much faster your code can run with asyncio!

SICORPS