Async and Await Syntax in Python0%

Async and Await Syntax in Python

Advanced8 min read•Updated: 2026-10-01

`async` and `await` Syntax

Formalized in PEP 492, the async and await keywords establish native asynchronous programming syntax in Python. By distinguishing coroutines from generator objects, native coroutines provide compile-time syntax validation, dedicated runtime protocols (__await__, __aiter__, __aenter__), and clear concurrency semantics.

1. Native Coroutines & The `await` Expression

Defining a function with async def creates a Native Coroutine Function. Calling this function does not execute its body; instead, it returns an unstarted Coroutine Object:

1async def fetch_user_profile(user_id: int) -> dict:
2    print(f"Fetching user #{user_id}...")
3    await asyncio.sleep(0.1)
4    return {"id": user_id, "name": "Ada Lovelace"}
5 
6# Calling the function without await:
7coro = fetch_user_profile(42)
8print("Type of coro:", type(coro))  # <class 'coroutine'>
9# If left un-awaited, Python raises:
10# RuntimeWarning: coroutine 'fetch_user_profile' was never awaited

The Three Awaitable Objects

In Python, the await expression can only be used on objects that implement the Awaitable Protocol (defining an __await__() method). The three core awaitable types are:

1
Coroutines: Native coroutines created via async def.
2
Tasks: Coroutines scheduled onto the event loop via asyncio.create_task().
3
Futures: Low-level objects representing the eventual result of an asynchronous operation (such as an I/O callback).

                    The Awaitable Protocol Hierarchy
                                    │
                 ┌──────────────────┼──────────────────┐
                 ▼                  ▼                  ▼
             Coroutine             Task              Future
         (async def body)    (Scheduled Loop)   (Low-level Result)
                 │                  │                  │
                 └──────────────────┼──────────────────┘
                                    ▼
                      Implements __await__() method

2. Asynchronous Context Managers (`async with`)

Just as synchronous code manages resources with with, asynchronous code uses async with to acquire and release network connections, transactions, and session locks non-blockingly.

An asynchronous context manager implements two dunder methods:

__aenter__(self): A coroutine that returns the acquired resource.
__aexit__(self, exc_type, exc_val, exc_tb): A coroutine that performs cleanup.

Visual Architecture & Process Flow

How data and code flow step-by-step

Flowchart

Step 1

def __init__

self, dsn: str

Step 2

None:

3. Asynchronous Iteration (`async for`)

Asynchronous iterators stream data non-blockingly (e.g. streaming chunks from an HTTP socket, WebSocket packets, or reading database query cursors).

They implement two methods:

__aiter__(self): Returns the asynchronous iterator object.
__anext__(self): A coroutine that returns the next value, or raises StopAsyncIteration when exhausted.

1import asyncio
2 
3class AsyncDataStream:
4    """Asynchronously yields simulated incoming telemetry chunks."""
5 
6    def __init__(self, total_packets: int) -> None:
7        self.total_packets = total_packets
8        self.current = 0
9 
10    def __aiter__(self) -> "AsyncDataStream":
11        return self
12 
13    async def __anext__(self) -> dict:
14        if self.current >= self.total_packets:
15            raise StopAsyncIteration  # Signals end of async stream
16 
17        self.current += 1
18        await asyncio.sleep(0.05)  # Non-blocking pause for incoming packet
19        return {"packet_index": self.current, "payload_bytes": 1024}
20 
21async def consume_stream():
22    print("--- Reading Asynchronous Data Stream ---")
23    async for packet in AsyncDataStream(total_packets=3):
24        print(f"Received: Packet #{packet['packet_index']} ({packet['payload_bytes']} bytes)")
25 
26if __name__ == "__main__":
27    asyncio.run(consume_stream())

4. Asynchronous Generators

Just as standard generators use yield, an async def function containing yield creates an Asynchronous Generator. It allows you to produce data streams lazily while using await internally:

1import asyncio
2from typing import AsyncGenerator
3 
4async def fetch_paged_records(total_pages: int) -> AsyncGenerator[str, None]:
5    """Asynchronous generator yielding paginated network responses."""
6    for page in range(1, total_pages + 1):
7        await asyncio.sleep(0.05)  # Non-blocking API network request
8        yield f"Page_{page}_Content"
9 
10async def process_pages():
11    async for page_data in fetch_paged_records(4):
12        print(f"Ingested: {page_data}")
13 
14if __name__ == "__main__":
15    asyncio.run(process_pages())

5. Architectural Summary Table

Syntax	Underlying Protocol	Core Dunder Methods
`await expr`	Awaitable Protocol	`__await__()`
`async with expr as val:`	Async Context Manager	`__aenter__()`, `__aexit__()`
`async for item in expr:`	Async Iterator	`__aiter__()`, `__anext__()`
`async def f(): yield x`	Async Generator	`__anext__()`, `asend()`, `aclose()`

⚠️ Common Advanced Mistakes & Gotchas

1. Forgetting `await` on a Coroutine

Calling an async function without await returns a coroutine object without executing it:

1# ❌ Coroutine was never awaited warning!
2fetch_data()
3 
4# ✅ CORRECT
5await fetch_data()

2. Using `await` Outside of `async def`

The await keyword is syntactically invalid outside of functions declared with async def (except in Python 3.8+ top-level REPL shells).

💻 Try It Yourself: Asynchronous Context Manager with aiofiles Simulation

Scenario

Implement a custom asynchronous context manager using __aenter__ and __aexit__ to simulate non-blocking file streaming.

Complete Solution

1import asyncio
2 
3class AsyncDatabaseSession:
4    async def __aenter__(self):
5        print("Acquiring async database connection...")
6        await asyncio.sleep(0.05)
7        return self
8 
9    async def query(self, sql):
10        await asyncio.sleep(0.05)
11        return f"Results for: {sql}"
12 
13    async def __aexit__(self, exc_type, exc_val, exc_tb):
14        print("Releasing async database connection back to pool.")
15        await asyncio.sleep(0.01)
16 
17async def main():
18    async with AsyncDatabaseSession() as db:
19        res = await db.query("SELECT * FROM users")
20        print("Query returned:", res)
21 
22asyncio.run(main())

Expected Output

1Acquiring async database connection...
2Query returned: Results for: SELECT * FROM users
3Releasing async database connection back to pool.

Interactive Quiz• Knowledge Check

Practice Quiz

1.

What occurs when an async def function is called directly without using the await keyword (e.g. result = my_coroutine())? A. The function executes immediately and returns its value. B. A coroutine object is created and returned, but its body is NOT executed yet, triggering a RuntimeWarning: coroutine was never awaited. C. A new OS thread is spawned. D. A SyntaxError is raised.

Answer: B

Explanation:Calling an async def function returns a coroutine object. Its code does not begin execution until it is explicitly awaited or scheduled as an asyncio.Task on an event loop.

2.

Which three types of objects are considered valid "Awaitables" that can follow the await keyword in Python? A. Lists, Dictionaries, and Tuples B. Native Coroutines, Tasks, and Futures C. Threads, Processes, and Sockets D. Strings, Bytes, and Numbers

Answer: B

Explanation:The Python asyncio specification defines three primary awaitable objects: Coroutines (created by async def), Tasks (created via asyncio.create_task), and Futures (low-level callback trackers).

3.

Which dunder methods must a class implement to function as an asynchronous context manager with async with? A. __enter__ and __exit__ B. __aenter__ and __aexit__ C. __open__ and __close__ D. __start__ and __stop__

Answer: B

Explanation:Asynchronous context managers implement __aenter__(self) and __aexit__(self, exc_type, exc_val, exc_tb), both of which are coroutines evaluated with await.

4.

What exception must an asynchronous iterator raise from its __anext__() method to terminate an async for loop? A. StopIteration B. StopAsyncIteration C. GeneratorExit D. EOFError

Answer: B

Explanation:While synchronous iterators raise StopIteration, asynchronous iterators must raise StopAsyncIteration to signal that no further items remain in the stream.

5.

Where is the await expression permitted to appear in Python code? A. Inside any standard Python function. B. Exclusively inside functions defined with async def (or within the interactive REPL in Python 3.8+). C. Only inside __init__ methods. D. Inside class definitions directly.

Answer: B

Explanation:Using await outside of an async def function triggers a SyntaxError: 'await' outside async function.

🚀 What's Next?

In the next lesson, we will continue your advanced Python journey with Creating and Managing Tasks (8: Asynchronous Programming (Asyncio)).

👉 Continue to Next Lesson: Creating and Managing Tasks →

Next Lesson

Creating and Managing Tasks

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Introduction to Asyncio	Creating and Managing Tasks

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

Creating and Managing Tasks

Async and Await Syntax in Python

Advanced8 min read•Updated: 2026-10-01

Study Materials Cheatsheet

`async` and `await` Syntax

1. Native Coroutines & The `await` Expression

Defining a function with async def creates a Native Coroutine Function. Calling this function does not execute its body; instead, it returns an unstarted Coroutine Object:

1async def fetch_user_profile(user_id: int) -> dict:
2    print(f"Fetching user #{user_id}...")
3    await asyncio.sleep(0.1)
4    return {"id": user_id, "name": "Ada Lovelace"}
5 
6# Calling the function without await:
7coro = fetch_user_profile(42)
8print("Type of coro:", type(coro))  # <class 'coroutine'>
9# If left un-awaited, Python raises:
10# RuntimeWarning: coroutine 'fetch_user_profile' was never awaited

The Three Awaitable Objects

In Python, the await expression can only be used on objects that implement the Awaitable Protocol (defining an __await__() method). The three core awaitable types are:

1
Coroutines: Native coroutines created via async def.
2
Tasks: Coroutines scheduled onto the event loop via asyncio.create_task().
3
Futures: Low-level objects representing the eventual result of an asynchronous operation (such as an I/O callback).

                    The Awaitable Protocol Hierarchy
                                    │
                 ┌──────────────────┼──────────────────┐
                 ▼                  ▼                  ▼
             Coroutine             Task              Future
         (async def body)    (Scheduled Loop)   (Low-level Result)
                 │                  │                  │
                 └──────────────────┼──────────────────┘
                                    ▼
                      Implements __await__() method

2. Asynchronous Context Managers (`async with`)

Just as synchronous code manages resources with with, asynchronous code uses async with to acquire and release network connections, transactions, and session locks non-blockingly.

An asynchronous context manager implements two dunder methods:

__aenter__(self): A coroutine that returns the acquired resource.
__aexit__(self, exc_type, exc_val, exc_tb): A coroutine that performs cleanup.

Visual Architecture & Process Flow

How data and code flow step-by-step

Flowchart

Step 1

def __init__

self, dsn: str

Step 2

None:

3. Asynchronous Iteration (`async for`)

Asynchronous iterators stream data non-blockingly (e.g. streaming chunks from an HTTP socket, WebSocket packets, or reading database query cursors).

They implement two methods:

__aiter__(self): Returns the asynchronous iterator object.
__anext__(self): A coroutine that returns the next value, or raises StopAsyncIteration when exhausted.

1import asyncio
2 
3class AsyncDataStream:
4    """Asynchronously yields simulated incoming telemetry chunks."""
5 
6    def __init__(self, total_packets: int) -> None:
7        self.total_packets = total_packets
8        self.current = 0
9 
10    def __aiter__(self) -> "AsyncDataStream":
11        return self
12 
13    async def __anext__(self) -> dict:
14        if self.current >= self.total_packets:
15            raise StopAsyncIteration  # Signals end of async stream
16 
17        self.current += 1
18        await asyncio.sleep(0.05)  # Non-blocking pause for incoming packet
19        return {"packet_index": self.current, "payload_bytes": 1024}
20 
21async def consume_stream():
22    print("--- Reading Asynchronous Data Stream ---")
23    async for packet in AsyncDataStream(total_packets=3):
24        print(f"Received: Packet #{packet['packet_index']} ({packet['payload_bytes']} bytes)")
25 
26if __name__ == "__main__":
27    asyncio.run(consume_stream())

4. Asynchronous Generators

Just as standard generators use yield, an async def function containing yield creates an Asynchronous Generator. It allows you to produce data streams lazily while using await internally:

1import asyncio
2from typing import AsyncGenerator
3 
4async def fetch_paged_records(total_pages: int) -> AsyncGenerator[str, None]:
5    """Asynchronous generator yielding paginated network responses."""
6    for page in range(1, total_pages + 1):
7        await asyncio.sleep(0.05)  # Non-blocking API network request
8        yield f"Page_{page}_Content"
9 
10async def process_pages():
11    async for page_data in fetch_paged_records(4):
12        print(f"Ingested: {page_data}")
13 
14if __name__ == "__main__":
15    asyncio.run(process_pages())

5. Architectural Summary Table

Syntax	Underlying Protocol	Core Dunder Methods
`await expr`	Awaitable Protocol	`__await__()`
`async with expr as val:`	Async Context Manager	`__aenter__()`, `__aexit__()`
`async for item in expr:`	Async Iterator	`__aiter__()`, `__anext__()`
`async def f(): yield x`	Async Generator	`__anext__()`, `asend()`, `aclose()`

⚠️ Common Advanced Mistakes & Gotchas

1. Forgetting `await` on a Coroutine

Calling an async function without await returns a coroutine object without executing it:

1# ❌ Coroutine was never awaited warning!
2fetch_data()
3 
4# ✅ CORRECT
5await fetch_data()

2. Using `await` Outside of `async def`

The await keyword is syntactically invalid outside of functions declared with async def (except in Python 3.8+ top-level REPL shells).

💻 Try It Yourself: Asynchronous Context Manager with aiofiles Simulation

Scenario

Implement a custom asynchronous context manager using __aenter__ and __aexit__ to simulate non-blocking file streaming.

Complete Solution

1import asyncio
2 
3class AsyncDatabaseSession:
4    async def __aenter__(self):
5        print("Acquiring async database connection...")
6        await asyncio.sleep(0.05)
7        return self
8 
9    async def query(self, sql):
10        await asyncio.sleep(0.05)
11        return f"Results for: {sql}"
12 
13    async def __aexit__(self, exc_type, exc_val, exc_tb):
14        print("Releasing async database connection back to pool.")
15        await asyncio.sleep(0.01)
16 
17async def main():
18    async with AsyncDatabaseSession() as db:
19        res = await db.query("SELECT * FROM users")
20        print("Query returned:", res)
21 
22asyncio.run(main())

Expected Output

1Acquiring async database connection...
2Query returned: Results for: SELECT * FROM users
3Releasing async database connection back to pool.

Interactive Quiz• Knowledge Check

Practice Quiz

1.

Answer: B

Explanation:Calling an async def function returns a coroutine object. Its code does not begin execution until it is explicitly awaited or scheduled as an asyncio.Task on an event loop.

2.

Answer: B

3.

Answer: B

Explanation:Asynchronous context managers implement __aenter__(self) and __aexit__(self, exc_type, exc_val, exc_tb), both of which are coroutines evaluated with await.

4.

What exception must an asynchronous iterator raise from its __anext__() method to terminate an async for loop? A. StopIteration B. StopAsyncIteration C. GeneratorExit D. EOFError

Answer: B

Explanation:While synchronous iterators raise StopIteration, asynchronous iterators must raise StopAsyncIteration to signal that no further items remain in the stream.

5.

Answer: B

Explanation:Using await outside of an async def function triggers a SyntaxError: 'await' outside async function.

🚀 What's Next?

In the next lesson, we will continue your advanced Python journey with Creating and Managing Tasks (8: Asynchronous Programming (Asyncio)).

👉 Continue to Next Lesson: Creating and Managing Tasks →

Next Lesson

Creating and Managing Tasks

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Introduction to Asyncio	Creating and Managing Tasks

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

Previous Next

async and await Syntax

1. Native Coroutines & The await Expression

The Three Awaitable Objects

2. Asynchronous Context Managers (async with)

Visual Architecture & Process Flow

3. Asynchronous Iteration (async for)

4. Asynchronous Generators

5. Architectural Summary Table

⚠️ Common Advanced Mistakes & Gotchas

1. Forgetting await on a Coroutine

2. Using await Outside of async def

💻 Try It Yourself: Asynchronous Context Manager with aiofiles Simulation

Scenario

Complete Solution

Expected Output

Practice Quiz

1.

2.

3.

4.

5.

🚀 What's Next?

Creating and Managing Tasks

Related Lessons

Practice Quiz

Loading Page Content...

async and await Syntax

1. Native Coroutines & The await Expression

The Three Awaitable Objects

2. Asynchronous Context Managers (async with)

Visual Architecture & Process Flow

3. Asynchronous Iteration (async for)

4. Asynchronous Generators

5. Architectural Summary Table

⚠️ Common Advanced Mistakes & Gotchas

1. Forgetting await on a Coroutine

2. Using await Outside of async def

💻 Try It Yourself: Asynchronous Context Manager with aiofiles Simulation

Scenario

Complete Solution

Expected Output

Practice Quiz

1.

2.

3.

4.

5.

🚀 What's Next?

Creating and Managing Tasks

Related Lessons

Practice Quiz

`async` and `await` Syntax

1. Native Coroutines & The `await` Expression

2. Asynchronous Context Managers (`async with`)

3. Asynchronous Iteration (`async for`)

1. Forgetting `await` on a Coroutine

2. Using `await` Outside of `async def`

`async` and `await` Syntax

1. Native Coroutines & The `await` Expression

2. Asynchronous Context Managers (`async with`)

3. Asynchronous Iteration (`async for`)

1. Forgetting `await` on a Coroutine

2. Using `await` Outside of `async def`