9.1 Synchronous vs Asynchronous

• Blocking vs non-blocking operations - what makes code wait?
• When async makes sense: I/O-bound vs CPU-bound tasks
• The problem async solves: waiting efficiently instead of idling
• Real-world analogy: Coffee shop order processing
• Understanding throughput vs latency trade-offs

9.2 Concurrency Models

• Threading: Parallel execution with shared memory (GIL limitations)
• Multiprocessing: True parallelism with separate memory spaces
• Async: Cooperative multitasking on a single thread
• The Global Interpreter Lock (GIL) - why it matters for Python
• Choosing the right concurrency model for your use case
• Combining approaches: when to use threads, processes, and async together

9.3 Event Loop Fundamentals

• What is the event loop and how does it work?
• How async/await works under the hood with coroutines
• Cooperative multitasking: yielding control voluntarily
• Understanding the execution model: single-threaded concurrency
• Event loop scheduling and task prioritization
• Common misconceptions about async Python

10.1 Core Syntax

• async def functions - defining coroutines
• await keyword - pausing execution to wait for results
• Running async functions with asyncio.run()
• Understanding coroutine objects and their lifecycle
• Syntax rules: when you can and cannot use await

import asyncioasync def greet(name):
# await only works inside async functions
await asyncio.sleep(1) # Non-blocking sleep
return f"Hello, {name}!"# Run the async function
result = asyncio.run(greet("Python"))
print(result) # Output: Hello, Python!

10.2 Creating Coroutines

• Writing your first async function from scratch
• asyncio.sleep() vs time.sleep() - the critical difference
• Common mistakes: forgetting await, using blocking code
• Debugging async functions: tools and techniques
• Coroutine states: created, running, suspended, completed

10.3 Awaitable Objects

• Understanding Coroutines, Tasks, and Futures
• When to await and when not to await
• Converting between coroutines and tasks
• The awaitable protocol in Python
• Creating custom awaitable objects

11.1 Task Creation and Execution

• asyncio.create_task() - scheduling coroutines for execution
• Running multiple tasks concurrently without waiting
• asyncio.gather() - collecting results from multiple tasks
• asyncio.wait() - advanced task coordination
• Differences between gather() and wait()
• Task cancellation and cleanup

async def main():
# Create tasks (start running immediately)
task1 = asyncio.create_task(fetch_data("api1"))
task2 = asyncio.create_task(fetch_data("api2"))
task3 = asyncio.create_task(fetch_data("api3"))

# Wait for all tasks to complete
results = await asyncio.gather(task1, task2, task3)
return results

11.2 Task Coordination

• Waiting for first completion: asyncio.wait_for()
• Setting timeouts to prevent hanging operations
• asyncio.as_completed() - processing results as they arrive
• Cancelling tasks gracefully with task.cancel()
• Handling CancelledError exceptions
• Task groups and structured concurrency (Python 3.11+)

11.3 Error Handling in Async Code

• Try/except blocks in async functions - same as sync but with await
• Handling exceptions from multiple concurrent tasks
• return_exceptions=True in gather()
• Graceful shutdown patterns and cleanup
• Timeout handling with asyncio.wait_for()
• Best practices for robust async error handling

12.1 Async Context Managers

• async with statement for resource management
• Implementing __aenter__ and __aexit__ methods
• Managing async resources: database connections, file handles, HTTP sessions
• Proper cleanup in async context managers
• Real examples: aiohttp.ClientSession, asyncpg.connect()

class AsyncResource:
async def __aenter__(self):
# Acquire resource asynchronously
await self.connect()
return self

async def __aexit__(self, exc_type, exc_val, exc_tb):
# Release resource asynchronously
await self.disconnect()async with AsyncResource() as resource:
await resource.do_something()

12.2 Async Iterators and Generators

• async for loops for asynchronous iteration
• Implementing __aiter__ and __anext__ methods
• async def generators with yield
• Streaming data processing with async generators
• Use cases: paginated API results, database cursors, file streaming
• Combining async iteration with task management

12.3 Synchronization Primitives

• asyncio.Lock - mutual exclusion for async code
• asyncio.Event - signaling between tasks
• asyncio.Semaphore - limiting concurrent operations
• Preventing race conditions in async code
• Rate limiting with semaphores (max N concurrent requests)
• Queue-based task distribution: asyncio.Queue

# Rate limiting with Semaphore
semaphore = asyncio.Semaphore(5) # Max 5 concurrentasync def limited_fetch(url):
async with semaphore:
return await fetch(url)

13.1 Async HTTP Requests

• Using aiohttp library for async HTTP requests
• Making parallel API calls efficiently (10x-100x faster)
• Session management and connection pooling
• Request headers, authentication, and cookies
• POST requests with JSON data
• Streaming large responses

import aiohttpasync def fetch_api_data():
async with aiohttp.ClientSession() as session:
tasks = [session.get(url) for url in urls]
responses = await asyncio.gather(*tasks)
return [await r.json() for r in responses]

13.2 Async Database Operations

• Using asyncpg for PostgreSQL (fastest Python PostgreSQL driver)
• Connection pooling for database efficiency
• Transaction handling with async context managers
• Batch operations and bulk inserts
• Prepared statements and query optimization
• Other async database drivers: aiomysql, motor (MongoDB)

13.3 Async File I/O

• Using aiofiles library for async file operations
• When async file operations matter (many small files, network file systems)
• Reading and writing files without blocking
• Processing multiple files concurrently
• Streaming large files efficiently

13.4 Mixing Sync and Async Code

• asyncio.to_thread() - running blocking code in threads (Python 3.9+)
• Running sync code in executor pools
• Best practices for hybrid codebases (mixing async and sync)
• Bridging sync libraries in async applications
• When to refactor sync code vs wrap it
• Common pitfalls and how to avoid them

# Running blocking code in async function
async def process_data():
# This blocks the event loop - BAD!
result = blocking_function()

# This runs in thread pool - GOOD!
result = await asyncio.to_thread(blocking_function)

14.1 Async Frameworks

• FastAPI: modern async web framework with automatic API docs
• Building REST APIs with async route handlers
• aiohttp server for HTTP servers and WebSocket support
• Comparing async frameworks: FastAPI vs Sanic vs Quart
• When async frameworks outperform sync (Flask, Django)
• Middleware and dependency injection in async frameworks

from fastapi import FastAPIapp = FastAPI()@app.get("/users/{user_id}")
async def get_user(user_id: int):
user = await db.fetch_user(user_id)
return user

14.2 Testing Async Code

• Using pytest-asyncio plugin for async tests
• Writing async test functions with @pytest.mark.asyncio
• Mocking async functions with AsyncMock
• Testing concurrent behavior and race conditions
• Using fixtures for async resources (databases, HTTP clients)
• Best practices for async test organization

import pytest# Async test function
@pytest.mark.asyncio
async def test_fetch_data():
result = await fetch_data("https://api.example.com")
assert result["status"] == "success"

14.3 Performance Optimization

• Profiling async applications with asyncio debug mode
• Identifying common bottlenecks in async code
• Connection pooling and reusing sessions
• Optimizing task scheduling and prioritization
• Memory management in long-running async applications
• Async best practices checklist for production