FastAPI Backend Development Bootcamp · 课时

FastAPI 与异步操作

理解 FastAPI 如何自然地处理异步函数，以及如何编写高效的非阻塞代码。

FastAPI 与异步操作 是 CoddyKit 上的免费 FastAPI Backend Development Bootcamp 课时。这是第 2 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 FastAPI Backend Development Bootcamp 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 FastAPI Backend Development Bootcamp 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

FastAPI's Async Foundation

FastAPI is built for speed! It leverages Python's asynchronous features to handle many requests concurrently, especially I/O-bound tasks.

This means your API can stay responsive even when waiting for external resources like databases or other APIs.

Sync vs. Async Endpoints

In FastAPI, you can define two main types of endpoint functions:

Synchronous (def): These functions block the event loop while they run. If one request takes long, others might wait.
Asynchronous (async def): These functions can 'pause' and let other tasks run while they await an operation (like reading from a database), making your API non-blocking.

Simple Synchronous Endpoint

Here's a standard synchronous endpoint. While simple, if time.sleep() were a real, slow database call, it would block other requests until it completes.

Try running it and observe the delay if you try to make multiple requests quickly.

from fastapi import FastAPI
import uvicorn
import time

app = FastAPI()

@app.get("/sync_hello")
def sync_hello():
    time.sleep(2) # Simulate a blocking I/O operation
    return {"message": "Hello from sync endpoint!"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Defining Asynchronous Endpoints

To make your endpoint non-blocking, use async def. This tells FastAPI (and Python) that this function can be suspended and resumed.

Inside an async def function, you use the await keyword to wait for other asynchronous operations to complete without blocking the entire application.

Your First Async Endpoint

This example uses asyncio.sleep(), which is an asynchronous sleep function. Notice the await keyword before it.

This allows FastAPI to handle other requests while this one 'sleeps', making the server more responsive.

from fastapi import FastAPI
import uvicorn
import asyncio

app = FastAPI()

@app.get("/async_hello")
async def async_hello():
    await asyncio.sleep(2) # Simulate non-blocking I/O
    return {"message": "Hello from async endpoint!"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

When to Go Async

async def shines for I/O-bound operations. These are tasks that spend most of their time waiting for something else to happen, such as:

Making requests to external APIs (e.g., httpx).
Querying a database (e.g., asyncpg, SQLModel).
Reading/writing files from disk.
Network communication.

For CPU-bound tasks (heavy calculations), async def doesn't speed up the task itself, but it can help keep the server responsive.

Interacting with Async Libraries

When your FastAPI async def endpoint needs to interact with another asynchronous library (like an async HTTP client or an async database driver), you must use await.

Failing to use await will result in the awaitable object being returned directly, not its resolved result, which is usually not what you want!

Conceptual Async API Call

Imagine fetching data from another service. An async HTTP client allows this without blocking. Here's how it conceptually looks within an async def endpoint:

We simulate network latency with asyncio.sleep to show the non-blocking nature.

from fastapi import FastAPI
import uvicorn
import asyncio

app = FastAPI()

@app.get("/fetch_data")
async def fetch_external_data():
    # In a real app, you'd use an async HTTP client like 'httpx'
    # async with httpx.AsyncClient() as client:
    #     response = await client.get("https://api.example.com/data")
    #     data = response.json()

    await asyncio.sleep(1) # Simulate network latency
    return {"data": "Fetched async data!"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Uvicorn: The Async Engine

FastAPI relies on an ASGI server like Uvicorn. Uvicorn is what actually runs your async def functions efficiently.

It manages the Python event loop, which orchestrates when different asynchronous tasks get to run.
When an await is encountered, Uvicorn can switch to another ready task, making your API highly concurrent.

This 'context switching' is what allows FastAPI to handle many requests without waiting for each one to finish entirely.

Quick Check: Async Use

You are building a FastAPI endpoint that needs to fetch data from a slow external API (an I/O-bound task). Which of the following is the best way to define this endpoint to ensure your FastAPI application remains responsive?

Recap: Async FastAPI

We've explored how FastAPI harnesses Python's asynchronous features:

Use async def for endpoint functions that perform I/O-bound operations.
Use await when calling other asynchronous functions or libraries within an async def.
This non-blocking approach, powered by Uvicorn and the event loop, allows your FastAPI application to handle many concurrent requests efficiently, leading to highly responsive APIs.

Next, we'll look at how to offload truly long-running or CPU-bound tasks to background processes!

常见问题解答

「FastAPI 与异步操作」课时是免费的吗？

是的 — 「FastAPI 与异步操作」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 FastAPI Backend Development Bootcamp 课程的其余内容，请升级到 CoddyKit PRO。 FastAPI Backend Development Bootcamp 课程共包含 4 节课。

「FastAPI 与异步操作」这节课中我会学到什么？

理解 FastAPI 如何自然地处理异步函数，以及如何编写高效的非阻塞代码。你通过在浏览器中直接运行的动手代码来练习 FastAPI Backend Development Bootcamp，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 FastAPI Backend Development Bootcamp 需要有经验吗？

无需任何先前经验。CoddyKit 上的 FastAPI Backend Development Bootcamp 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 2 节课，共 4 节。

「FastAPI 与异步操作」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 FastAPI Backend Development Bootcamp 课中编写并运行代码吗？

能。每节 FastAPI Backend Development Bootcamp 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 FastAPI Backend Development Bootcamp