Learn Python's AsyncIO in 15 minutes

Transcribed Jun 16, 2026 Watch on YouTube ↗

Intermediate 10 min read For: Python developers with a basic understanding of functions and imports who want to learn asynchronous programming for I/O-bound tasks.

60.8K

Views

1.6K

Likes

44

Comments

43

Dislikes

2.6%

📈 Moderate

AI Summary

This tutorial introduces Python's asyncio library for asynchronous programming, beginning with how to define async functions and use the `await` keyword to simulate API calls with delays. It then demonstrates running multiple tasks concurrently using `asyncio.gather`, and explores advanced task management including cancellation, checking completion, and setting timeouts.

Chapters

1 Fundamentals of async/await 0:00 2 Concurrent I/O with gather 2:51 3 Managing Tasks with asyncio 5:37 4 Timeout and Cancellation Patterns 8:00

[0:00]

Setting up async functions

Import asyncio; define async functions with `async def`. Within a function, use `await asyncio.sleep(delay)` to pause without blocking the event loop, then `return` the result.

[1:06]

Awaiting a coroutine

When calling an async function, prefix it with `await` to ensure the program waits for that function's result before proceeding. This makes the flow synchronous within the coroutine.

[2:08]

Concurrent execution with gather

Use `await asyncio.gather(coro1, coro2, ...)` to run multiple coroutines concurrently. They will be executed in parallel (single-threaded concurrency), and the program will wait for all to complete.

[3:56]

Running many tasks concurrently

Create a list of coroutine calls (e.g., `[kill_time(i) for i in range(1, 1001)]`). Pass them to `gather` using `*list` to unpack the list. The program runs 1000 tasks simultaneously, each sleeping for 1 second, and finishes in about 1 second.

[5:37]

Task objects

Wrap a coroutine with `asyncio.create_task(coro)` to turn it into a Task. The task starts immediately upon creation. You can then await the task, check if it is done (`task.done()`), or cancel it (`task.cancel()`).

[6:24]

Handling cancellation and timeouts

Use `try/except asyncio.CancelledError` to handle cancellations. Use `asyncio.wait_for(task, timeout)` to raise `asyncio.TimeoutError` if the task takes too long. Check `task.done()` before accessing `task.result()` to avoid errors.

Asyncio provides the tools to write concurrent Python code by using `async`/`await` syntax, turning sequential I/O-bound operations into non-blocking concurrent tasks. Mastering functions like `gather`, `create_task`, and `wait_for` is essential for building efficient, responsive applications.

Mentioned in this Video

asyncio documentation

link

Tutorial Checklist

1 0:14 Import asyncio and define an async function `async def fetch_data() -> str`. Inside, print 'fetching data', await `asyncio.sleep(2.5)`, print 'data fetched', and return the data string.

2 1:51 Create another async function `async def send_data(to: str)`. Print 'sending data to {to}', await `asyncio.sleep(2)`, then print 'data sent to {to}'.

3 2:51 Define the main async function: await `api.fetch_data()`, store the result, then send the data to a single user by awaiting `send_data('mario')`. Run with `asyncio.run(main())`.

4 3:15 To send to multiple users concurrently, replace the sequential awaits with `await asyncio.gather(send_data('mario'), send_data('luigi'))`.

5 4:28 How to run 1000 tasks: define `async def kill_time(n)`, print the number, wait 1 second, print 'finished'. In main, create a list `tasks = [kill_time(i) for i in range(1, 1001)]` and await `asyncio.gather(*tasks)`.

6 5:37 Create a task: `task = asyncio.create_task(api.fetch_data())`. Use `try/except` to catch `asyncio.CancelledError` and `asyncio.TimeoutError`. Call `task.cancel()` to cancel before awaiting the task.

7 6:06 Check task completeness: use `if task.done(): print(task.result())`. Add a small sleep (e.g., 0.5 s) after `task.cancel()` to let the cancellation register.

8 6:17 Set a timeout: wrap the task with `await asyncio.wait_for(task, timeout=2)`. If the task (which takes 2.5 s) exceeds the timeout, it raises `asyncio.TimeoutError` which you can handle in the except block.

Study Flashcards (10)

What keyword is used to define an asynchronous function in Python?

easy Click to reveal answer

async