Python Notes
HubHistory of Python - Complete Guide 2026Python Applications - Complete Guide 2026Python Features - Complete Guide 2026What is Python? - Complete Guide 2026Why Learn Python? - Complete Guide 2026Your First Python Program – Hello World & Beyond 2026How to Install Python on Windows, Mac & Linux – Complete Guide 2026Install VS Code for Python – Complete Setup Guide with Extensions 2026Python Environment Setup – Virtual Environments, pip & Project Structure 2026Python IDLE – Complete Guide for Beginners 2026Python CommentsPython Data TypesPython Input and OutputPython OperatorsPython SyntaxPython Strings BasicsPython Type CastingPython VariablesBreak, Continue and Pass in PythonElif Statement in PythonFor Loop in PythonIf-Else Statement in PythonIf Statement in PythonNested If in PythonPattern Programs in PythonWhile Loop in PythonDecorators in PythonFunction Arguments in PythonFunctions Basics in PythonGenerators in PythonLambda Functions in PythonRecursive Functions in PythonReturn Statement in PythonScope of Variables in PythonAbstraction in PythonClasses and Objects in PythonConstructors in PythonEncapsulation in PythonInheritance in PythonMagic Methods (Dunder Methods) in PythonMethod Overriding in PythonPolymorphism in PythonPython Comprehensions – List, Dict, Set & GeneratorPython Dictionaries – Key-Value StorePython Dictionary Methods – Complete ReferencePython List Methods – All Built-in MethodsPython Lists – Complete GuidePython Set Methods – Complete ReferencePython Sets – Unordered Unique CollectionsPython Tuples – Immutable SequencesPython Asynchronous Programming with asyncioPython Context ManagersAdvanced Python DecoratorsAdvanced Python GeneratorsPython Iterators - Advanced GuidePython Memory ManagementPython MultiprocessingPython MultithreadingCRUD Operations in Python DatabasesMySQL with Python (mysql-connector-python)ORM Introduction with SQLAlchemyPostgreSQL with Python (psycopg2)SQLite3 with PythonIntroduction to DjangoDjango Models and ORMDjango REST API with DRFDjango ViewsIntroduction to FlaskFlask RoutingFlask Templates with Jinja2Email Automation with PythonPDF Automation with PythonSelenium Web Automation with PythonTask Scheduler with PythonWeb Scraping with PythonData Analysis with PythonData Cleaning with PythonData Visualization ProjectData Visualization with MatplotlibNumPy IntroductionPandas IntroductionStatistical Visualization with SeabornClassification AlgorithmsClustering AlgorithmsIntroduction to Machine LearningMachine Learning Project: Churn PredictionModel Evaluation and SelectionRegression AlgorithmsSave pipeline (includes preprocessing + model)AI Assistant ProjectCalculator ProjectChatbot ProjectExpense Tracker ProjectFace Detection ProjectPassword Generator ProjectWeather App ProjectPython Coding Interview QuestionsPython OOP Interview Questions and AnswersPython Master CheatsheetPython Interview Questions and AnswersPython Best PracticesCommon Python Errors and SolutionsPython Debugging TechniquesPython Learning Resources
Deep dive into Python async/await, asyncio event loop, coroutines, tasks, async generators, aiohttp, and real-world asynchronous patterns with Hindi explanations.
Introduction
Async programming allows Python to perform concurrent I/O operations in a single thread. When one operation is waiting (network response, disk read), another operation continues executing.
Analogy: A chef who puts one dish in the oven and preps another — one task at a time, but efficiently.
2. Event Loop
python example
import asyncio
# Event loop kya hai?
"""
Event Loop asyncio ka heart hai:
1. Coroutines register karta hai
2. I/O events monitor karta hai
3. Ready coroutines ko run karta hai
4. Callbacks schedule karta hai
"""
# Getting the event loop
async def show_loop_info():
loop = asyncio.get_event_loop()
print(f"Loop type: {type(loop).__name__}")
print(f"Is running: {loop.is_running()}")
asyncio.run(show_loop_info())
# Manual event loop (older style — avoid in new code)
# loop = asyncio.new_event_loop()
# loop.run_until_complete(show_loop_info())
# loop.close()
# asyncio.run() is the preferred way (Python 3.7+)
async def main():
await asyncio.sleep(0) # Yield control once
print("Main coroutine")
asyncio.run(main())Output
Loop type: _UnixSelectorEventLoop Is running: True Main coroutine
3. Tasks — Concurrent Execution
python example
import asyncio
import time
async def fetch_data(source, delay):
print(f"Fetching from {source}...")
await asyncio.sleep(delay) # Simulate network delay
data = f"data_from_{source}"
print(f"Got data from {source}")
return data
async def main():
# asyncio.create_task() — run in background
start = time.time()
# Create tasks (start immediately)
task1 = asyncio.create_task(fetch_data("API_1", 2))
task2 = asyncio.create_task(fetch_data("API_2", 1))
task3 = asyncio.create_task(fetch_data("API_3", 1.5))
# Wait for all tasks
results = await asyncio.gather(task1, task2, task3)
print(f"\nAll results: {results}")
print(f"Total time: {time.time()-start:.2f}s") # ~2s, not 4.5s!
asyncio.run(main())Output
Fetching from API_1... Fetching from API_2... Fetching from API_3... Got data from API_2 Got data from API_3 Got data from API_1 All results: ['data_from_API_1', 'data_from_API_2', 'data_from_API_3'] Total time: 2.00s
4. asyncio.gather() vs asyncio.wait()
Example
import asyncio
async def task(name, delay, fail=False):
await asyncio.sleep(delay)
if fail:
raise ValueError(f"{name} failed!")
return f"{name} done"
async def demo_gather():
# gather() — all results in order
results = await asyncio.gather(
task("A", 1),
task("B", 0.5),
task("C", 1.5),
)
print(f"gather results: {results}")
# gather() with exception handling
results = await asyncio.gather(
task("A", 1),
task("B", 0.5, fail=True), # This fails
task("C", 0.3),
return_exceptions=True # Exceptions as results, don't raise
)
print(f"With exceptions: {results}")
async def demo_wait():
tasks = [
asyncio.create_task(task("X", 1.5)),
asyncio.create_task(task("Y", 0.5)),
asyncio.create_task(task("Z", 1)),
]
# wait() — more control
done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
print(f"First completed: {len(done)} tasks")
for t in done:
print(f" Result: {t.result()}")
# Cancel remaining
for t in pending:
t.cancel()
await asyncio.wait(pending)
asyncio.run(demo_gather())
asyncio.run(demo_wait())
Output
gather results: ['A done', 'B done', 'C done']
With exceptions: ['A done', ValueError('B failed!'), 'C done']
First completed: 1 tasks
Result: Y done5. Async Generators
Example
import asyncio
import random
async def async_data_stream(n, delay=0.1):
"""Simulated data stream"""
for i in range(n):
await asyncio.sleep(delay) # Simulate data arriving
yield {"id": i, "value": random.randint(1, 100)}
async def process_stream():
total = 0
count = 0
# async for — iterate over async generator
async for data in async_data_stream(5):
print(f"Received: {data}")
total += data["value"]
count += 1
print(f"Average: {total/count:.1f}")
asyncio.run(process_stream())
# Async comprehension
async def collect_data():
# Async list comprehension
results = [item async for item in async_data_stream(5, delay=0.05)]
print(f"Collected: {results}")
asyncio.run(collect_data())
Output
Received: {'id': 0, 'value': 42}
Received: {'id': 1, 'value': 73}
Received: {'id': 2, 'value': 15}
Received: {'id': 3, 'value': 88}
Received: {'id': 4, 'value': 56}
Average: 54.8
Collected: [{'id': 0, 'value': 31}, {'id': 1, 'value': 67}, {'id': 2, 'value': 44}, {'id': 3, 'value': 92}, {'id': 4, 'value': 19}]📝 Hindi Explanation
Async Generator uses bothasync defandyield. Iterate it withasync foror[x async for x in gen]async comprehension. It's perfect for real-time data streams (websockets, live feeds, streaming APIs).
6. Async Context Managers
Example
import asyncio
from contextlib import asynccontextmanager
class AsyncDBConnection:
"""Simulated async database connection"""
async def __aenter__(self):
print("Connecting to database asynchronously...")
await asyncio.sleep(0.1) # Connection setup
self.connected = True
return self
async def __aexit__(self, exc_type, exc_val, exc_tb):
print("Closing database connection...")
await asyncio.sleep(0.05) # Cleanup
self.connected = False
return False
async def execute(self, query):
await asyncio.sleep(0.1) # Simulate query
return f"Result of: {query}"
async def main():
async with AsyncDBConnection() as db:
result = await db.execute("SELECT * FROM users")
print(f"Query result: {result}")
asyncio.run(main())
# asynccontextmanager decorator
@asynccontextmanager
async def async_timer(label):
import time
start = time.perf_counter()
try:
yield
finally:
elapsed = time.perf_counter() - start
print(f"[{label}] {elapsed:.4f}s")
async def main2():
async with async_timer("Database query"):
await asyncio.sleep(0.2) # Simulate work
asyncio.run(main2())
Output
Connecting to database asynchronously... Query result: Result of: SELECT * FROM users Closing database connection... [Database query] 0.2003s
7. Async Synchronization Primitives
Example
import asyncio
# asyncio.Lock
async def demo_lock():
lock = asyncio.Lock()
shared_value = [0]
async def increment(n):
for _ in range(n):
async with lock:
temp = shared_value[0]
await asyncio.sleep(0) # Yield control (simulates async work)
shared_value[0] = temp + 1
tasks = [asyncio.create_task(increment(1000)) for _ in range(5)]
await asyncio.gather(*tasks)
print(f"Lock-protected value: {shared_value[0]}") # Always 5000
# asyncio.Semaphore — limit concurrent operations
async def demo_semaphore():
semaphore = asyncio.Semaphore(3) # Max 3 concurrent
async def limited_task(name):
async with semaphore:
print(f"{name}: Started")
await asyncio.sleep(1)
print(f"{name}: Done")
tasks = [asyncio.create_task(limited_task(f"Task-{i}")) for i in range(10)]
await asyncio.gather(*tasks)
# asyncio.Queue — producer-consumer
async def demo_queue():
queue = asyncio.Queue(maxsize=5)
async def producer():
for i in range(10):
await queue.put(f"item-{i}")
print(f"Produced: item-{i}")
async def consumer(name):
while True:
try:
item = await asyncio.wait_for(queue.get(), timeout=1.0)
print(f"[{name}] Consumed: {item}")
queue.task_done()
await asyncio.sleep(0.1)
except asyncio.TimeoutError:
break
prod = asyncio.create_task(producer())
cons = [asyncio.create_task(consumer(f"C{i}")) for i in range(3)]
await asyncio.gather(prod, *cons)
asyncio.run(demo_lock())
asyncio.run(demo_semaphore())
asyncio.run(demo_queue())
Output
Lock-protected value: 5000 Task-0: Started Task-1: Started Task-2: Started Task-0: Done Task-1: Done Task-2: Done Task-3: Started Task-4: Started Task-5: Started ... Produced: item-0 [C0] Consumed: item-0
8. Real-World: Async HTTP Requests
Example
# pip install aiohttp
import asyncio
# import aiohttp # Uncomment when aiohttp is installed
async def fetch_url_simulation(session_id, url, delay):
"""Simulate async HTTP fetch"""
await asyncio.sleep(delay)
return {
"session": session_id,
"url": url,
"status": 200,
"data": f"response_from_{url[-10:]}"
}
async def fetch_all_urls(urls):
"""Fetch all URLs in parallel"""
tasks = [
asyncio.create_task(fetch_url_simulation(i, url, 0.5))
for i, url in enumerate(urls)
]
results = await asyncio.gather(*tasks, return_exceptions=True)
successful = [r for r in results if not isinstance(r, Exception)]
failed = [r for r in results if isinstance(r, Exception)]
print(f"Successful: {len(successful)}, Failed: {len(failed)}")
return successful
# Simulate fetching multiple URLs
urls = [f"https://api.example.com/data/{i}" for i in range(10)]
import time
start = time.time()
results = asyncio.run(fetch_all_urls(urls))
print(f"Fetched {len(results)} URLs in {time.time()-start:.2f}s")
Output
Successful: 10, Failed: 0 Fetched 10 URLs in 0.50s
📝 Hindi Explanation
aiohttp is an asyncio-based HTTP client library.async with aiohttp.ClientSession() as session:manages the connection pool. Withasyncio.gather(), all requests are sent in parallel — 10 URLs take 0.5s (the time for 1 URL), not 10s!
9. Error Handling in Async Code
Example
import asyncio
async def might_fail(n):
await asyncio.sleep(0.1)
if n % 3 == 0:
raise ValueError(f"Failed for {n}")
return n * 2
async def safe_gather():
results = []
errors = []
# Method 1: return_exceptions=True
all_results = await asyncio.gather(
*[might_fail(i) for i in range(10)],
return_exceptions=True
)
for i, result in enumerate(all_results):
if isinstance(result, Exception):
errors.append((i, result))
else:
results.append(result)
print(f"Success: {results}")
print(f"Errors: {errors}")
async def with_timeout():
"""Timeout handling"""
try:
result = await asyncio.wait_for(
asyncio.sleep(10), # Takes too long
timeout=2.0
)
except asyncio.TimeoutError:
print("Operation timed out!")
async def task_exception_handling():
async def bad_task():
await asyncio.sleep(0.1)
raise RuntimeError("Task failed!")
task = asyncio.create_task(bad_task())
try:
result = await task
except RuntimeError as e:
print(f"Caught task exception: {e}")
asyncio.run(safe_gather())
asyncio.run(with_timeout())
asyncio.run(task_exception_handling())
Output
Success: [2, 4, 8, 10, 14, 16]
Errors: [(0, ValueError('Failed for 0')), (3, ValueError('Failed for 3')), (6, ValueError('Failed for 6')), (9, ValueError('Failed for 9'))]
Operation timed out!
Caught task exception: Task failed!10. Cancellation
python example
import asyncio
async def long_running():
try:
print("Long running task started")
await asyncio.sleep(10)
print("Long running task done")
except asyncio.CancelledError:
print("Task was cancelled!")
# Cleanup here
raise # Always re-raise CancelledError!
async def main():
task = asyncio.create_task(long_running())
await asyncio.sleep(1)
# Cancel the task
task.cancel()
try:
await task
except asyncio.CancelledError:
print("Main: Task cancelled confirmed")
asyncio.run(main())Output
Long running task started Task was cancelled! Main: Task cancelled confirmed
11. Best Practices
python example
import asyncio
# ✅ Use asyncio.run() as entry point
async def main():
pass
asyncio.run(main())
# ✅ Use asyncio.create_task() for concurrent background tasks
async def concurrent_demo():
task1 = asyncio.create_task(asyncio.sleep(1))
task2 = asyncio.create_task(asyncio.sleep(1))
await asyncio.gather(task1, task2)
# ✅ Handle CancelledError properly
async def cancellable():
try:
await asyncio.sleep(10)
except asyncio.CancelledError:
# Cleanup
raise # MUST re-raise!
# ✅ Use asyncio.wait_for() for timeouts
async def with_timeout():
try:
result = await asyncio.wait_for(asyncio.sleep(5), timeout=2)
except asyncio.TimeoutError:
pass
# ❌ Don't mix sync blocking with async
# async def bad():
# time.sleep(5) # Blocks entire event loop!
# ✅ Use asyncio.sleep(0) to yield control
async def good():
for i in range(1000):
if i % 100 == 0:
await asyncio.sleep(0) # Yield to other coroutines
# ❌ Don't call async functions without await
# result = async_function() # Returns coroutine object, not result!
# ✅ Always await async functions
async def correct():
result = await some_async_function()
async def some_async_function():
return 42Summary
| Concept | Tool | Use Case |
|---|---|---|
| Run coroutine | asyncio.run() | Entry point |
| Concurrent tasks | asyncio.gather() | Multiple coroutines |
| Background task | asyncio.create_task() | Fire and forget |
| Timeout | asyncio.wait_for() | Deadline control |
| Rate limiting | asyncio.Semaphore() | Limit concurrency |
| Communication | asyncio.Queue() | Producer-consumer |
| Mutual exclusion | asyncio.Lock() | Shared state |
Example
# Async pattern template
import asyncio
async def async_pipeline(items, concurrency=10):
semaphore = asyncio.Semaphore(concurrency)
async def process_one(item):
async with semaphore:
await asyncio.sleep(0.1) # Your async work here
return f"processed_{item}"
tasks = [asyncio.create_task(process_one(item)) for item in items]
return await asyncio.gather(*tasks, return_exceptions=True)
results = asyncio.run(async_pipeline(range(20), concurrency=5))
print(f"Processed {len(results)} items")
asyncio is perfect for: Web servers (FastAPI, aiohttp), web scraping, API clients, real-time applications, and any I/O-heavy workloads.
Output
Processed 20 items
⚠️ Common Mistakes
1. ❌ Using time.sleep() in async code
python example
import asyncio, time
# ❌ WRONG — blocks the entire event loop!
async def bad_sleep():
time.sleep(5) # No other coroutine will run for 5 seconds!
# ✅ CORRECT — non-blocking sleep
async def good_sleep():
await asyncio.sleep(5) # Event loop doosre tasks run karegatime.sleep()is synchronous — it blocks the entire event loop. Always useawait asyncio.sleep()in async code.
2. ❌ Forgetting await before coroutine calls
python example
async def fetch_data():
return "data"
# ❌ WRONG — returns coroutine object, not result!
async def bad():
result = fetch_data() # RuntimeWarning: coroutine was never awaited
print(result) # <coroutine object fetch_data at 0x...>
# ✅ CORRECT
async def good():
result = await fetch_data()
print(result) # "data"Using await is mandatory — without await you only get a coroutine object, not the actual result!3. ❌ Creating tasks but never awaiting them
python example
# ❌ WRONG — task might not complete before program exits
async def bad():
asyncio.create_task(some_work()) # Fire and forget — may get garbage collected!
# ✅ CORRECT — always keep a reference and await
async def good():
task = asyncio.create_task(some_work())
await task # Ya gather() use karoAfter creating a task, you must await it or keep a reference to it, otherwise the task may be silently cancelled.
4. ❌ Not handling CancelledError properly
python example
# ❌ WRONG — swallowing CancelledError breaks cancellation
async def bad():
try:
await asyncio.sleep(10)
except asyncio.CancelledError:
print("Cancelled") # Error swallowed — task won't actually cancel!
# ✅ CORRECT — always re-raise CancelledError
async def good():
try:
await asyncio.sleep(10)
except asyncio.CancelledError:
print("Cleaning up...")
raise # MUST re-raise!Catching and re-raising CancelledError is essential. If you swallow it, the cancellation chain will break.5. ❌ Running CPU-bound work in async functions
python example
# ❌ WRONG — blocks the event loop
async def bad():
result = sum(range(10_000_000)) # CPU-intensive, no await points!
# ✅ CORRECT — offload to thread pool
async def good():
loop = asyncio.get_event_loop()
result = await loop.run_in_executor(None, sum, range(10_000_000))Don't perform CPU-heavy work (calculations, image processing) directly in async functions. Offload to a thread pool using run_in_executor().6. ❌ Mixing asyncio.run() inside an already running event loop
python example
# ❌ WRONG — RuntimeError: This event loop is already running
async def bad():
asyncio.run(some_coroutine()) # Can't nest asyncio.run()!
# ✅ CORRECT — just await directly
async def good():
await some_coroutine()You cannot callasyncio.run()when an event loop is already running. Useawaitdirectly instead.
7. ❌ Not using return_exceptions=True with asyncio.gather()
python example
# ❌ RISKY — one failure cancels everything
async def risky():
results = await asyncio.gather(task1(), task2(), task3()) # task2 fails = all fail!
# ✅ SAFE — handle failures gracefully
async def safe():
results = await asyncio.gather(task1(), task2(), task3(), return_exceptions=True)
for r in results:
if isinstance(r, Exception):
print(f"Error: {r}")Use return_exceptions=True when you need all results — a single failure won't cancel the remaining tasks.✅ Key Takeaways
- 🔹
async defdefines a coroutine function — unlike a normal function, calling it returns a coroutine object that executes when youawaitit. - 🔹
awaitpauses execution (without blocking!) — the event loop can run other coroutines while waiting. - 🔹
asyncio.run()is the standard entry point (Python 3.7+) — it creates the event loop, runs the coroutine, and handles cleanup. - 🔹
asyncio.gather()runs multiple coroutines concurrently and returns results in an ordered list — perfect for parallel I/O. - 🔹
asyncio.create_task()schedules a coroutine to run in the background — the result is available when you await it. - 🔹 Async is NOT parallel — it's cooperative multitasking in a single thread. For CPU-bound work, use
multiprocessingorrun_in_executor(). - 🔹
asyncio.Semaphoreis used for rate limiting — essential for limiting API calls and DB connections. - 🔹
asyncio.Queueimplements the producer-consumer pattern — best for async pipelines and worker pools. - 🔹 Error handling: use
return_exceptions=Truewith gather() — one failed task won't cancel the others. - 🔹 Always handle
CancelledError— perform cleanup and re-raise it, don't swallow it!
❓ FAQ
Q1: What is the difference between asyncio and threading?
A: asyncio performs cooperative multitasking in a single thread — coroutines voluntarily yield control at await points. Threading is OS-level preemptive multitasking where the OS switches threads. asyncio is better for I/O-bound work (less overhead, no GIL issues), while threading is useful for CPU-bound or legacy blocking code.
Q2: Does async code automatically run faster?
A: No! Async only provides speed benefits for I/O-bound operations (network calls, file reads, DB queries) where there is wait time. For CPU-bound work (calculations, image processing), there's no benefit — use multiprocessing for that. The advantage of async is that other work can happen during wait time.
Q3: What is the difference between asyncio.gather() and asyncio.wait()?
A: gather() is simpler — all results come in an ordered list. wait() gives more control — you can set return conditions like FIRST_COMPLETED, FIRST_EXCEPTION, or ALL_COMPLETED. With wait() you can get partial results and cancel pending tasks.
Q4: Can I use an existing synchronous library in async code?
A: Yes! Use loop.run_in_executor() — it runs the blocking function in a thread pool without blocking the event loop:
python example
import asyncio
import requests # Sync library
async def fetch():
loop = asyncio.get_event_loop()
response = await loop.run_in_executor(None, requests.get, "https://api.example.com")
return response.json()Q5: How does FastAPI use async internally?
A: FastAPI runs on uvicorn (ASGI server) which runs an asyncio event loop. Each request is a coroutine — async def endpoints run directly on the event loop, while regular def endpoints run in a thread pool. That's why you shouldn't make blocking calls in FastAPI's async def endpoints.
Q6: async for kab use karna chahiye?
A: When data is arriving asynchronously one item at a time from a stream — websocket messages, database cursor results, file chunks streaming, or Server-Sent Events. A regular for loop doesn't work with async iterators.
Q7: What is the difference between asyncio.Queue and queue.Queue?
A: asyncio.Queue is async/await compatible — await queue.get() doesn't block the event loop. queue.Queue is for threading — queue.get() is blocking. Don't mix them — always use asyncio.Queue in async code!
Q8: How do you debug async code in production?
A: (1) Enable asyncio.get_event_loop().set_debug(True) — it detects slow callbacks and unawaited coroutines. (2) Set the PYTHONASYNCIODEBUG=1 environment variable. (3) Use the aiodebug library. (4) Track task IDs with structured logging (loguru/structlog).
🎯 Interview Questions
Q1: What is the difference between concurrency and parallelism in Python's asyncio?
A: Concurrency means multiple tasks make progress by interleaving execution on a single thread — asyncio achieves this via cooperative multitasking at await points. Parallelism means multiple tasks execute simultaneously on different CPU cores (multiprocessing). asyncio is concurrent but NOT parallel — it excels at I/O-bound workloads where tasks spend most time waiting.
Q2: Explain the asyncio event loop and its lifecycle.
A: The event loop is the central execution mechanism: (1) It maintains a queue of ready coroutines. (2) Runs a coroutine until it hits an await. (3) Registers the awaited I/O operation with the OS (epoll/kqueue/IOCP). (4) Picks the next ready coroutine. (5) When I/O completes, marks the waiting coroutine as ready. Lifecycle: asyncio.run() creates the loop → runs the main coroutine → closes the loop. Only one event loop runs per thread.
Q3: What happens when you call an async def function without await?
A: It returns a coroutine object without executing the function body. Python will emit RuntimeWarning: coroutine 'func_name' was never awaited. The coroutine is then garbage collected without execution. This is a common bug — always await coroutines or wrap them in asyncio.create_task().
Q4: How does asyncio.gather() handle exceptions? What's return_exceptions?
A: By default, if any coroutine raises an exception, gather() cancels all remaining tasks and propagates the first exception. With return_exceptions=True, exceptions are returned as values in the results list alongside successful results — no task is cancelled, and you can handle errors individually.
Q5: How would you limit concurrent async operations (e.g., API rate limiting)?
A: Use asyncio.Semaphore:
Example
semaphore = asyncio.Semaphore(10) # Max 10 concurrent
async def limited_fetch(url):
async with semaphore:
return await aiohttp_session.get(url)
# All 1000 URLs will be fetched, but max 10 at a time
tasks = [limited_fetch(url) for url in urls]
results = await asyncio.gather(*tasks)
This is essential for respecting API rate limits and preventing resource exhaustion.
Q6: What is the difference between asyncio.create_task() and directly awaiting a coroutine?
A: await coroutine() runs sequentially — the current coroutine waits for it to complete before continuing. asyncio.create_task(coroutine()) schedules it for concurrent execution — it starts running in the background immediately, and you can await the task later or gather multiple tasks. Use create_task() when you want concurrency.
Q7: How do you handle timeouts in async code?
A: Use asyncio.wait_for(coroutine, timeout=seconds). It raises asyncio.TimeoutError if the coroutine doesn't complete within the specified time. For more control, use asyncio.timeout() (Python 3.11+) context manager. Always wrap timeout-sensitive operations in try/except to handle graceful fallback.
Q8: Can you mix synchronous and asynchronous code? How?
A: Yes — use loop.run_in_executor() to run blocking sync code in a thread pool without blocking the event loop. For the reverse (calling async from sync), use asyncio.run() at the top level. Never call blocking functions directly inside async functions — it starves the event loop and defeats the purpose of async.
Q9: What are async context managers and when do you use them?
A: Async context managers implement __aenter__ and __aexit__ (both async). Use them when setup/teardown involves I/O — database connections, HTTP sessions, file handles, locks. Example: async with aiohttp.ClientSession() as session: ensures the connection pool is properly opened and closed asynchronously.
Q10: Design a producer-consumer system using asyncio. What components do you need?
A: Components: (1) asyncio.Queue as the buffer between producers and consumers. (2) Producer coroutines that await queue.put(item). (3) Consumer coroutines that await queue.get() and call queue.task_done(). (4) await queue.join() to wait until all items are processed. (5) Graceful shutdown via cancellation or sentinel values. Use maxsize to apply backpressure on fast producers.
Continue the lesson path
Study next in this module
01Advanced PythonPython Context ManagersComprehensive guide to Python context managers using with statement, __enter__ and __exit__ methods, contextlib module, nested context managers and custom resource management.02Advanced PythonAdvanced Python DecoratorsMaster advanced Python decorators including decorator factories, class decorators, stacking decorators, functools.wraps, parameterized decorators, and real-world patterns.03Advanced PythonAdvanced Python GeneratorsDeep dive into Python generators, yield keyword, generator expressions, send(), throw(), close() methods, pipelines, and coroutines with Hindi explanations.04Advanced PythonPython Iterators - Advanced GuideMaster Python iterators with __iter__, __next__, custom iterator classes, infinite iterators, and real-world use cases with detailed examples and Hindi explanations.