Python Async Await Tutorial with Diagrams & Real Examples (2026)

The Story That Explains async / await ☕async / await समझाने वाली कहानी ☕一个讲清 async / await 的故事 ☕

async / await is Python's way to write code that pauses cleanly at slow I/O and lets other work run during the wait. It runs on one thread, it is cooperative, and it is much faster for programs that spend most of their time waiting on the network, a database, files or timers.

async / await Python का ऐसा code लिखने का तरीक़ा है जो धीमे I/O पर साफ़ रुकता है और इंतज़ार के दौरान दूसरा काम चलने देता है। यह एक thread पर चलता है, cooperative है, और उन programs के लिए बहुत तेज़ है जो ज़्यादातर समय network, database, files या timers का इंतज़ार करते हैं।

async / await 是 Python 编写这样一种代码的方式：它在缓慢的 I/O 处干净地暂停，并在等待期间让其他工作运行。它运行在 一个线程 上，是 协作式 的，对于大部分时间都在等待网络、数据库、文件或定时器的程序来说要快得多。

The Problem — Why Sync Code Is Slow at I/O 🐢समस्या — Sync Code I/O में धीमा क्यों है 🐢问题 — 为什么同步代码在 I/O 上很慢 🐢

Fetch three URLs, each taking about 1 second because the network is slow. Synchronous code stops the whole program during every wait.

तीन URLs fetch कीजिए, हर एक लगभग 1 second लेता है क्योंकि network धीमा है। Synchronous code हर इंतज़ार के दौरान पूरा program रोक देता है।

获取三个 URL，因为网络慢，每个大约要 1 秒。同步代码在每次等待时都会让整个程序停下来。

The Three Building Blocks 🧱तीन बुनियादी हिस्से 🧱三个基本组成部分 🧱

Your first async functionआपका पहला async function你的第一个异步函数

import asyncio, time

async def greet(name):
    print(f"Hello {name}, starting...")
    await asyncio.sleep(1)          # pause 1 s WITHOUT blocking
    print(f"Goodbye {name}")

coro = greet("Mohit")               # calling greet() only CREATES a coroutine
print(type(coro).__name__, "- nothing has run yet")

t0 = time.perf_counter()
asyncio.run(coro)                   # asyncio.run() starts the event loop and runs it
print(f"took {time.perf_counter() - t0:.2f}s")

We added two lines to the original to make the key point visible: greet("Mohit") alone printed nothing — it only made a coroutine object. The greeting ran when asyncio.run() started the loop.

मुख्य बात दिखाने के लिए हमने मूल में दो lines जोड़ीं: अकेले greet("Mohit") ने कुछ print नहीं किया — इसने बस एक coroutine object बनाया। Greeting तब चली जब asyncio.run() ने loop शुरू किया।

为了让关键点更直观，我们在原文基础上加了两行：单独调用 greet("Mohit") 什么也没打印 — 它只创建了一个 coroutine 对象。直到 asyncio.run() 启动事件循环，问候才真正运行。

⏳ await in depth — what really happens⏳ await गहराई से — असल में क्या होता है⏳ 深入理解 await — 到底发生了什么

await is the heart of async code, so let us look at it slowly. x = await something means: "pause this coroutine until something is finished, then give me its result." While this coroutine is paused, the event loop is free to run other tasks. Four facts follow from this.

await async code का दिल है, तो इसे धीरे-धीरे देखते हैं। x = await something का मतलब है: "इस coroutine को तब तक रोको जब तक something पूरा न हो, फिर मुझे उसका result दो।" जब यह coroutine रुका होता है, event loop दूसरे tasks चलाने के लिए आज़ाद होता है। इससे चार बातें निकलती हैं।

await 是异步代码的核心，我们来慢慢看。x = await something 的意思是："暂停这个协程，直到 something 完成，然后把它的结果给我。"在这个协程暂停期间，事件循环可以自由地运行其他任务。由此可以得出四个事实。

Fact 1 — await waits; create_task overlapsबात 1 — await इंतज़ार करता है; create_task साथ चलाता है事实 1 — await 是等待；create_task 才能重叠

import asyncio, time

async def job(name, secs):
    print(f"{time.perf_counter() - T0:4.1f}s  {name} starts")
    await asyncio.sleep(secs)
    print(f"{time.perf_counter() - T0:4.1f}s  {name} done")
    return name.upper()

async def main():
    a = await job("a", 1)      # main pauses here until job a is DONE
    b = await job("b", 1)      # only then does job b even start
    print("results:", a, b)

T0 = time.perf_counter()
asyncio.run(main())
print(f"total {time.perf_counter() - T0:.1f}s")

Job b did not even start until job a was done: 2 seconds in total. Now the same jobs, scheduled as tasks first:

Job a पूरा होने तक job b शुरू भी नहीं हुआ: कुल 2 सेकंड। अब वही jobs, पहले tasks बनाकर:

直到任务 a 完成，任务 b 才 开始：总共 2 秒。现在把同样的任务先安排成 Task：

import asyncio, time

async def job(name, secs):
    print(f"{time.perf_counter() - T0:4.1f}s  {name} starts")
    await asyncio.sleep(secs)
    print(f"{time.perf_counter() - T0:4.1f}s  {name} done")
    return name.upper()

async def main():
    ta = asyncio.create_task(job("a", 1))   # scheduled now
    tb = asyncio.create_task(job("b", 1))   # scheduled now
    a = await ta               # main waits; meanwhile BOTH jobs run
    b = await tb               # already finished - returns at once
    print("results:", a, b)

T0 = time.perf_counter()
asyncio.run(main())
print(f"total {time.perf_counter() - T0:.1f}s")

Fact 2 — await returns the value and passes on errorsबात 2 — await value लौटाता है और errors आगे देता है事实 2 — await 返回值并传递错误

import asyncio

async def fetch_price(symbol):
    await asyncio.sleep(0.1)
    if symbol == "XYZ":
        raise ValueError(f"unknown symbol {symbol}")
    return 142.35

async def main():
    price = await fetch_price("AAPL")        # await gives back the return value
    print("price:", price)
    try:
        await fetch_price("XYZ")             # an error inside comes out HERE
    except ValueError as e:
        print("caught at the await line:", e)

asyncio.run(main())

Fact 3 — an await only gives others a turn if it really waitsबात 3 — await दूसरों को मौका तभी देता है जब सच में इंतज़ार करे事实 3 — 只有真正等待时，await 才会让出机会

import asyncio

async def quick():
    return 1                    # awaits nothing - never pauses

async def ticker():
    for i in range(3):
        print("  tick", i)
        await asyncio.sleep(0)  # a real pause point

async def worker(really_pause):
    for i in range(3):
        if really_pause:
            await asyncio.sleep(0)   # gives the loop a turn
        else:
            await quick()            # runs straight through, no turn given
        print("work", i)

async def main(really_pause):
    print(f"--- really_pause={really_pause}")
    await asyncio.gather(worker(really_pause), ticker())

asyncio.run(main(False))
asyncio.run(main(True))

With await quick(), the worker printed all three lines before the ticker got a single turn — quick() never paused. With await asyncio.sleep(0) they took turns.

await quick() के साथ worker ने तीनों lines print कर दीं, ticker को एक भी मौका मिलने से पहले — quick() कभी रुका ही नहीं। await asyncio.sleep(0) के साथ दोनों ने बारी-बारी से चलाया।

用 await quick() 时，worker 把三行都打印完，ticker 才第一次轮到 — quick() 从未暂停。用 await asyncio.sleep(0) 时，二者轮流运行。

What can you await?आप किसे await कर सकते हैं?哪些东西可以 await？

import asyncio

async def main():
    loop = asyncio.get_running_loop()

    fut = loop.create_future()                      # 1) a Future
    loop.call_later(0.1, fut.set_result, "filled by the loop")
    print(await fut)

    task = asyncio.create_task(asyncio.sleep(0.1, result="task result"))
    print(await task)                               # 2) a Task

    print(await asyncio.sleep(0.1, result="coroutine result"))   # 3) a coroutine

    try:
        await 5                                     # not awaitable
    except TypeError as e:
        print("TypeError:", e)

asyncio.run(main())

try:
    compile("import asyncio\nawait asyncio.sleep(1)", "demo.py", "exec")
except SyntaxError as e:
    print("SyntaxError:", e.msg)

⏱️ Simulator: Await Patterns Lab⏱️ Simulator: Await Patterns Lab⏱️ 模拟器：await 模式实验室

Three jobs: A and B each wait 0.5 s, C is a 0.5 s wait or a 1 s CPU loop. Pick how they are awaited. Each timeline is a real measured run: grey = waiting at await, red = finished waiting but stuck because the loop is busy, solid = using the CPU.

तीन jobs: A और B हर एक 0.5 s इंतज़ार करते हैं, C 0.5 s इंतज़ार या 1 s का CPU loop है। चुनिए उन्हें कैसे await किया जाए। हर timeline एक असली मापा हुआ run है: धूसर = await पर इंतज़ार, लाल = इंतज़ार पूरा पर loop व्यस्त होने से अटका, गाढ़ा = CPU इस्तेमाल।

三个任务：A 和 B 各等待 0.5 秒，C 是 0.5 秒等待或 1 秒的 CPU 循环。选择 await 它们的方式。每条时间线都是真实测量的运行：灰色 = 在 await 处等待，红色 = 等待已结束却因事件循环忙碌而 卡住，实色 = 占用 CPU。

Inside the Event Loop 🔄Event Loop के अंदर 🔄事件循环内部 🔄

🔄 Simulator: Event Loop Stepper🔄 Simulator: Event Loop Stepper🔄 模拟器：事件循环单步演示

Three coroutines run with asyncio.gather(). Step through and watch the ready queue, the waiting timers and the output. Time is in units (1 unit = 30 ms in the real test). The scheduling rules were checked against real asyncio on 300 random programs — press 🎲 for a new one.

तीन coroutines asyncio.gather() से चलते हैं। क़दम-दर-क़दम चलिए और ready queue, waiting timers और output देखिए। समय units में है (असली test में 1 unit = 30 ms)। Scheduling नियम 300 random programs पर असली asyncio से जाँचे गए — नए के लिए 🎲 दबाइए।

三个协程通过 asyncio.gather() 运行。一步一步观察 就绪 队列、等待中 的定时器和输出。时间以单位计（真实测试中 1 单位 = 30 毫秒）。调度规则已在 300 个随机程序上与真实的 asyncio 核对过 — 按 🎲 生成一个新程序。

Running Things Concurrently — asyncio.gather 🧺चीज़ें एक साथ चलाना — asyncio.gather 🧺并发运行 — asyncio.gather 🧺

A single await on its own gives you nothing — it just waits. The speed-up comes from running several coroutines at once with asyncio.gather().

अकेला await कुछ नहीं देता — बस इंतज़ार करता है। Speed-up asyncio.gather() से कई coroutines एक साथ चलाने से आता है।

单独一个 await 什么好处也没有 — 它只是在等待。加速来自用 asyncio.gather() 同时运行多个协程。

import asyncio, time

async def fetch(name, delay):
    print(f"-> start {name}")
    await asyncio.sleep(delay)      # simulate network
    print(f"OK done  {name}")
    return f"{name}-result"

async def sequential():
    t0 = time.perf_counter()
    a = await fetch("A", 1)         # wait for A
    b = await fetch("B", 1)         # then wait for B
    c = await fetch("C", 1)         # then wait for C
    print(f"Sequential: {time.perf_counter()-t0:.2f}s")

async def concurrent():
    t0 = time.perf_counter()
    a, b, c = await asyncio.gather(
        fetch("A", 1),
        fetch("B", 1),
        fetch("C", 1),
    )
    print(f"Concurrent: {time.perf_counter()-t0:.2f}s")
    print("results:", [a, b, c])

asyncio.run(sequential())
asyncio.run(concurrent())

🏁 Simulator: Sync vs Async Race🏁 Simulator: Sync बनाम Async Race🏁 模拟器：同步 vs 异步赛跑

Each "fetch" waits 0.5 s. Choose how many fetches to run. Top: await one after another. Bottom: asyncio.gather(). Real runs.

हर "fetch" 0.5 s इंतज़ार करता है। चुनिए कितने fetch चलें। ऊपर: एक के बाद एक await। नीचे: asyncio.gather()। असली runs।

每个"fetch"等待 0.5 秒。选择运行多少个 fetch。上面：依次 await。下面：asyncio.gather()。真实运行。

Tasks — Start Now, Collect Later 📌Tasks — अभी शुरू, बाद में लें 📌任务 — 现在启动，稍后取结果 📌

asyncio.gather() waits for a fixed set of coroutines. Sometimes you want to start a coroutine, carry on with your own work, and collect the result later. That is a Task: a coroutine wrapped and scheduled on the loop.

asyncio.gather() coroutines के एक तय समूह का इंतज़ार करता है। कभी-कभी आप एक coroutine शुरू करके अपना काम जारी रखना और result बाद में लेना चाहते हैं। यही Task है: loop पर schedule किया गया लिपटा हुआ coroutine।

asyncio.gather() 等待一组固定的协程。有时你想 启动 一个协程，继续做自己的事，稍后再取结果。这就是 Task：一个被包装并安排在事件循环上的协程。

import asyncio, time

async def slow_price_lookup(symbol):
    print("  [task] API call started")
    await asyncio.sleep(2)          # pretend this is an API call
    return {"symbol": symbol, "price": 142.35}

async def main():
    t0 = time.perf_counter()
    # Schedule the task - it starts as soon as main() reaches its next await
    task = asyncio.create_task(slow_price_lookup("AAPL"))

    # Meanwhile, do other work - this takes ~1 second
    print("doing local calculations...")
    await asyncio.sleep(1)
    print("calculations done, now waiting on API...")

    # Collect the result. Only ~1 more second of waiting (not 2!)
    result = await task
    print(f"Got: {result}")
    print(f"Total wall time: {time.perf_counter() - t0:.2f}s (not 3)")

asyncio.run(main())

Practical Example — Fetching Many URLs With aiohttp 🌐व्यावहारिक उदाहरण — aiohttp से कई URLs Fetch करना 🌐实战示例 — 用 aiohttp 获取多个 URL 🌐

This is where async shines. aiohttp is an async HTTP client — the async counterpart of requests. Five URLs that each take 1 second come back in about 1 second together.

यहीं async चमकता है। aiohttp एक async HTTP client है — requests का async साथी। पाँच URLs जो हर एक 1 second लेते हैं, साथ में लगभग 1 second में लौटते हैं।

这正是异步大放异彩的地方。aiohttp 是一个异步 HTTP 客户端 — 相当于 requests 的异步版。五个各需 1 秒的 URL，一起只需约 1 秒就能返回。

# pip install aiohttp
import asyncio, aiohttp, time

URLS = ["http://127.0.0.1:8765/delay/1"] * 5     # our local test server (no internet here)

async def fetch_url(session, url):
    async with session.get(url) as resp:
        return resp.status, len(await resp.text())

async def fetch_all(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, u) for u in urls]
        return await asyncio.gather(*tasks)

t0 = time.perf_counter()
results = asyncio.run(fetch_all(URLS))
print(f"Fetched {len(results)} URLs in {time.perf_counter()-t0:.2f}s")
for status, size in results:
    print(f"  status={status}  bytes={size}")

Timeouts and Cancellation ⏱️Timeouts और Cancellation ⏱️超时与取消 ⏱️

Network calls hang. Databases stall. You need a way to say "give up if this takes too long". asyncio.timeout() and asyncio.wait_for() do this cleanly.

Network calls अटक जाती हैं। Databases रुक जाते हैं। आपको कहने का तरीक़ा चाहिए "बहुत देर लगे तो छोड़ दो"। asyncio.timeout() और asyncio.wait_for() यह साफ़ ढंग से करते हैं।

网络调用会卡住，数据库会停滞。你需要一种方式说"太久了就放弃"。asyncio.timeout() 和 asyncio.wait_for() 可以干净地做到这一点。

import asyncio, time

async def slow_task():
    await asyncio.sleep(10)
    return "done"

async def main():
    t0 = time.perf_counter()
    # Modern style - Python 3.11+
    try:
        async with asyncio.timeout(2):
            result = await slow_task()
    except TimeoutError:
        print(f"gave up after {time.perf_counter() - t0:.1f} seconds")

    t0 = time.perf_counter()
    # Classic style - works on older versions too
    try:
        result = await asyncio.wait_for(slow_task(), timeout=2)
    except asyncio.TimeoutError:              # same class as TimeoutError since 3.11
        print(f"also gave up after {time.perf_counter() - t0:.1f} seconds")

asyncio.run(main())

Cancelling a task by handTask को हाथ से cancel करना手动取消任务

import asyncio

async def worker(n):
    try:
        while True:
            print(f"worker {n} tick")
            await asyncio.sleep(0.5)
    except asyncio.CancelledError:
        print(f"worker {n} shutting down cleanly")
        raise                        # re-raise so cancellation propagates

async def main():
    t = asyncio.create_task(worker(1))
    await asyncio.sleep(2)
    t.cancel()                       # request cancellation
    try:
        await t
    except asyncio.CancelledError:
        print("main: the task is cancelled ->", t.cancelled())

asyncio.run(main())

The worker ticked 4 times in 2 seconds, then CancelledError appeared at its await. It cleaned up and re-raised, so the task really ended — t.cancelled() is True. The Bug Doctor (Section 15) shows what happens if you swallow the error instead.

Worker ने 2 seconds में 4 बार tick किया, फिर उसके await पर CancelledError आया। उसने सफ़ाई की और फिर raise किया, इसलिए task सच में ख़त्म हुआ — t.cancelled() True है। Bug Doctor (Section 15) दिखाता है कि error निगल जाने पर क्या होता है।

工作协程在 2 秒内 tick 了 4 次，然后 CancelledError 在它的 await 处出现。它做完清理并 重新抛出，所以任务真正结束了 — t.cancelled() 为 True。Bug 医生（第 15 节）展示了如果吞掉这个错误会发生什么。

Common Pitfalls (and How to Avoid Them) 🩹आम ग़लतियाँ (और उनसे कैसे बचें) 🩹常见陷阱（以及如何避免）🩹

Real runs of three mistakesतीन ग़लतियों के असली runs三个错误的真实运行

import asyncio, time

async def ticker():
    t0 = time.perf_counter()
    for _ in range(4):
        print(f"tick at {time.perf_counter() - t0:.1f}s")
        await asyncio.sleep(0.5)

async def bad_worker():
    time.sleep(2)                    # BLOCKING sleep inside async code!

async def main():
    await asyncio.gather(ticker(), bad_worker())

asyncio.run(main())

The ticker should tick every 0.5 s. Instead there is a 2-second gap: time.sleep(2) froze the whole loop.

Ticker को हर 0.5 s पर tick करना चाहिए। इसकी जगह 2-second का gap है: time.sleep(2) ने पूरा loop जमा दिया।

ticker 本应每 0.5 秒 tick 一次。结果却出现了 2 秒的空档：time.sleep(2) 冻结了整个事件循环。

import asyncio

async def save(item):
    print("saving", item)

async def main():
    save("order-42")                 # forgot await!
    print("main finished")

asyncio.run(main())

import asyncio

async def helper():
    return 42

async def main():
    print(asyncio.run(helper()))     # asyncio.run() INSIDE a running loop

asyncio.run(main())

The fix for blocking libraries — asyncio.to_thread()Blocking libraries का इलाज — asyncio.to_thread()阻塞库的解决办法 — asyncio.to_thread()

import asyncio, time

def blocking_download():             # a normal (sync) library call
    time.sleep(1)
    return "data"

async def main():
    t0 = time.perf_counter()
    results = await asyncio.gather(
        asyncio.to_thread(blocking_download),   # runs in a worker thread
        asyncio.to_thread(blocking_download),
        asyncio.to_thread(blocking_download),
    )
    print(results, f"in {time.perf_counter() - t0:.2f}s")

asyncio.run(main())

Three blocking 1-second calls finished in about 1 second: each ran in a worker thread while the event loop stayed free.

तीन blocking 1-second calls लगभग 1 second में पूरी हुईं: हर एक worker thread में चली जबकि event loop ख़ाली रहा।

三个各阻塞 1 秒的调用约 1 秒就全部完成：每个都在工作线程中运行，而事件循环保持空闲。

🧊 Simulator: Blocking Lab🧊 Simulator: Blocking Lab🧊 模拟器：阻塞实验室

A ticker should tick every 0.25 s (hollow circles). A worker starts at 0.3 s and does 1 second of "work" in one of four ways. Filled circles are the real tick times.

एक ticker को हर 0.25 s पर tick करना चाहिए (खोखले circles)। एक worker 0.3 s पर शुरू होकर चार में से एक तरीक़े से 1 second का "काम" करता है। भरे circles असली tick समय हैं।

一个 ticker 应该每 0.25 秒 tick 一次（空心圆）。一个工作协程在 0.3 秒时开始，用四种方式之一做 1 秒的"工作"。实心圆是真实的 tick 时间。

async / await vs Threads vs Processes ⚖️async / await बनाम Threads बनाम Processes ⚖️async / await vs 线程 vs 进程 ⚖️

Threads and async/await both let one program handle many waiting jobs. They look similar from far away, but they work in very different ways. The key difference is who decides when to switch.

Threads और async/await दोनों एक program को कई इंतज़ार करते jobs संभालने देते हैं। दूर से दोनों एक जैसे दिखते हैं, पर बहुत अलग ढंग से काम करते हैं। मुख्य अंतर है switch कब करना है, यह कौन तय करता है।

线程和 async/await 都能让一个程序处理许多等待中的任务。远看相似，但工作方式截然不同。关键区别在于 由谁决定何时切换。

Same job, both waysएक ही काम, दोनों तरीकों से同一件事，两种做法

import asyncio, threading, time
from concurrent.futures import ThreadPoolExecutor

N = 100

def blocking_wait(i):                 # thread version - normal blocking code
    time.sleep(0.5)
    return threading.current_thread().name

async def async_wait(i):              # async version - must use await
    await asyncio.sleep(0.5)
    return threading.current_thread().name

t0 = time.perf_counter()
with ThreadPoolExecutor(max_workers=N) as pool:
    names = set(pool.map(blocking_wait, range(N)))
print(f"threads : {time.perf_counter() - t0:.2f}s using {len(names)} OS threads")

async def main():
    return await asyncio.gather(*(async_wait(i) for i in range(N)))

t0 = time.perf_counter()
names = set(asyncio.run(main()))
print(f"asyncio : {time.perf_counter() - t0:.2f}s using {len(names)} thread: {names.pop()}")

Both finish in about half a second — for 100 waiting jobs they are equally fast. The difference is the cost: 100 OS threads versus one thread running 100 small tasks. The lab below raises the number.

दोनों लगभग आधे सेकंड में पूरे होते हैं — 100 इंतज़ार करते jobs के लिए दोनों बराबर तेज़ हैं। अंतर लागत में है: 100 OS threads बनाम एक thread जो 100 छोटे tasks चलाता है। नीचे का lab संख्या बढ़ाता है।

两者都在约半秒内完成 — 对于 100 个等待任务，它们一样快。区别在于开销：100 个操作系统线程，对比一个线程运行 100 个小任务。下面的实验室会增大数量。

📈 Simulator: Threads vs asyncio at Scale📈 Simulator: बड़े पैमाने पर Threads बनाम asyncio📈 模拟器：大规模下的线程 vs asyncio

Shared data — where switches can hurtसाझा data — जहाँ switch नुक़सान कर सकता है共享数据 — 切换可能造成伤害的地方

Each worker reads counter, then writes counter + 1. If another worker runs between the read and the write, an update is lost. Threads can be switched there at any time. A task can only be switched there if you put an await there.

हर worker counter पढ़ता है, फिर counter + 1 लिखता है। अगर पढ़ने और लिखने के बीच कोई दूसरा worker चल जाए, तो एक update खो जाता है। Threads वहाँ कभी भी switch हो सकते हैं। Task वहाँ तभी switch हो सकता है जब आप वहाँ await रखें।

每个 worker 先读取 counter，再写入 counter + 1。如果在读和写之间另一个 worker 运行了，就会丢失一次更新。线程随时可能在那里被切换。而任务只有在你在那里放了 await 时才会被切换。

import asyncio, threading, time

def run_threads():
    global counter
    counter = 0
    def add():
        global counter
        for _ in range(1000):
            v = counter            # read
            time.sleep(0)          # the OS may switch threads here (or anywhere)
            counter = v + 1        # write
    ts = [threading.Thread(target=add) for _ in range(4)]
    for t in ts: t.start()
    for t in ts: t.join()
    return counter

async def add_no_await():
    global counter
    for _ in range(1000):
        v = counter
        counter = v + 1            # no await between read and write

async def add_with_await():
    global counter
    for _ in range(1000):
        v = counter
        await asyncio.sleep(0)     # a pause point between read and write!
        counter = v + 1

async def run_tasks(fn):
    global counter
    counter = 0
    await asyncio.gather(*(fn() for _ in range(4)))
    return counter

print("expected            :", 4 * 1000)
print("4 threads           :", run_threads())
print("4 tasks, no await   :", asyncio.run(run_tasks(add_no_await)))
print("4 tasks, with await :", asyncio.run(run_tasks(add_with_await)))

🧮 Simulator: Lost Update Lab🧮 Simulator: Lost Update Lab🧮 模拟器：丢失更新实验室

Stopping work earlyकाम जल्दी रोकना提前停止工作

import asyncio, threading, time

async def worker():
    try:
        await asyncio.sleep(10)
    except asyncio.CancelledError:
        print("task: cancelled at its await - cleaning up")
        raise

async def main():
    t = asyncio.create_task(worker())
    await asyncio.sleep(0.1)
    t.cancel()                                 # tasks can be cancelled
    try:
        await t
    except asyncio.CancelledError:
        print("task cancelled after 0.1 s")

asyncio.run(main())

th = threading.Thread(target=time.sleep, args=(1,))
th.start()
print("thread has .cancel()? ", hasattr(th, "cancel"))   # no way to stop it
t0 = time.perf_counter(); th.join()
print(f"had to wait {time.perf_counter() - t0:.1f}s for the thread to finish")

A task can be cancelled: the CancelledError appears at its await, so it can clean up. A thread has no cancel method — you must build your own stop signal (like an Event) or wait for it to finish.

Task को cancel किया जा सकता है: CancelledError उसके await पर आता है, ताकि वह सफ़ाई कर सके। Thread में कोई cancel method नहीं है — आपको अपना stop signal (जैसे Event) बनाना होगा या उसके पूरा होने का इंतज़ार करना होगा।

任务可以被取消：CancelledError 会在它的 await 处出现，因此它能做清理。线程没有 cancel 方法 — 你必须自己做停止信号（例如 Event），或者等它结束。

All three side by sideतीनों साथ-साथ三者并列比较

Real-World Example — Weather Dashboard Aggregator 🌦️असली उदाहरण — Weather Dashboard Aggregator 🌦️实战示例 — 天气看板聚合器 🌦️

Fetch the current weather for 5 cities at the same time, handle failures, apply a timeout, and print a summary. (Our local server answers like Open-Meteo, with fixed test values and slightly different delays per city.)

5 शहरों का मौजूदा मौसम एक साथ fetch कीजिए, failures संभालिए, timeout लगाइए, और summary print कीजिए। (हमारा local server Open-Meteo की तरह जवाब देता है, तय test values और हर शहर के लिए थोड़ी अलग देरी के साथ।)

同时获取 5 个城市的当前天气，处理失败，设置超时，并打印摘要。（我们的本地服务器以 Open-Meteo 的格式应答，返回固定的测试值，每个城市的延迟略有不同。）

import asyncio, aiohttp, time

CITIES = [
    ("Mumbai",     19.0760, 72.8777),
    ("New York",   40.7128, -74.0060),
    ("London",     51.5074, -0.1278),
    ("Tokyo",      35.6762, 139.6503),
    ("Sydney",    -33.8688, 151.2093),
]
API = "http://127.0.0.1:8765/v1/forecast"   # local stand-in for api.open-meteo.com

async def fetch_weather(session, city, lat, lon):
    params = {"latitude": lat, "longitude": lon, "current_weather": "true"}
    try:
        async with asyncio.timeout(5):
            async with session.get(API, params=params) as r:
                r.raise_for_status()
                data = await r.json()
                cw = data["current_weather"]
                return city, cw["temperature"], cw["windspeed"], None
    except Exception as e:
        return city, None, None, repr(e)

async def main():
    t0 = time.perf_counter()
    async with aiohttp.ClientSession() as session:
        results = await asyncio.gather(
            *[fetch_weather(session, c, lat, lon) for c, lat, lon in CITIES]
        )
    print(f"\nWeather report - fetched in {time.perf_counter()-t0:.2f}s")
    print("-" * 50)
    for city, temp, wind, err in results:
        if err:
            print(f"{city:12s}  ERROR: {err}")
        else:
            print(f"{city:12s}  {temp:5.1f}°C   wind {wind:.1f} km/h")

asyncio.run(main())

Limiting Concurrency — Don't Overload Your Own API 🚦Concurrency सीमित करना — अपनी ही API पर बोझ मत डालिए 🚦限制并发 — 别把自己的 API 压垮 🚦

Firing 10,000 requests at once is easy in async — and a quick way to get rate-limited or crash the server. Use asyncio.Semaphore to cap how many run at the same time. (We used 200 URLs against our local server.)

Async में 10,000 requests एक साथ भेजना आसान है — और rate-limit होने या server crash करने का तेज़ तरीक़ा भी। एक साथ कितने चलें, इसकी सीमा asyncio.Semaphore से लगाइए। (हमने अपने local server पर 200 URLs लिए।)

在异步中一次发出 10,000 个请求很容易 — 这也是被限流或压垮服务器的捷径。用 asyncio.Semaphore 限制同时运行的数量。（我们对本地服务器使用了 200 个 URL。）

import asyncio, aiohttp, time

in_flight = peak = 0

async def fetch_one(sem, session, url):
    global in_flight, peak
    async with sem:                          # at most N in flight
        in_flight += 1; peak = max(peak, in_flight)
        async with session.get(url) as r:
            text = await r.text()
        in_flight -= 1
        return text

async def fetch_many(urls, max_concurrent=10):
    sem = asyncio.Semaphore(max_concurrent)
    async with aiohttp.ClientSession() as session:
        return await asyncio.gather(
            *[fetch_one(sem, session, u) for u in urls]
        )

urls = [f"http://127.0.0.1:8765/anything/{i}" for i in range(200)]   # each takes ~0.05 s
t0 = time.perf_counter()
results = asyncio.run(fetch_many(urls, max_concurrent=20))
print(f"{len(results)} responses in {time.perf_counter() - t0:.2f}s, "
      f"never more than {peak} in flight")

We added a small counter to prove the limit: never more than 20 requests were in flight. 200 requests × 0.05 s, 20 at a time → about 10 rounds → about 0.5 s.

हमने सीमा साबित करने के लिए एक छोटा counter जोड़ा: एक साथ कभी 20 से ज़्यादा requests नहीं चलीं। 200 requests × 0.05 s, एक बार में 20 → लगभग 10 rounds → लगभग 0.5 s।

我们加了一个小计数器来 证明 这个限制：同时在途的请求从未超过 20 个。200 个请求 × 0.05 秒，每次 20 个 → 约 10 轮 → 约 0.5 秒。

🚦 Simulator: Semaphore Lab🚦 Simulator: Semaphore Lab🚦 模拟器：信号量实验室

12 jobs of 0.3 s each, with different limits. Each row is one "slot" of the semaphore. Real runs.

हर एक 0.3 s के 12 jobs, अलग-अलग सीमाओं के साथ। हर row semaphore का एक "slot" है। असली runs।

12 个各 0.3 秒的任务，设置不同的限制。每一行是信号量的一个"名额"。真实运行。

When to Use async / await 🧭async / await कब लें 🧭何时使用 async / await 🧭

Modern Pattern — asyncio.TaskGroup (Python 3.11+) 🧩आधुनिक Pattern — asyncio.TaskGroup (Python 3.11+) 🧩现代模式 — asyncio.TaskGroup（Python 3.11+）🧩

TaskGroup is the recommended choice when you want clean error handling: if any child task fails, the group cancels the tasks that are still running and raises the errors together as an ExceptionGroup.

जब आपको साफ़ error handling चाहिए, TaskGroup सुझाया गया विकल्प है: अगर कोई child task fail होता है, तो group अब भी चल रहे tasks को cancel करता है और errors को एक साथ ExceptionGroup के रूप में raise करता है।

当你需要干净的错误处理时，推荐使用 TaskGroup：只要有任何子任务失败，这个组就会取消 仍在运行 的任务，并把错误合并成一个 ExceptionGroup 抛出。

import asyncio, time

T0 = time.perf_counter()
def now(): return f"[{time.perf_counter() - T0:.1f}s]"

async def work(name, delay, fail=False):
    try:
        await asyncio.sleep(delay)
        if fail:
            raise RuntimeError(f"{name} exploded")
        print(now(), f"{name} finished ok")
        return f"{name} ok"
    except asyncio.CancelledError:
        print(now(), f"{name} was cancelled")
        raise

async def main():
    try:
        async with asyncio.TaskGroup() as tg:
            t1 = tg.create_task(work("A", 1))
            t2 = tg.create_task(work("B", 2, fail=True))
            t3 = tg.create_task(work("C", 3))
    except* RuntimeError as eg:              # exception-group syntax
        for e in eg.exceptions:
            print(now(), f"caught: {e}")
    print("A:", t1.result(), "| C cancelled?", t3.cancelled())

asyncio.run(main())

💥 Simulator: Failure Lab💥 Simulator: Failure Lab💥 模拟器：失败实验室

A finishes at 1 s, B fails at 2 s, C would finish at 3 s. What happens to the others? Three real runs. (main then waits 1.5 s more so you can see what keeps running.)

A 1 s पर ख़त्म होता है, B 2 s पर fail होता है, C 3 s पर ख़त्म होता। बाक़ियों का क्या होता है? तीन असली runs। (main फिर 1.5 s और रुकता है ताकि आप देख सकें कि क्या चलता रहता है।)

A 在 1 秒完成，B 在 2 秒失败，C 本应在 3 秒完成。其他任务会怎样？三次真实运行。（之后 main 再等 1.5 秒，让你看到哪些任务还在继续运行。）

Bug Doctor, Golden Rules and Quiz 🏆Bug Doctor, सुनहरे नियम और Quiz 🏆Bug 医生、黄金法则与小测验 🏆

🩺 Simulator: Bug Doctor🩺 Simulator: Bug Doctor🩺 模拟器：Bug 医生

Six real async mistakes. Buggy code on the left, fixed code on the right, changed lines marked. Every output is from a real run (programs that hang were stopped after 4 seconds).

छह असली async ग़लतियाँ। बाईं ओर buggy code, दाईं ओर ठीक किया हुआ, बदली lines चिह्नित। हर output असली run से है (अटकने वाले programs 4 seconds बाद रोके गए)।

六个真实的异步错误。左边是有 bug 的代码，右边是修正后的代码，改动的行已标出。每个输出都来自真实运行（会挂起的程序在 4 秒后被停止）。

Quick Quiz — 8 Questionsछोटा Quiz — 8 सवाल小测验 — 8 道题