First, what is asyncio? It’s basically a library in Python that allows us to write concurrent code using an elegant syntax called “async/await”. This means we can handle multiple tasks simultaneously without having to worry about threading or multiprocessing (which are both great options for certain situations but can be pretty complicated).
So how does asyncio work? Let’s take a look at some examples!
Example #1: Say you want to print “Hello” and then wait for one second before printing “World!” Here’s what it would look like using regular synchronous code:
# Import the time module to use its sleep function
import time
# Define the main function
def main():
# Print "Hello"
print("Hello")
# Use the sleep function to pause for 1 second
time.sleep(1)
# Print "World!"
print("World!")
# Check if the script is being run directly
if __name__ == "__main__":
# Call the main function
main()
# Output:
# Hello
# (1 second pause)
# World!
# Explanation:
# The time module is imported to use its sleep function, which pauses the execution of the program for a specified number of seconds.
# The main function is defined to contain the code that will be executed.
# The print function is used to display the string "Hello".
# The sleep function is used to pause the program for 1 second.
# The print function is used again to display the string "World!".
# The if statement checks if the script is being run directly, and if so, calls the main function to start the program.
# This script demonstrates how to use the sleep function to pause the execution of a program for a specified amount of time.
This works fine, but what if you want to do something else while waiting for that second to pass? That’s where asyncio comes in handy! Here’s the same code using async/await:
# This script uses asyncio to print "Hello" and "World!" with a 1 second delay in between.
# Import the necessary libraries
import time
import asyncio
# Define the main function with async keyword to allow for asynchronous execution
async def main():
# Print "Hello"
print("Hello")
# Use await keyword to pause execution for 1 second
await asyncio.sleep(1)
# Print "World!"
print("World!")
# Check if the script is being run directly
if __name__ == "__main__":
# Get the event loop
loop = asyncio.get_event_loop()
# Run the main function until it is complete
loop.run_until_complete(main())
Notice how we’re using the `async def` syntax to define our function as “asynchronous”, and then calling it with `loop.run_until_complete`. This tells asyncio that we want to run this code in an event loop, which allows us to handle multiple tasks simultaneously without blocking (which is what happens when you use regular synchronous code).
Example #2: Let’s say you have a function called `fetch_data` that takes some time to complete. Instead of waiting for it to finish before moving on to the next task, we can use asyncio to handle multiple tasks simultaneously! Here’s what it might look like:
# Import necessary libraries
import asyncio # Import asyncio library for asynchronous tasks
from urllib.request import urlopen # Import urlopen function from urllib.request library for making HTTP requests
# Define a function to fetch data from a given URL
async def fetch_data(url):
response = await urlopen(url) # Use await keyword to wait for the response from the URL
data = await response.read() # Use await keyword to wait for the data to be read from the response
return data # Return the data retrieved from the URL
# Check if the script is being run directly
if __name__ == "__main__":
loop = asyncio.get_event_loop() # Get the event loop for managing asynchronous tasks
tasks = [fetch_data("https://www.example.com"), fetch_data("https://www.google.com")] # Create a list of tasks to be executed asynchronously
results = [] # Create an empty list to store the results of the tasks
for task in tasks:
result = loop.run_until_complete(task) # Use the event loop to run the tasks and wait for them to complete
results.append(result) # Add the result of each task to the results list
print(results[0]) # Print the first result (from "https://www.example.com")
In this example, we’re using `asyncio.get()` to make a request and then waiting for it to finish with `await response.read()`. We can also use `loop.run_until_complete(task)` to run each task in the event loop (which allows us to handle multiple tasks simultaneously).
Asyncio is an awesome library that makes asynchronous programming much easier and more intuitive than traditional threading or multiprocessing. Give it a try and let me know what you think!