Python 的 asyncio 函式庫提供了一種優雅且高效的方式來處理非同步操作，尤其適用於 I/O 密集型任務，例如網路程式設計。asyncio 的核心概念是協程和事件迴圈。協程是一種特殊的函式，可以暫停執行並允許其他協程執行，而事件迴圈則負責協調和排程這些協程的執行。透過使用 async 和 await 關鍵字，我們可以定義和執行協程，並利用 asyncio.sleep 模擬 I/O 操作的延遲。asyncio.gather 函式則允許我們並發執行多個協程，提高程式效率。除了基本的協程操作，asyncio 還支援更進階的應用，例如建立非同步網路伺服器，處理大量並發連線。
使用 Python 的 asyncio 實作非同步程式設計
在上一節中，我們討論了使用 select 函式實作事件驅動程式設計的基本概念。現在，我們將深入探討 Python 3 中的 asyncio 模組，該模組提供了一個更高階別的抽象層，用於實作非同步程式設計。
什麼是 asyncio？
asyncio 是 Python 3.5 中引入的一個新模組，旨在提供一個簡單且高效的方式來實作非同步程式設計。它的核心概念是事件迴圈（event loop），該迴圈負責管理和排程不同任務（task）的執行。
如何使用 asyncio？
要使用 asyncio，您需要建立一個事件迴圈（event loop）例項，並將其註冊到您的應用程式中。然後，您可以定義協程（coroutine），它是一種特殊的函式，可以將控制權交回給事件迴圈，以便其他任務可以執行。
以下是使用 asyncio 實作一個簡單的 “Hello World” 協程的示例：
import asyncio
async def hello_world():
print("hello world!")
return 42
hello_world_coroutine = hello_world()
print(hello_world_coroutine)
event_loop = asyncio.get_event_loop()
try:
print("entering event loop")
result = event_loop.run_until_complete(hello_world_coroutine)
print(result)
finally:
event_loop.close()
在這個示例中，我們定義了一個名為 hello_world 的協程，它只是列印 “hello world!” 並傳回 42。然後，我們建立了一個事件迴圈例項，並使用 run_until_complete 方法執行協程，直到它完成。
協程和生成器
協程和生成器之間有著密切的關係。事實上，協程可以被視為是一種特殊的生成器，它可以將控制權交回給事件迴圈。這使得事件迴圈可以繼續執行，而不需要等待協程完成。
以下是使用生成器實作一個簡單的 “Hello World” 函式的示例：
def hello_world():
print("hello world!")
yield
print("goodbye world!")
hello_world_generator = hello_world()
next(hello_world_generator) # prints "hello world!"
next(hello_world_generator) # prints "goodbye world!"
在這個示例中，我們定義了一個名為 hello_world 的生成器，它列印 “hello world!"，然後產生一個值，最後列印 “goodbye world!"。我們可以使用 next 函式來執行生成器，直到它完成。
內容解密：
asyncio是 Python 3.5 中引入的一個新模組，旨在提供一個簡單且高效的方式來實作非同步程式設計。- 協程是一種特殊的函式，可以將控制權交回給事件迴圈，以便其他任務可以執行。
- 生成器是一種特殊的函式，可以產生多個值。
run_until_complete方法用於執行協程，直到它完成。async和await關鍵字用於定義協程。asyncio.gather函式用於執行多個協程。
圖表翻譯：
graph LR
A[事件迴圈] -->|建立|> B[協程]
B -->|執行|> C[任務]
C -->|完成|> D[結果]
D -->|傳回|> A
這個圖表展示了事件迴圈、協程、任務和結果之間的關係。事件迴圈建立協程，協程執行任務，任務完成後傳回結果，結果傳回給事件迴圈。
非同步程式設計與協程
非同步程式設計是一種允許程式在執行時可以暫停和還原的方法，從而可以提高程式的效率和反應速度。Python 的 asyncio 模組提供了一種實作非同步程式設計的方法，使用協程（coroutine）來管理非同步任務。
協程的定義
協程是一種特殊的函式，使用 async def 關鍵字定義。協程可以暫停和還原執行，允許其他協程在其間執行。這使得協程可以合作，實作複雜的非同步任務。
協程的執行
協程的執行需要一個事件迴圈（event loop）。事件迴圈負責管理協程的執行，當一個協程暫停時，事件迴圈會將控制權轉交給另一個協程。當一個協程完成時，事件迴圈會將結果傳回給呼叫者。
範例：Hello World 協程
以下是一個簡單的 Hello World 協程範例：
import asyncio
async def hello_world():
print("hello world!")
return 42
async def main():
result = await hello_world()
print(result)
asyncio.run(main())
在這個範例中，hello_world 協程列印 “hello world!” 並傳回 42。main 協程呼叫 hello_world 協程並列印結果。
協程之間的合作
協程可以合作，實作複雜的非同步任務。以下是一個範例：
import asyncio
async def add_42(number):
print("Adding 42")
return 42 + number
async def hello_world():
print("hello world!")
result = await add_42(23)
print(result)
async def main():
await hello_world()
asyncio.run(main())
在這個範例中，hello_world 協程呼叫 add_42 協程並等待結果。add_42 協程傳回結果後，hello_world 協程列印結果。
內容解密：
在上述範例中，我們使用 async def 關鍵字定義協程。協程可以使用 await 關鍵字等待另一個協程的結果。事件迴圈負責管理協程的執行，當一個協程暫停時，事件迴圈會將控制權轉交給另一個協程。
圖表翻譯：
flowchart TD
A[hello_world] --> B[add_42]
B --> C[result]
C --> D[print result]
在這個圖表中，我們展示了 hello_world 協程呼叫 add_42 協程並等待結果的過程。add_42 協程傳回結果後，hello_world 協程列印結果。
使用 Python 的 asyncio 實作協程並發
Python 的 asyncio 模組提供了一種實作協程並發的方法。協程（Coroutine）是一種特殊的函式，可以在執行過程中暫停和還原，允許其他協程執行。
基本概念
- 協程（Coroutine）：是一種特殊的函式，可以在執行過程中暫停和還原。
- 事件迴圈（Event Loop）：是一種機制，負責排程和執行協程。
- await：是一個關鍵字，用於暫停協程的執行，並將控制權交給事件迴圈。
示例 1：基本協程
import asyncio
async def hello_world():
print("hello world!")
await asyncio.sleep(1) # 暫停 1 秒
print("hello world! (after sleep)")
event_loop = asyncio.get_event_loop()
try:
result = event_loop.run_until_complete(hello_world())
finally:
event_loop.close()
在這個示例中，hello_world 是一個協程，使用 async def 定義。協程內使用 await 暫停執行，並將控制權交給事件迴圈。
示例 2：多協程並發
import asyncio
async def hello_world():
print("hello world!")
await asyncio.sleep(1) # 暫停 1 秒
print("hello world! (after sleep)")
async def hello_python():
print("hello Python!")
await asyncio.sleep(0.1) # 暫停 0.1 秒
print("hello Python! (after sleep)")
event_loop = asyncio.get_event_loop()
try:
result = event_loop.run_until_complete(asyncio.gather(
hello_world(),
hello_python()
))
finally:
event_loop.close()
在這個示例中，使用 asyncio.gather 函式同時執行多個協程。asyncio.gather 函式允許等待多個協程完成，並傳回結果。
示例 3：使用 asyncio.sleep 和 asyncio.gather
import asyncio
async def task1():
print("Task 1 started")
await asyncio.sleep(1) # 暫停 1 秒
print("Task 1 finished")
async def task2():
print("Task 2 started")
await asyncio.sleep(0.5) # 暫停 0.5 秒
print("Task 2 finished")
async def main():
await asyncio.gather(
task1(),
task2()
)
event_loop = asyncio.get_event_loop()
try:
result = event_loop.run_until_complete(main())
finally:
event_loop.close()
在這個示例中，使用 asyncio.sleep 函式暫停協程的執行，並使用 asyncio.gather 函式同時執行多個協程。
使用 asyncio 實作非同步程式設計
非同步程式設計是一種可以提高程式效率的技術，尤其是在需要等待 I/O 操作的情況下。Python 的 asyncio 函式庫提供了一種簡單的方式來實作非同步程式設計。
例子 1：使用 asyncio.sleep 和 asyncio.gather
在這個例子中，我們定義了兩個協程：hello_world 和 hello_python。這兩個協程都使用 asyncio.sleep 來暫停執行一段時間。然後，我們使用 asyncio.gather 來同時執行這兩個協程。
import asyncio
async def hello_world():
print("Hello world!")
await asyncio.sleep(0.1)
print("Hello world! (after sleep)")
async def hello_python():
print("Hello Python!")
await asyncio.sleep(0.1)
print("Hello Python! (after sleep)")
loop = asyncio.get_event_loop()
results = loop.run_until_complete(asyncio.gather(hello_world(), hello_python()))
例子 2：使用 aiohttp
在這個例子中，我們使用 aiohttp 來傳送 HTTP 請求。aiohttp 是一個非同步的 HTTP 客戶端函式庫，可以用來傳送 HTTP 請求。
import aiohttp
import asyncio
async def get(url):
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
return response
loop = asyncio.get_event_loop()
results = loop.run_until_complete(asyncio.gather(get("http://example.com"), get("http://example.org")))
print("Results: %s" % results)
使用 loop.call_later
asyncio 也提供了一種方式來呼叫函式在未來的某個時間點。可以使用 call_later 和 call_at 方法來呼叫函式在相對或絕對未來的時間點。
import asyncio
def hello_world():
print("Hello world!")
loop = asyncio.get_event_loop()
loop.call_later(1, hello_world)
圖表翻譯：
flowchart TD
A[開始] --> B[定義協程]
B --> C[使用 asyncio.sleep]
C --> D[使用 asyncio.gather]
D --> E[執行協程]
E --> F[等待 I/O 操作]
F --> G[繼續執行協程]
G --> H[結束]
內容解密：
在這些例子中，我們使用 asyncio 來實作非同步程式設計。asyncio 提供了一種簡單的方式來定義協程和執行協程。可以使用 asyncio.sleep 來暫停執行一段時間，然後使用 asyncio.gather 來同時執行多個協程。另外，aiohttp 是一個非同步的 HTTP 客戶端函式庫，可以用來傳送 HTTP 請求。最後，asyncio 也提供了一種方式來呼叫函式在未來的某個時間點，可以使用 call_later 和 call_at 方法來呼叫函式在相對或絕對未來的時間點。
使用 Python 的 asyncio 實作非同步網路伺服器
Python 的 asyncio 是一個用於寫入非同步程式碼的函式庫，尤其適合處理網路相關任務。它可以輕鬆地處理數千個並發的網路連線，提高程式的效率和可擴充套件性。
從底層實作到高階應用的全面檢視顯示，Python 的 asyncio 模組提供了一個強大且靈活的框架，以簡化非同步程式設計的複雜性。透過協程、事件迴圈和非同步 I/O 操作的巧妙結合，asyncio 能有效提升網路應用程式的效能和反應速度。然而，在實務應用中，開發者仍需仔細考量任務粒度、錯誤處理和資源管理等議題，才能充分發揮 asyncio 的優勢。對於追求高效能和高並發的網路服務而言，深入理解 asyncio 的運作機制並搭配合適的設計模式至關重要。玄貓認為，asyncio 已成為現代 Python 網路程式設計的根本，值得所有 Python 開發者深入學習和掌握。隨著 Python 生態系統的持續發展，預見 asyncio 將在更多應用場景中扮演關鍵角色，並持續推動非同步程式設計的演進。
