anext() in Python

anext() is a built-in function that retrieves the next item from an asynchronous iterator, acting as the async version of next(). It is essential when working with async iterators and generators, offering more flexibility in asynchronous workflows. Note: anext() is available starting in Python 3.10.

import asyncio

# asynchronous generator function
async def async_numbers():
    for i in range(2):
        yield i

# main function
async def main():
    agen = async_numbers()  # Create an async generator
    print(await anext(agen, 'End')) 
    print(await anext(agen, 'End'))  
    print(await anext(agen, 'End'))  

asyncio.run(main()) # calling main function

0
1
End

Explanation:

• async_numbers() iterating over the range 2, yielding values 0 and 1 sequentially, with execution paused at each yield until the next value is requested.
• main() creates an instance of the asynchronous generator agen = async_numbers() and calls anext(agen, 'End') three times, since the generator is exhausted.

anext() Syntax

anext(async_iterator, default)

Parameters:

• async_iterator(Required) : The asynchronous iterator to retrieve the next item.
• default(Optional) : default parameter is optional. If it is not provided and the iterator is exhausted, anext() raises a StopAsyncIteration

Returns:

• It returns the next item from the asynchronous iterator.
• If exhausted, returns default (if provided) or raises StopAsyncIteration if not.

anext() Examples

Example: 1: No Default Value Provided for anext()

This example demonstrates fetching values asynchronously from an asynchronous generator and handling exhaustion using StopAsyncIteration.

import asyncio

# asynchronous generator function
async def async_numbers():
    for i in range(2):
        yield i

# main function
async def main():
    agen = async_numbers()  # create an async generator
    print(await anext(agen))  
    print(await anext(agen))  
    
    # this will raise StopAsyncIteration because no default is provided
    try:
        print(await anext(agen))  # generator exhausted
    except StopAsyncIteration:
        print("Generator exhausted")

asyncio.run(main())  # calling main function

0
1
Generator exhausted

Explanation:

• async_numbers() is an asynchronous generator that yields two values, 0 and 1.
• main() creates an async generator agen, fetches values using await anext(agen), and handles exhaustion by printing "Generator exhausted" when the generator is empty.

Example: 2: Processing Queue Items

This example demonstrates processing tasks from a queue asynchronously using an asynchronous generator.

import asyncio

# asynchronous function
async def process_item(item):
    return f"Processed {item}"

# main function
async def main():
    queue = ['task1', 'task2']
    async_gen = (await process_item(item) for item in queue)
    
    print(await anext(async_gen))
    print(await anext(async_gen))

asyncio.run(main()) # calling main function

Output

Processed task1
Processed task2

Explanation:

• process_item() takes an item, simulates processing it and returns a string in the format "Processed {item}".
• main() defines a queue ['task1', 'task2'], creates an asynchronous generator async_gen that processes each item in the queue using process_item(item) and retrieves the processed results of task1 and task2 sequentially using await anext(async_gen).

Example 3: Real- Time notifications

This example demonstrates how to process real-time notifications asynchronously using an asynchronous generator.

import asyncio

# asynchronous function
async def fetch_notification(id):
    await asyncio.sleep(1)
    return f"Notification {id}"

# main function
async def main():
    notifications = (await fetch_notification(i) for i in range(2))
    print(await anext(notifications)) 
    print(await anext(notifications))

asyncio.run(main()) # calling main function

Output

Notification 0
Notification 1

Explanation:

• fetch_notification() takes an id as a parameter, waits for 1 second (simulated with await asyncio.sleep(1)), and then returns a string in the format Notification {id}.
• main() creates an asynchronous generator notifications that fetches notifications for IDs 0 and 1 using fetch_notification(i).Calling await anext(notifications) twice fetches Notification 0 and Notification 1 from the asynchronous generator.