Summary  
This chapter introduces the async and await keywords in Python for defining coroutine functions and suspending their execution to enable non-blocking asynchronous programming via an event loop.

General domain of usage  
Asynchronous HTTP requests

Watch this video for a clear overview of the `async` and `await` keywords in Python's asyncio. You'll see how they work together to enable asynchronous programming, learn when to use each keyword, and understand their role in building non-blocking, concurrent code. This visual guide will help you confidently start using asyncio's core features.

Two keywords power everything in asyncio: `async` and `await`. Understanding exactly what each one does – and when to use it – is the foundation for writing correct async code.

## `async def` – Defining a Coroutine

Adding `async` before `def` turns a regular function into a **coroutine function**. Calling it does not execute the body – it returns a coroutine object that the event loop can schedule.


import asyncio
import nest_asyncio

nest_asyncio.apply()

# Defining a coroutine function
async def greet(name):
    print(f"Hello, {name}!")

# Calling it returns a coroutine object, not the result
result = greet("Alice")
print(type(result))  # <class 'coroutine'>

# Running the coroutine properly
asyncio.run(greet("Alice"))

A coroutine only runs when it is either awaited or passed to `asyncio.run()`.

## `await` – Suspending Execution

`await` can only be used inside an `async def` function. It does two things:

- Suspends the current coroutine until the awaited operation completes;
- Hands control back to the event loop so other tasks can run.


import asyncio
import httpx
import nest_asyncio

nest_asyncio.apply()

# Fetching a post title using await
async def fetch_post_title(post_id):
    url = f"https://jsonplaceholder.typicode.com/posts/{post_id}"
    async with httpx.AsyncClient() as client:
        response = await client.get(url)  # Suspending here
        data = response.json()
        print(f"Post {post_id}: {data['title']}")

asyncio.run(fetch_post_title(1))

The `await client.get(url)` line suspends `fetch_post_title` while the HTTP request is in flight. The event loop is free to run other coroutines during that time.

## What You Can `await`

Not everything can be awaited. The `await` keyword only works with **awaitables** – objects that implement the `__await__` method:

- Coroutines (functions defined with `async def`);
- `asyncio.Task` objects;
- `asyncio.Future` objects;
- Objects from libraries built for asyncio (like `httpx`, `aiofiles`).

import asyncio
import nest_asyncio

nest_asyncio.apply()

# Awaiting another coroutine from within a coroutine
async def fetch_data():
    await asyncio.sleep(1)  # Awaiting a built-in asyncio awaitable
    return "data ready"

async def process():
    result = await fetch_data()  # Awaiting a coroutine
    print(result)

asyncio.run(process())

import asyncio

# Wrong: calling an async function without await
async def main():
    result = asyncio.sleep(1)  # Returning a coroutine object – never runs
    print(result)  # <coroutine object sleep at 0x...>

# Correct: awaiting the coroutine
async def main():
    result = await asyncio.sleep(1)
    print("Done")

If you forget `await`, the coroutine object is created but never executed. Python will warn you with `RuntimeWarning: coroutine was never awaited`.

What does calling an `async def` function without `await` return?

Master the skills needed to build efficient, concurrent Python applications using asyncio – from coroutines and event loop fundamentals through tasks, synchronization primitives, and real-world debugging techniques.

Gain a solid understanding of asynchronous programming concepts and the core mechanisms behind Python's asyncio library.

Dive into asyncio's task scheduling mechanisms and learn how to run multiple coroutines concurrently.

Get hands-on experience with HTTP clients, synchronization primitives, and queue-based pipelines using asyncio.

Explore advanced asyncio features for controlling task groups, running blocking code, and debugging asynchronous applications.

async and await Keywords

`async def` – Defining a Coroutine

`await` – Suspending Execution

What You Can `await`

Common Mistakes

async and await Keywords

async def – Defining a Coroutine

await – Suspending Execution

What You Can await

Common Mistakes

`async def` – Defining a Coroutine

`await` – Suspending Execution

What You Can `await`