Summary  
This chapter explains the differences between synchronous functions (which run start-to-finish and return one value), generators (which yield values lazily and can pause/resume), and coroutines (defined with async/await for non-blocking, concurrent execution).

General domain of usage  
Asynchronous I/O operations

Watch this video for a clear overview of the differences between regular functions, generators, and coroutines in Python. You'll see practical code examples and learn when to use each type of callable for synchronous logic, lazy value production, and asynchronous I/O with asyncio.

- 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.

Python has three types of callable objects that can produce values and be paused mid-execution. Understanding their differences prevents confusion when reading async code and helps you choose the right tool.

## Regular Functions

A regular function runs from start to finish in one go. It blocks the caller until it returns.


# Returning a post title synchronously
def get_post_title(post_id):
    return f"Post number {post_id}"

title = get_post_title(1)
print(title)  # Post number 1

- Called with `()`;
- Runs completely before returning control;
- Cannot be paused or resumed.

## Generators

A generator function uses `yield` to produce values one at a time. It pauses at each `yield` and resumes when `next()` is called.


# Generating post IDs one at a time
def post_id_generator(count):
    for post_id in range(1, count + 1):
        yield post_id  # Pausing here, resuming on next()

generator = post_id_generator(3)

print(next(generator))  # 1
print(next(generator))  # 2
print(next(generator))  # 3

Generators are about **lazy value production** – they don't compute all values upfront.

## Coroutines

A coroutine is defined with `async def` and uses `await` to pause execution. Unlike generators, coroutines pause to **wait for I/O** – not to produce values.

import asyncio
import httpx
import nest_asyncio

nest_asyncio.apply()

# Fetching a post and pausing while waiting for the response
async def fetch_post(post_id):
    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"https://jsonplaceholder.typicode.com/posts/{post_id}"
        )
        data = response.json()
        return data["title"]

asyncio.run(fetch_post(1))

Coroutines are about **cooperative scheduling** – yielding control to the event loop while waiting.

## Side-by-Side Comparison


## The Key Distinction

Generators and coroutines both pause execution, but for different reasons:

- A generator pauses to **hand a value to the caller**;
- A coroutine pauses to **wait for an external operation** and let other coroutines run.

Internally, coroutines are built on top of Python's generator protocol – which is why the syntax looks similar. But at the usage level, they serve entirely different purposes.


What is the key difference between a generator and a 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.

Coroutines vs Functions vs Generators

Regular Functions

Generators

Coroutines

Side-by-Side Comparison

The Key Distinction