Python async (original) (raw)

Last Updated : 10 Mar, 2025

**async keyword in Python is used to define asynchronous functions, which allow tasks to run without blocking the execution of other code. It is commonly used for handling tasks like network requests, database operations or file I/O, where waiting for one task to finish would normally slow down the entire program. Async relies on await because an async function does not execute asynchronously on its own, it needs await to actually pause and resume tasks.

To use async in our code, we need to first import the asyncio library, to know about it in detail, refer to asyncio in Python. Let's consider an example.

Python `

import asyncio

async def func(): print("Hello!") await asyncio.sleep(2) # Pause for 2 second without blocking print("Geeks for Geeks") #

asyncio.run(func())

`

Output

Hello! Geeks for Geeks

**Explanation:

• ****"async"** keyword before "**def" keyword defines the function func as an asynchronous function.
• "**await asyncio.sleep(2)" makes it wait for 2 second before continuing.
• that's why when the function is called using "**asyncio.run(gree())", the second print statement gets executed after a delay of 2 seconds.

**Syntax:

async def function_name():
await some_async_function()

• **async def: defines an asynchronous function.
• **await: pauses execution until the awaited function completes.

Let's see some of the use cases of the async with examples.

Running Multiple Tasks Simultaneously

With the help of **async, multiple tasks can run without waiting for one to finish before starting another.

Python `

import asyncio

async def task1(): print("Task 1 started") await asyncio.sleep(3) print("Task 1 finished")

async def task2(): print("Task 2 started") await asyncio.sleep(1) print("Task 2 finished")

async def main(): await asyncio.gather(task1(), task2()) # Runs both tasks together

asyncio.run(main())

`

Output

Task 1 started Task 2 started Task 2 finished Task 1 finished

**Explanation:

• in this code, **task1() and **task2() run at the same time becasue they are defined as async functions.
• **task2() completes first because it waits for only 1 second, while task1() waits for 3 seconds.

Using Async with HTTP Requests

It is a very common practice to use async keyword with HTTP requests, if we fetch data from multiple URLs using a synchronous approach, each request blocks the execution until it completes. However, with async, we can send multiple requests simultaneously, making the program much faster. Here's an example:

Python `

import aiohttp import asyncio

async def func(): async with aiohttp.ClientSession() as session: async with session.get("https://example.com") as res: data = await res.text() print(data[:100]) # Prints first 100 characters

asyncio.run(func())

`

Output

• **aiohttp library is used for making async HTTP requests.
• **aiohttp.ClientSession(), creates HTTP session and making an asynchronous get request using session.get().
• **await keyword ensures that the request completes before proceeding to the next step.
• **data[:100] ensure that only first 100 characters are printed.

**Note: Ensure that "aiohttp" library is installed on your system before running the code. If it's mot installed, you can add it by running "pip install aiohttp" command in the terminal

Using Async with File I/O

Python by default handles files one at a time, making the program wait until the task is done. But async can also be used for file operations. While writing and reading files, we can simulate async behavior using **asyncio.sleep() to represent delays, similar to real-world scenarios where I/O operations take time. Here's an example:

Python `

import asyncio import aiofiles import asyncio

async def write(): async with aiofiles.open(r"paste_your_file_path_here\file.txt", "w") as f: await f.write("Hello from Geeks for Geeks!")

async def read(): async with aiofiles.open(r"paste_your_file_path_here\file.txt", "r") as f: print(await f.read())

asyncio.run(write()) asyncio.run(read())

`

Output

Hello from Geeks for Geeks!

**Explanation:

• **write_file() writes data to "**file.txt" if it already exists in the specified path. If the file doesn't exist, it automatically creates a new "**file.txt" and writes data to it.
• **read_file() opens "file.txt" in read mode and prints its content asynchronously. If the file doesn’t exist, it will raise a **FileNotFoundError.
• **asyncio.run(write()) runs first, making sure the file is created and written. Then, **asyncio.run(read()) runs, reading and printing the content.

To learn about file-handling in Python in detail, refer to- File Handling In Python