Syntax Overview

result = [await process(item) async for item in async_generator()]
result = {item.id: item async for item in async_source()}
result = (await transform(x) async for x in async_stream())

These work just like normal comprehensions, except they use async for and can contain await.

Basic Example

import asyncio

async def numbers():
    for i in range(5):
        await asyncio.sleep(0.1)
        yield i

async def main():
    squares = [i * i async for i in numbers()]
    print(squares)

asyncio.run(main())

Output:

[0, 1, 4, 9, 16]

Real Use Case: Processing Large API Data

Imagine you are collecting thousands of records from a paginated API. Instead of fetching everything sequentially, you can stream data asynchronously
and build your dataset on the fly with async comprehensions.

import asyncio
import aiohttp

API_URL = "https://jsonplaceholder.typicode.com/posts"

async def fetch_posts():
    async with aiohttp.ClientSession() as session:
        async with session.get(API_URL) as resp:
            data = await resp.json()
            for post in data:
                yield post

async def main():
    # Collect titles asynchronously
    titles = [post["title"] async for post in fetch_posts()]
    print(f"Collected {len(titles)} titles")

asyncio.run(main())

Sample Output:

Collected 100 titles

Instead of loading everything into memory at once, the data is yielded and processed piece by piece.

Filtering Data with Async Comprehensions

You can add conditions in async comprehensions, just like in normal comprehensions.

async def main():
    posts_with_python = [
        post async for post in fetch_posts() if "python" in post["title"].lower()
    ]
    print(f"Found {len(posts_with_python)} posts mentioning Python")

asyncio.run(main())

Real Use Case: Large File Processing

Suppose you have a large log file (gigabytes in size). Reading it synchronously blocks the program, but using async streams you can process lines on the fly with async comprehensions.

import aiofiles

async def read_large_file(filename):
    async with aiofiles.open(filename, "r") as f:
        async for line in f:
            yield line.strip()

async def main():
    error_lines = [
        line async for line in read_large_file("server.log") if "ERROR" in line
    ]
    print(f"Found {len(error_lines)} error lines")

# asyncio.run(main())

This way, you don’t need to load the entire file into memory.

Performance Benefits

• Memory efficiency — process data as it streams.
• Cleaner code — avoids explicit loops and appending.
• Concurrency — multiple async tasks can run while waiting for I/O.

Best Practices

• Use async comprehensions for I/O-bound tasks, not CPU-bound tasks.
• Combine them with asyncio.gather when processing multiple streams.
• Always keep memory usage in mind with large datasets.

Conclusion

Asynchronous comprehensions (PEP 530) extend the expressive power of Python comprehensions into the world of async/await. They make it simple to process large or streaming datasets efficiently, such as API results, file lines, or database rows.

By combining async generators and comprehensions, Python developers can write concise, high-performance, and memory-efficient asynchronous programs.