2025年5月31日 星期六

Python 非同步程式設計入門:async/await 與 asyncio 基本教學

隨著網路應用與 I/O 密集型工作越來越普遍,Python 的非同步程式設計變得非常重要。本篇文章將帶你了解 Python 中 async / await 的用法,並介紹 asyncio 模組的基本概念與範例。

什麼是非同步程式設計?

非同步程式設計讓你能夠在等待 I/O(像是網路請求、檔案讀寫)時,不會阻塞整個程式,而是把時間留給其他工作繼續執行,提高效率。

Python 的 async 與 await

  • async def:定義非同步函式(協程 coroutine)
  • await:等待一個協程或非同步任務完成

範例:定義與呼叫非同步函式

import asyncio

async def say_hello():
    print("Hello")
    await asyncio.sleep(1)  # 非同步等待 1 秒
    print("World")

asyncio.run(say_hello())

asyncio 模組簡介

Python 的 asyncio 是標準庫裡負責非同步事件循環的模組,主要用來調度與執行多個協程。

同時執行多個協程:asyncio.gather()

import asyncio

async def task(id, delay):
    print(f"Task {id} 開始")
    await asyncio.sleep(delay)
    print(f"Task {id} 結束")
    return id * 10

async def main():
    results = await asyncio.gather(
        task(1, 2),
        task(2, 1),
        task(3, 3),
    )
    print("結果:", results)

asyncio.run(main())

控制非同步併發數量(類似 ThreadPoolExecutor)

當你有一個參數列表,想非同步呼叫很多工作,但想限制同時執行的任務數量(例如同時最多 3 個),可以用 asyncio.Semaphore 來做到。

import asyncio

async def worker(sem, param):
    async with sem:  # 申請 Semaphore,限制同時併發數
        print(f"開始處理 {param}")
        await asyncio.sleep(2)  # 模擬 I/O 工作
        print(f"完成處理 {param}")

async def main(params):
    sem = asyncio.Semaphore(3)  # 同時最多允許3個併發
    tasks = [asyncio.create_task(worker(sem, p)) for p in params]
    await asyncio.gather(*tasks)

params = list(range(10))
asyncio.run(main(params))

這樣即使建立了 10 個任務,也會同時最多執行 3 個,避免過度佔用資源。


錯誤處理

非同步函式裡也可以用 try/except 捕捉例外,錯誤會往上拋,讓你能集中處理。

async def might_fail():
    await asyncio.sleep(1)
    raise ValueError("出錯了!")

async def main():
    try:
        await might_fail()
    except ValueError as e:
        print("捕捉到錯誤:", e)

asyncio.run(main())

非同步 vs 同步的比較

面向 同步 非同步
執行模式 逐步等待完成 可同時等待多個任務
資源使用 可能阻塞,浪費等待時間 更有效率,充分利用等待時間
程式設計 直觀,但對I/O不友好 需設計非同步流程,較複雜

小結

  • 使用 async defawait 寫非同步函式
  • 利用 asyncio.run() 啟動事件循環
  • asyncio.gather() 可以同時跑多個協程
  • asyncio.Semaphore 控制同時執行數量,避免過度佔用資源
  • try/except 做非同步錯誤處理
  • 非同步適合 I/O 密集、等待較長的場景

如果你想了解更進階的非同步網路程式設計(如 aiohttp)、資料庫非同步操作,或事件循環底層運作,歡迎留言討論!

Promise.then() vs async/await:該怎麼選擇?

在撰寫 JavaScript 的非同步程式時,我們通常有兩種主流方式來處理 Promise 的結果:

  • 使用 .then() 搭配 .catch()
  • 使用 async/await 搭配 try/catch

那麼問題來了:
當你要拿一個 Promise 的結果做後續處理時,該用哪一種方式?

這篇文章會帶你比較兩者的差異、優缺點,並給出實務上的建議。

🔁 基本寫法比較

使用 .then()

fetchData()
  .then(data => {
    console.log("資料取得成功:", data);
  })
  .catch(err => {
    console.error("發生錯誤:", err);
  });

使用 await

async function main() {
  try {
    const data = await fetchData();
    console.log("資料取得成功:", data);
  } catch (err) {
    console.error("發生錯誤:", err);
  }
}
main();

✅ 各自的優缺點

項目 .then() async/await
可讀性 多層 .then() 可能會變難讀 結構接近同步邏輯,可讀性高
錯誤處理 使用 .catch() 可使用 try/catch 處理錯誤
控制流程 條件判斷或迴圈處理不直觀 iffor 等控制流可自然搭配使用
使用場景 非 async 環境(如模組頂層)適用 必須在 async 函式中使用
串接多個任務 .then().then().then() 較直覺 多個 await 也清楚,但需搭配邏輯

🧠 多段傳遞差異

.then() 支援連鎖傳值

Promise.resolve(2)
  .then(x => x * 3)        // 傳遞 6
  .then(y => y + 1)        // 傳遞 7
  .then(z => console.log(z)); // 印出 7

await 要自己手動接收變數

async function run() {
  const x = await Promise.resolve(2);
  const y = x * 3;
  const z = y + 1;
  console.log(z); // 印出 7
}

⚠️ 注意:.catch() 後還能繼續 .then()

你可能會以為錯誤後整個鏈就中止了,其實不是:

doSomething()
  .catch(err => {
    console.warn("錯誤被攔截:", err);
    return "預設值";
  })
  .then(result => {
    console.log("後續繼續執行:", result); // 收到預設值
  });

.catch() 沒有拋出新的錯誤,Promise 鏈會繼續執行後面的 .then()

🎯 什麼情況用哪一個?

建議使用 async/await:

  • 寫長流程邏輯時(可讀性更高)
  • 有多個非同步步驟需依序處理
  • 錯誤處理邏輯較複雜

建議使用 .then():

  • 在模組頂層(不方便加 async
  • 想快速串接簡單處理流程
  • 喜歡函式式風格或鏈式操作

✅ 結論

無論使用 .then() 還是 async/await,它們本質上都在操作 Promise。

  • .then() 更像函數式管線
  • await 更像同步的控制流
  • .catch() 可以中斷 .then() 鏈,也可以處理錯誤後繼續執行
  • .finally() 可以寫多個,做收尾工作

建議平時盡量用 async/await 搭配 try/catch
除非你的環境或需求更適合 .then() 鏈式處理。

如果你想要更深入的示範(例如多個非同步任務併發、錯誤復原機制、top-level await 實務寫法),也歡迎留言或關注後續文章。