FastAPI个人入门学习

快速入门

1. 安装 FastAPI 和 Uvicorn

首先，你需要安装 FastAPI 和一个 ASGI 服务器，例如 Uvicorn：

pip install fastapi uvicorn

1. 创建一个简单的 FastAPI 应用

创建一个文件 main.py，内容如下：

from fastapi import FastAPI
app = FastAPI()

@app.get("/")def read_root():return {"Hello": "World"}

@app.get("/items/{item_id}")def read_item(item_id: int, q: str = None):return {"item_id": item_id, "q": q}

1. 运行 FastAPI 应用

使用 Uvicorn 运行这个应用：

uvicorn main:app --reload

• main 是指 main.py 文件（不需要 .py 后缀）。
• app 是指在 main.py 文件中创建的 FastAPI 实例。
• --reload 使服务器在代码更改时自动重新启动，仅用于开发环境。

1. 访问 API

打开浏览器，访问 http://127.0.0.1:8000，你应该会看到：

{"Hello": "World"}

访问 http://127.0.0.1:8000/items/5?q=somequery，你应该会看到：

json
复制代码
{"item_id": 5, "q": "somequery"}

1. 自动生成文档

FastAPI 会自动生成 API 文档。你可以访问以下两个 URL：

• Swagger UI: http://127.0.0.1:8000/docs
• ReDoc: http://127.0.0.1:8000/redoc

1. 增加更多功能

路由和请求体

你可以使用 POST 请求并接受 JSON 请求体：

from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None@app.post("/items/")def create_item(item: Item):return item

运行和测试

重新运行应用，然后你可以通过以下命令进行测试：

uvicorn main:app --reload

使用工具（如 Postman）或命令行（如 curl）发送 POST 请求：

curl -X 'POST' \'http://127.0.0.1:8000/items/' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "name": "Item Name",
  "description": "Item Description",
  "price": 10.5,
  "tax": 0.5
}'

你将收到与请求体相同的响应：

{"name": "Item Name","description": "Item Description","price": 10.5,"tax": 0.5}

1. 部署应用

在本地开发完成后，你可以将 FastAPI 应用部署到生产环境。推荐使用 Docker 来容器化你的应用，并使用 Gunicorn 作为生产服务器。

Dockerfile 示例

创建一个 Dockerfile：

FROM tiangolo/uvicorn-gunicorn-fastapi:python3.8

COPY ./app /app

# 如果需要安装额外的依赖，可以使用以下命令
# COPY requirements.txt .
# RUN pip install -r requirements.txt

然后使用以下命令构建并运行 Docker 容器：

docker build -t myfastapiapp .
docker run -d --name myfastapiapp -p 80:80 myfastapiapp

深入了解

路由分发的概念

假设你的网站有很多不同的功能模块，比如用户管理、商品管理、订单管理等。为了代码清晰和维护方便，我们可以将每个模块的路由分开管理，然后统一纳入主应用中。这就是路由分发的概念。

创建不同的路由模块

1. 安装 FastAPI 和 Uvicorn
2. 首先确保你已经安装了 FastAPI 和 Uvicorn：

pip install fastapi uvicorn

1. 创建项目结构
2. 假设我们有用户管理和商品管理两个模块，我们可以创建如下的项目结构：

myproject/
├── main.py
├── users.py
└── items.py

1. 编写用户管理模块（users.py）

from fastapi import APIRouter
router = APIRouter()

@router.get("/users/")def read_users():return [{"username": "user1"}, {"username": "user2"}]

@router.get("/users/{user_id}")def read_user(user_id: int):return {"username": f"user{user_id}"}

1. 编写商品管理模块（items.py）

from fastapi import APIRouter
router = APIRouter()

@router.get("/items/")def read_items():return [{"item": "item1"}, {"item": "item2"}]

@router.get("/items/{item_id}")def read_item(item_id: int):return {"item": f"item{item_id}"}

1. 主应用程序（main.py）

from fastapi import FastAPI
from users import router as users_router
from items import router as items_router
app = FastAPI()
app.include_router(users_router, prefix="/users")
app.include_router(items_router, prefix="/items")

@app.get("/")def read_root():return {"message": "欢迎来到餐馆"}

解释每一步

1. 创建 APIRouter 实例：
   1. 在 users.py 和 items.py 中，我们分别创建了一个 APIRouter 实例 router。
   2. 然后我们使用这个 router 来定义路径和处理函数。
2. 定义路径和处理函数：
   1. 在 users.py 中定义了 /users/ 和 /users/{user_id} 路径。
   2. 在 items.py 中定义了 /items/ 和 /items/{item_id} 路径。
3. 主应用****程序中包含路由：
   1. 在 main.py 中，我们导入了 users.py 和 items.py 中的 router。
   2. 使用 app.include_router 方法将这些路由包含到主应用中，并为每个路由添加前缀。

运行应用程序

在终端运行以下命令：

uvicorn main:app --reload

测试路由

• 访问 http://127.0.0.1:8000/ 会返回欢迎信息。
• 访问 http://127.0.0.1:8000/users/ 会返回用户列表。
• 访问 http://127.0.0.1:8000/users/1 会返回用户1的信息。
• 访问 http://127.0.0.1:8000/items/ 会返回商品列表。
• 访问 http://127.0.0.1:8000/items/1 会返回商品1的信息。

Rquest

基本使用方法

首先，我们来看一个简单的例子，展示如何在 FastAPI 中使用 request。

from fastapi import FastAPI, Request
app = FastAPI()

@app.get("/info")async def get_info(request: Request):return {"method": request.method,"url": str(request.url),"headers": dict(request.headers),"client": request.client.host
    }

在这个例子中，我们定义了一个路径 /info，当客户端发送 GET 请求到这个路径时，我们可以通过 request 对象获取请求的详细信息并返回。

详细讲解

1. 请求方法和 URL

你可以通过 request.method 获取请求方法（如 GET、POST 等），通过 request.url 获取请求的完整 URL。

@app.get("/method-url")async def method_url(request: Request):return {"method": request.method,"url": str(request.url)
    }

2. 请求头部信息

请求头部信息可以通过 request.headers 获取。它是一个包含所有请求头部信息的字典。

@app.get("/headers")async def headers(request: Request):return {"headers": dict(request.headers)
    }

3. 查询参数

查询参数可以通过 request.query_params 获取。它是一个包含所有查询参数的字典。

@app.get("/query-params")async def query_params(request: Request):return {"query_params": dict(request.query_params)
    }

例如，访问 http://127.0.0.1:8000/query-params?name=FastAPI&version=1.0，会返回：

{"query_params": {"name": "FastAPI","version": "1.0"}}

4. 请求体

对于 POST 请求，我们通常需要读取请求体的数据。你可以通过 request.json() 或 request.body() 读取 JSON 格式或原始格式的请求体数据。

@app.post("/post-json")async def post_json(request: Request):
    json_body = await request.json()return {"json_body": json_body
    }

客户端发送一个 POST 请求到 /post-json 路径，带有 JSON 格式的请求体：

json
复制代码
{"name": "FastAPI","version": "1.0"}

服务器会返回相同的 JSON 数据。

5. 客户端信息

你可以通过 request.client 获取客户端的 IP 地址和端口信息。

@app.get("/client-info")async def client_info(request: Request):return {"client_host": request.client.host,"client_port": request.client.port
    }

结合其他 FastAPI 功能

还可以将 request 对象与路径参数、查询参数、请求体等其他 FastAPI 功能结合使用，来实现更复杂的逻辑。

from fastapi import FastAPI, Request, Query
from pydantic import BaseModel
app = FastAPI()

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None@app.post("/items/{item_id}")async def create_item(item_id: int, item: Item, q: str = Query(None), request: Request):return {"item_id": item_id,"item": item.dict(),"query": q,"client": request.client.host
    }

这个例子展示了如何结合路径参数、查询参数、请求体和 request 对象来处理一个 POST 请求。