RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/python/python-async/ below:

Python async - GeeksforGeeks

Python async

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

<!doctype html>
<html>
<head>
    <title>Example Domain</title>
    <meta charset="utf-8" />
    <m

Explanation: In this code we have defined an asynchronous function that performs an HTTP request using the async keyword, the breakdown of code is such:

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4