What is a coroutine in Python?

A coroutine is a generalized subroutine that can suspend and resume its execution while preserving its state. Unlike regular functions, which run from start to finish in a single call, coroutines can "yield" control to another coroutine or the main event loop and then "accept" it back from the same point where they paused.

In Python, coroutines are implemented using the keywords async def and await.

Main characteristics:

• Suspension and resumption: They can suspend their execution (await) and be resumed later.
• State preservation: After suspension, they save the state of their local variables and the execution pointer.
• Explicit control: Control transfer is explicit using await.
• Non-blocking I/O: Often used for performing non-blocking input/output operations (e.g., network requests) without using threads or processes.

Syntax:

// Defining an asynchronous function (coroutine)
async def my_coroutine():
    print("Start of coroutine")
    await some_async_operation() // Suspend until the async operation completes
    print("Continuation after waiting")

// Calling the coroutine
import asyncio

async def main():
    await my_coroutine() // Execute the coroutine

# Running the main event loop
asyncio.run(main())

Advantages:

• Performance: More efficient use of system resources compared to threads for waiting tasks (e.g., I/O bound).
• Readability: The async/await syntax makes asynchronous code more similar to synchronous code, improving readability.
• Concurrency: Easily implement concurrent task execution without the complexities of thread management.

Coroutines are a fundamental part of asynchronous programming in Python, used in frameworks like asyncio, aiohttp, and FastAPI.