Summary  
This chapter explains how to schedule coroutines as tasks with asyncio.create_task for concurrent execution, monitor their lifecycle states, and retrieve return values once completed.

General domain of usage  
Concurrent HTTP requests (network I/O)

Watch this video to see how `asyncio.create_task()` enables concurrency in Python. You'll compare awaiting coroutines sequentially with running them as tasks, learn how to check task states, and see how to retrieve return values from tasks. Clear code examples will help you understand when and why to use `create_task()` for efficient asynchronous programming.

- video metadata (use this info when making a video) --
Cut all examples of code to a minimum. Show only the essential code. Show code no longer than 10 lines. Remove all possible pieces to demonstrate some code feature. You may show not full code that will not start, but still demonstrates some feature theoritacally.
If code is longer than 8 lines, move code output  blocks to second column.
No diagrams

Awaiting a coroutine directly runs it – but sequentially. To run coroutines **concurrently**, you need to schedule them as **tasks**. That's what `asyncio.create_task()` is for.

## Coroutines vs Tasks

When you `await` a coroutine directly, the current coroutine pauses and waits for it to finish before continuing. No concurrency happens.



import asyncio
import nest_asyncio

nest_asyncio.apply()

async def fetch(source):
    print(f"Starting {source}")
    await asyncio.sleep(1)  # Simulating I/O delay
    print(f"Done {source}")

async def main():
    # Sequential
    await fetch("source_A")
    await fetch("source_B")

asyncio.run(main())

Wrapping a coroutine in `asyncio.create_task()` schedules it to run on the event loop **immediately** – without waiting for the current coroutine to finish.

import asyncio
import nest_asyncio

nest_asyncio.apply()

async def fetch(source):
    print(f"Starting {source}")
    await asyncio.sleep(1)  # Simulating I/O delay
    print(f"Done {source}")

async def main():
    # Concurrent
    task_a = asyncio.create_task(fetch("source_A"))
    task_b = asyncio.create_task(fetch("source_B"))

    await task_a
    await task_b

asyncio.run(main())

Both tasks start almost simultaneously. Awaiting them at the end just waits for their completion.

## Retrieving Return Values

Tasks capture the return value of the coroutine. You retrieve it by awaiting the task:

import asyncio
import httpx
import nest_asyncio

nest_asyncio.apply()

# Fetching a single post title
async def fetch_title(client, post_id):
    url = f"https://jsonplaceholder.typicode.com/posts/{post_id}"
    response = await client.get(url)
    data = response.json()
    return data["title"]

async def main():
    async with httpx.AsyncClient() as client:
        task_1 = asyncio.create_task(fetch_title(client, 1))
        task_2 = asyncio.create_task(fetch_title(client, 2))

        title_1 = await task_1
        title_2 = await task_2

        print(f"Post 1: {title_1}")
        print(f"Post 2: {title_2}")

asyncio.run(main())

## Task States

A task moves through three states after creation:

- **Pending**: scheduled but not yet complete;
- **Done**: finished successfully;
- **Cancelled**: stopped before completing.

You can check a task's state with `task.done()` and `task.cancelled()`.

import asyncio
import nest_asyncio

nest_asyncio.apply()

async def work():
    await asyncio.sleep(1)
    return "result"

async def main():
    task = asyncio.create_task(work())
    print(task.done())  # False – still pending

    result = await task
    print(task.done())  # True – completed
    print(result)       # result

asyncio.run(main())

What is the difference between `await coroutine()` and `asyncio.create_task(coroutine())`?

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.

Creating Tasks with asyncio.create_task()

Coroutines vs Tasks

Retrieving Return Values

Task States