5. Advanced Topics (Optional for Beginners)

async def might_fail():
    raise ValueError("Something went wrong")
async def main():
    try:
        await might_fail()
    except ValueError as e:
        print(f"Caught error: {e}")
asyncio.run(main())

This chunk covers how to handle exceptions in asynchronous functions. In the first part of the code, we define a coroutine might_fail that intentionally raises a ValueError. In the main coroutine, we use a try block to call this function. If a ValueError is raised, the except block catches the error and prints a message to the console, indicating that an error has occurred. This is crucial in async code because if an exception is not handled, it may lead to unanticipated application behavior.

Consider a scenario where you are making a reservation online. If the system encounters an error due to unavailability of seats, you need to gracefully inform the user rather than crashing the whole booking system. This code snippet demonstrates how you can catch such errors and respond appropriately, just like notifying someone if their intended reservation cannot be processed.

sem = asyncio.Semaphore(3)
async def limited_task(n):
    async with sem:
        print(f"Task {n} started")
        await asyncio.sleep(2)
        print(f"Task {n} finished")

This chunk introduces asyncio.Semaphore, which is a way to manage the number of concurrent operations running at any given time. Here, we create a semaphore object that allows up to 3 tasks to run simultaneously. The limited_task coroutine uses async with to acquire the semaphore before executing its task and will wait if more than 3 tasks are trying to run at the same time, making it useful for controlling resource usage.

Think of a restaurant with only 3 tables available. If more than 3 groups arrive, they must wait for a table to become free. The semaphore acts like the restaurant's limit on available tables, allowing only a certain number of tasks (or diners) to proceed while others wait until a resource becomes available.

class AsyncContext:
    async def __aenter__(self):
        print("Entering context")
        return self
    async def __aexit__(self, exc_type, exc, tb):
        print("Exiting context")
async def main():
    async with AsyncContext():
        print("Inside block")
asyncio.run(main())

Here we learn about asynchronous context managers. The AsyncContext class implements __aenter__ and __aexit__, allowing for setup and teardown actions similar to traditional context managers but in an asynchronous way. When an async with statement is executed, it triggers __aenter__, and upon exiting the block, __aexit__ is called. This helps manage resources such as network connections or files efficiently without blocking the execution of other tasks.

Consider your living space as a context manager. When you enter a room (like a context), you might need to turn the light on (setup), and when you leave, you turn off the light (teardown). In async programming, this concept helps to manage entry and exit from resources without disrupting the flow of your program.

• Use asyncio.run() to start the main coroutine.
• Avoid mixing blocking code (e.g., time.sleep, requests) in async code.
• Use aiohttp instead of requests for HTTP requests in async code.
• Don’t forget to await all coroutines; failing to do so will silently skip execution.

This chunk summarizes key practices for writing efficient asynchronous code. The first point emphasizes using asyncio.run() for executing a coroutine; it sets up an event loop and runs the provided coroutine until it completes. The second point warns against using blocking code, which can hinder the efficiency of an async application. The recommendation to use aiohttp instead of requests is to ensure that HTTP calls are non-blocking. Lastly, it highlights the importance of awaiting all coroutines to ensure they execute as intended.

Think of these best practices as rules in a well-organized library. Just as you’d want to ensure readers respect library hours (using asyncio.run()), avoid noisy behavior (blocking code), and make sure every book return is recorded (awaiting coroutines), these practices ensure that your asynchronous code runs smoothly and efficiently.

Asynchronous programming with asyncio is a powerful and efficient way to handle large numbers of concurrent I/O operations using a single thread. ✅ In Summary:

• Use async/await to define and execute non-blocking coroutines.
• Run concurrent operations using create_task() or gather().
• Ideal for tasks like network communication, web scraping, and database calls.
• Requires careful attention to coroutine structure and event loop management.

The final chunk underscores the significance of asynchronous programming using asyncio. It points out how this model allows for high-performance applications capable of handling numerous I/O-bound tasks efficiently within a single thread. Key points in the summary highlight using the async and await keywords, running concurrent operations, and recognizing the best scenarios for asyncio, such as network communication and web scraping.

Imagine a busy chef in a restaurant managing various orders simultaneously—the chef does not wait for one dish to finish before starting another. Rather, they prepare multiple dishes at once, checking back on each one as needed. This is akin to how asyncio manages tasks without waiting for each one to finish before beginning another, making the process far more efficient.

--