Simple Guide to the Basics of Async/Await in Python

Blog Articles
1

The asyncio is a very well known Python Module that provides support for writing asynchronous code using the async and await syntax. This is designed to handle all asynchronous I/O operations. This makes it way easier to build concurrent and highly scalable software and applications.

Understanding the async in Python

In the Python programming language, the async keyword defines the asynchronous functions or coroutines. The foundation of asyncio module relies heavily on the coroutines – which tend to be special functions which execution can be paused for a time and let a different coroutine take over the processing. When we choose to add the async keyword before a function, the regular function will transform into a coroutine such as async def fetch():.

Let me provide a code sample of the difference in the execution of synchronous and asynchronous functions.

def fetch():
    return "Hello World" 
print(fetch()) # Hello World

In the following code sample, synchronously calling the fetch() function results in the immediate return of the string Hello World.

async def fetch():
     return “Hello World”
print(fetch()) # <coroutine object fetch at 0x7fdf620994d0>

When we make the fetch() function asynchronous with the asynckeyword, calling it returns a coroutine object rather than the actual result as printed by the above program. Remember, the coroutine needs to be awaited to retrieve the value it produces.

async def fetch():
    return "Hello World"
print(await fetch()) # Hello World

Understanding the await in Python

The await is used with coroutines to pause the execution of it until the awaited asynchronous operation is complete. When we use await, the control moves from one coroutine to another. Allow me to provide a come sample.

async def fetch():
    print('Hello World')
    await asyncio.sleep(5)
    print("Hello World Again")

 In the fetch coroutine, once the Hello World is printed, the control transitions to the sleep coroutine, causing the execution to pause for 5 seconds before printing Hello World Again. The complete code sample is right below.

import asyncio
async def fetch():
    print('Hello World')
    await asyncio.sleep(5)
    print("Hello World Again")
async def main():
    await fetch()
if __name__ == "__main__":
    asyncio.run(main())

What About Error Handling?

Coroutines can handle errors using standard try-except blocks. Exceptions within coroutines can be caught and processed just like in synchronous code.

import asyncio
async def fetch_server_data():
    raise ValueError("Simulated network error")
async def fetch():
    print('Hello World')
    try:
        await fetch_server_data()
    except ValueError as e:
        print(f"Error fetching data: {e}")
async def main():
    await fetch()
if __name__ == "__main__":
    asyncio.run(main())

Then There is Timeouts and Delays

The asyncio module allows you to set timeouts for coroutines or delay their execution using functions like 'asyncio.sleep' and 'asyncio.wait_for'.

Timeouts are limits set on the duration allowed for the completion of a particular asynchronous operation or coroutine. If the operation takes longer than the specified timeout, asyncio can raise an exception, allowing the program to respond appropriately.

import asyncio
async def fetch_server_data():
    await asyncio.sleep(4)
    return "Done Processing"
async def fetch():
    try:
        await asyncio.wait_for(fetch_server_data(), timeout=2.0)
    except TimeoutError as e:
        print(f"Error fetching data: {e}")
async def main():
    await fetch()
if __name__ == "__main__":
    asyncio.run(main())

In this example, asyncio.wait_for function is used to set a timeout of 2 seconds for the fetch_server_data function to respond.  If the fetch_server_dataoperation takes longer than 2 seconds, a TimeoutError is caught, and an error message is printed.

Delays involve intentionally pausing the execution of a coroutine for a specified duration before proceeding. The asyncio.sleep function is commonly used to introduce delays within asynchronous code.

import asyncio
async def fetch()
    print("Start of operation")
    await asyncio.sleep(2)  # Pause for 2 seconds
    print("End of operation after delay")
await fetch()

In the code sample above, asyncio.sleep(2) introduces a delay of 2 seconds within the fetch() coroutine

Do you enjoy the content we provide?

We rely on the support from our awesome readers like you to keep going! If you found this article helpful for learning how to program, consider a one-time donation. Each donation helps us stay ad-free and able to offer all of these articles free for everyone.

Thank you for your support of our programming blog!

This is a companion discussion topic for the original entry at https://coderoasis.com/async-await-in-python