FastAPI 入门指南：从介绍到 GitHub 项目实践 – wiki基地

作者： /

FastAPI 入门指南：从介绍到 GitHub 项目实践

前言

在现代 Web 开发领域，构建高效、高性能的 API 是至关重要的。Python 作为一门 versatile（多用途）的语言，拥有众多成熟的 Web 框架，如 Django 和 Flask。然而，当追求极致的性能、现代化的开发体验以及自动化的 API 文档时，FastAPI 横空出世，迅速成为了众多开发者的新宠。

FastAPI 是一个用于构建 API 的现代、快速（高性能）的 web 框架，使用标准的 Python 类型提示。它的设计目标是：快速（开发速度快，运行时性能高）、可靠、直观、易于和健壮。它基于 Starlette （处理 Web 部分）和 Pydantic （处理数据部分）构建，充分利用了 Python 3.6+ 的异步特性和类型提示，带来了前所未有的开发效率和运行时性能。

本篇文章将带你从零开始认识 FastAPI，学习其核心概念，并通过一个简单的 GitHub 项目实践，让你了解如何构建、组织和分享你的 FastAPI 项目。

1. 为什么选择 FastAPI？

在深入学习之前，我们先来了解一下 FastAPI 的主要优势，这解释了为什么它在短时间内如此流行：

  1. 极高的性能: 得益于 Starlette （一个轻量级的 ASGI 框架）和 Uvicorn （一个高性能的 ASGI 服务器），FastAPI 拥有与 Node.js 和 Go 相媲美的性能。它支持异步（async/await），能够高效处理大量并发请求，特别适合 I/O 密集型任务（如数据库操作、调用外部服务）。
  2. 开发效率高: 使用 Python 类型提示，FastAPI 可以自动完成很多工作：
    • 数据验证: 基于 Pydantic 模型自动验证请求数据，并在数据无效时返回清晰的错误信息。
    • 数据序列化: 自动将 Python 对象（如 Pydantic 模型实例、字典）序列化为 JSON 响应。
    • 参数解析: 自动从请求路径、查询参数、请求体、Header、Cookie 中解析参数，并根据类型提示进行转换和验证。
    • 依赖注入: 强大的依赖注入系统使得代码更加模块化、可测试和可复用。
  3. 自动生成 API 文档: FastAPI 基于 OpenAPI (以前称为 Swagger) 标准，自动生成交互式的 API 文档界面。默认提供 Swagger UI (/docs) 和 ReDoc (/redoc)，无需手动编写文档，大大提高了开发效率和团队协作效率。
  4. 强大的类型提示支持: 充分利用 Python 3.6+ 的类型提示，提供优秀的代码补全和类型检查支持，减少运行时错误。
  5. 代码更少，Bug 更少: 自动化很多重复性工作，使得编写的代码量大大减少，降低了引入 Bug 的可能性。
  6. 易于学习和使用: 语法直观，文档清晰（尽管是英文，但非常详尽易懂）。

与 Flask 相比，FastAPI 原生支持异步，内置数据验证和序列化，自动生成文档，更适合构建现代的 API 服务。与 Django 相比，FastAPI 更轻量，更专注于 API 构建，没有内置 ORM、模板引擎等全栈功能（当然，你也可以很方便地集成这些库）。

2. 前置准备

在开始之前，请确保你已经安装了 Python 3.7+（虽然官方说 3.6+，但推荐 3.7+ 以获得更好的类型提示支持）和一个代码编辑器（如 VS Code, PyCharm）。

强烈建议使用虚拟环境来隔离项目依赖。

“`bash

创建虚拟环境 (venv 是 Python 3.3+ 内置的)

python -m venv .venv

激活虚拟环境

macOS/Linux

source .venv/bin/activate

Windows

..venv\Scripts\activate
“`

激活虚拟环境后，你的终端提示符前会显示虚拟环境的名称（通常是 .venv）。

3. 安装 FastAPI 和 ASGI 服务器

FastAPI 本身是一个框架，需要一个 ASGI 服务器来运行它。常用的 ASGI 服务器有 Uvicorn、Hypercorn 等。我们通常选择 Uvicorn，因为它高性能且易于使用。

“`bash

确保你在激活的虚拟环境中

pip install fastapi uvicorn[standard]

uvicorn[standard] 包含了 uvicorn 和一些可选的依赖，如 websockets, httptools 等

如果只想安装基本的 uvicorn, 使用 pip install uvicorn 即可

“`

安装完成后，你就可以开始编写你的第一个 FastAPI 应用了。

4. 第一个 FastAPI 应用：Hello, World!

创建一个名为 main.py 的文件，并输入以下代码：

“`python

main.py

from fastapi import FastAPI

创建一个 FastAPI 应用实例

app = FastAPI()

定义一个路径操作装饰器 @app.get(“/”)

这意味着当收到 GET 请求访问根路径 “/” 时，将执行下面的异步函数

@app.get(“/”)
async def read_root():
# 异步函数，因为 Fastapi 基于 async/await
# 返回一个字典，FastAPI 会自动将其序列化为 JSON 响应
return {“Hello”: “World”}

定义另一个路径操作

@app.get(“/items/{item_id}”)
async def read_item(item_id: int, q: str | None = None):
# item_id 是路径参数，从 URL 中获取，类型提示为 int
# q 是查询参数，从 URL “?q=somevalue” 中获取，类型提示为 str 或 None，默认值为 None
return {“item_id”: item_id, “q”: q}
“`

运行应用:

打开终端，进入到 main.py 文件所在的目录，并确保虚拟环境已激活。然后运行 Uvicorn：

bash
uvicorn main:app --reload

  • main: 指代 main.py 文件（模块）。
  • app: 指代在 main.py 文件中创建的 FastAPI() 实例对象。
  • --reload: 开启热重载模式。当你修改代码并保存后，Uvicorn 会自动重启服务器，方便开发调试。

你应该会看到类似以下的输出：

INFO: Will watch for changes in these directories: ['/path/to/your/project']
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO: Started reloader process [PID]
INFO: Started server running on http://127.0.0.1:8000

现在，打开你的浏览器或使用工具（如 Postman, curl）访问 http://127.0.0.1:8000，你会看到 JSON 响应：{"Hello":"World"}。

访问 http://127.0.0.1:8000/items/5?q=somequery，你会看到：{"item_id": 5, "q": "somequery"}。

自动生成的 API 文档:

FastAPI 最酷的特性之一是自动生成 API 文档。在服务器运行状态下，访问以下地址：

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

你会看到交互式的 API 文档界面，你可以直接在里面测试你的 API 端点！

5. FastAPI 核心概念详解

现在我们来深入了解 FastAPI 背后的一些核心概念。

5.1 路径操作（Path Operations）

你通过 app.get()、app.post()、app.put()、app.delete()、app.patch()、app.options()、app.head()、app.trace() 等装饰器来定义不同的 HTTP 方法对应不同的 URL 路径。这些装饰器就是路径操作装饰器。

“`python
@app.post(“/items/”) # 处理 POST 请求到 /items/
async def create_item(item: Item): # 接受请求体，使用 Pydantic 模型
# … 处理创建逻辑
pass

@app.get(“/items/{item_id}”) # 处理 GET 请求到 /items/{item_id}
async def read_item(item_id: int): # 接受路径参数
# … 处理读取逻辑
pass
“`

5.2 异步（Async/Await）

FastAPI 支持使用标准的 Python async def 和 await 语法。这对于需要等待其他操作完成（如数据库查询、调用外部 API、文件读写等 I/O 密集型操作）而不阻塞服务器主线程的应用非常重要。使用 async def 可以显著提高应用处理并发请求的能力。

如果你的路径操作函数中没有需要 await 的操作（即它是 CPU 密集型任务），你可以使用普通的 def 函数。FastAPI 会在单独的线程池中运行这些同步函数，避免阻塞主事件循环。但对于 I/O 密集型任务，强烈建议使用 async def。

“`python

I/O 密集型，推荐使用 async def

@app.get(“/users/{user_id}”)
async def get_user(user_id: int):
user = await database.get_user(user_id) # 假设 database.get_user 是一个 async 函数
return user

CPU 密集型，可以使用普通的 def

@app.post(“/process-data”)
def process_data(data: list[int]):
result = complex_calculation(data) # 假设 complex_calculation 是一个耗时计算
return {“result”: result}
“`

5.3 Pydantic 数据模型与类型提示

FastAPI 深度整合了 Pydantic 库。Pydantic 使用 Python 类型提示来定义数据模型，并提供自动的数据验证、解析和序列化功能。

“`python
from typing import Optional
from pydantic import BaseModel

定义一个 Pydantic 模型，用于请求体的数据结构

class Item(BaseModel):
name: str # 必填的字符串
description: str | None = None # 可选的字符串，默认值为 None
price: float # 必填的浮点数
tax: float | None = None # 可选的浮点数，默认值为 None

定义一个 POST 请求，接收一个 Item 对象作为请求体

@app.post(“/items/”)
async def create_item(item: Item):
# FastAPI 收到请求后，会自动将请求体（通常是 JSON）解析并验证
# 如果数据格式或类型不匹配 Item 模型，FastAPI 会返回 422 Unprocessable Entity 错误
# 验证通过后，item 变量就是一个 Item 类的实例
print(f”Received item: {item.model_dump_json(indent=2)}”) # model_dump_json 是 Pydantic v2+ 的方法
return item # FastAPI 会自动将 Item 实例序列化为 JSON 返回
“`

使用 Pydantic 的好处：

  • 数据验证: 自动根据模型定义进行验证，确保数据的正确性。
  • 代码补全: 编辑器可以根据类型提示提供代码补全。
  • 文档: Pydantic 模型的信息会被 FastAPI 用于生成 API 文档。
  • 序列化/反序列化: 自动处理 JSON 和 Python 对象之间的转换。

5.4 参数类型：路径、查询、请求体

FastAPI 会根据函数参数的类型提示和默认值，自动判断参数的来源：

  • 路径参数 (Path Parameters): 在路径字符串中 {param_name} 定义的参数。必须在函数签名中同名出现，且通常有类型提示。
    python
    @app.get("/items/{item_id}")
    async def read_item(item_id: int): # item_id 从路径获取并转换为 int
    return {"item_id": item_id}

  • 查询参数 (Query Parameters): 不在路径字符串中，但在 URL 中 ?key=value&key2=value2 出现的参数。在函数签名中定义，可以有默认值，也可以是可选的（使用 Optional 或 | None）。
    “`python
    from typing import Optional

    @app.get(“/items/”)
    async def read_items(skip: int = 0, limit: int = 10): # skip 和 limit 从查询参数获取，有默认值
    return {“skip”: skip, “limit”: limit}

    @app.get(“/users/”)
    async def read_users(name: Optional[str] = None): # name 从查询参数获取，可选
    return {“name”: name}
    * **请求体 (Request Body)**: 通过 `POST`, `PUT`, `PATCH` 等请求发送的数据，通常是 JSON 或表单数据。通过定义一个继承自 `Pydantic.BaseModel` 的参数来接收。python
    from pydantic import BaseModel

    class User(BaseModel):
    name: str
    age: int

    @app.post(“/users/”)
    async def create_user(user: User): # user 从请求体获取，并验证为 User 模型
    return user
    “`
    注意: 如果函数签名中同时有路径参数、查询参数和一个 Pydantic 模型参数，FastAPI 会智能地将路径参数和查询参数作为函数参数，将 Pydantic 模型参数作为请求体处理。

5.5 额外的校验和元数据：Query, Path, Body

有时候，你不仅想指定参数的类型，还想添加额外的校验规则（如最小/最大长度、最小值/最大值）或元数据（如描述、例子）。你可以使用 Query, Path, Body 等函数来实现。

“`python
from typing import Optional
from fastapi import FastAPI, Query, Path, Body
from pydantic import BaseModel, Field

app = FastAPI()

使用 Query 添加校验和元数据

@app.get(“/items/”)
async def read_items(
# 查询参数 q，可选，默认 None
# min_length=3: 最小长度为 3
# max_length=50: 最大长度为 50
# title: 在文档中显示的标题
# description: 在文档中显示的描述
# example: 在文档中显示的示例值
q: Optional[str] = Query(
None,
min_length=3,
max_length=50,
title=”搜索查询字符串”,
description=”用于搜索物品的查询字符串”,
example=”fastapi tutorial”
)
):
results = {“items”: [{“item_id”: “Foo”}, {“item_id”: “Bar”}]}
if q:
results.update({“q”: q})
return results

使用 Path 添加校验和元数据

@app.get(“/items/{item_id}”)
async def read_item(
# 路径参数 item_id
# gt=0: 必须大于 0 (Greater Than)
# example: 在文档中显示的示例值
item_id: int = Path(…, title=”要获取的物品的 ID”, gt=0, example=123), # … 表示该参数是必需的
# 另一个查询参数 q，可选，有默认值
q: str | None = Query(None, alias=”item-query”) # alias 定义了在 URL 中使用的名称
):
return {“item_id”: item_id, “q”: q}

使用 Body 添加校验和元数据到 Pydantic 模型字段

class Item(BaseModel):
name: str = Field(…, example=”Awesome Phone”) # Field 用于在 Pydantic 模型内部添加元数据和校验
description: str | None = Field(None, example=”A great phone with a nice camera.”)
price: float = Field(…, gt=0, description=”物品价格，必须大于0″, example=1200.5)
tax: float | None = Field(None, le=100, description=”税率，必须小于等于100″, example=12.0)

@app.put(“/items/{item_id}”)
async def update_item(
item_id: int = Path(…, gt=0),
item: Item = Body(
…, # … 表示请求体是必需的
example={ # 整个请求体的示例
“name”: “Updated Phone”,
“description”: “Even better now”,
“price”: 1500.0,
“tax”: 15.0
}
)
):
results = {“item_id”: item_id, “item”: item}
return results

``Query,Path,Body继承自FastAPI的Param类，提供了丰富的参数校验选项，例如：
*default: 默认值
*alias: 别名
*title: 标题
*description: 描述
*min_length,max_length: 字符串长度限制
*gt,ge,lt,le: 数值大小限制 (Greater Than, Greater or Equal, Less Than, Less or Equal)
*regex: 正则表达式校验
*…`: 表示该参数是必需的，没有默认值。

5.6 依赖注入 (Dependency Injection)

FastAPI 强大的依赖注入系统是其设计的一大亮点。你可以定义一个函数或类，让它作为另一个路径操作函数的“依赖”。FastAPI 会自动解决并注入这些依赖项。这使得代码更加模块化、可测试和可重用。

依赖可以用于：
* 数据库连接
* 认证和授权
* 数据校验
* 获取其他资源等

“`python
from typing import Annotated
from fastapi import Depends, FastAPI, Header, HTTPException

app = FastAPI()

定义一个简单的依赖函数

async def common_parameters(q: str | None = None, skip: int = 0, limit: int = 100):
“””
常用的分页和搜索参数依赖
“””
return {“q”: q, “skip”: skip, “limit”: limit}

使用 Annotated 和 Depends 来声明依赖

Annotated 是 Python 3.9+ 的新特性，推荐使用，更清晰

common_params 将接收 common_parameters 函数的返回值

@app.get(“/items/”)
async def read_items(common_params: Annotated[dict, Depends(common_parameters)]):
# common_params 现在是一个字典，包含了 q, skip, limit
# 你可以直接使用 common_params[“skip”] 等
return common_params

另一个依赖示例：校验 Header

async def verify_token(x_token: Annotated[str, Header()]):
if x_token != “fake-super-secret-token”:
raise HTTPException(status_code=400, detail=”X-Token header invalid”)
return x_token

async def verify_key(x_key: Annotated[str, Header()]):
if x_key != “fake-super-secret-key”:
raise HTTPException(status_code=400, detail=”X-Key header invalid”)
return x_key

将多个依赖项注入到一个路径操作中

@app.get(“/users/”, dependencies=[Depends(verify_token), Depends(verify_key)])
async def read_users():
# 如果 verify_token 或 verify_key 抛出 HTTPException，请求会在到达这里之前中断
# 如果都通过，函数正常执行
return [{“username”: “Rick”}, {“username”: “Morty”}]

“`
依赖注入使得代码组织更加清晰，逻辑分离，特别是对于需要跨多个端点共享的功能（如认证、数据库连接池）非常有用。

5.7 错误处理

FastAPI 提供了方便的错误处理机制。你可以使用 fastapi.HTTPException 来抛出 HTTP 错误。

“`python
from fastapi import FastAPI, HTTPException

app = FastAPI()

items = {“foo”: “The Foo Wrestlers”}

@app.get(“/items/{item_id}”)
async def read_item(item_id: str):
if item_id not in items:
# 抛出 404 错误，并包含详细信息
raise HTTPException(status_code=404, detail=”Item not found”)
return {“item”: items[item_id]}
``
当抛出HTTPException时，FastAPI 会自动生成相应的 HTTP 响应（例如 404 Not Found），并将detail` 信息包含在响应体中。

你也可以定义自定义的异常处理程序来覆盖默认的错误响应。

6. 构建一个简单的 CRUD API 示例

现在我们将上面学到的概念结合起来，构建一个简单的内存型的 CRUD（创建、读取、更新、删除） API。

我们将创建一个简单的物品模型，并实现对物品的增删改查操作。

“`python

main.py

from typing import List, Optional
from fastapi import FastAPI, HTTPException, Path, Body
from pydantic import BaseModel, Field
import uvicorn # 导入 uvicorn 以便在脚本末尾直接运行

定义一个物品 Pydantic 模型

class Item(BaseModel):
name: str = Field(…, description=”物品名称”)
description: Optional[str] = Field(None, description=”物品描述”)
price: float = Field(…, gt=0, description=”物品价格，必须大于0″)
tax: Optional[float] = Field(None, ge=0, le=100, description=”税率，0-100之间”)

# 可选：Pydantic v2+ 中的 Config 或 model_config 用于配置
# class Config:
#     json_schema_extra = {
#         "example": {
#             "name": "Awesome Item",
#             "description": "A wonderful item",
#             "price": 100.0,
#             "tax": 10.0
#         }
#     }
# Pydantic v2+ 推荐使用 model_config
model_config = {
    "json_schema_extra": {
        "examples": [
            {
                "name": "Awesome Item",
                "description": "A wonderful item",
                "price": 100.0,
                "tax": 10.0
            }
        ]
    }
}

内存数据库（使用字典模拟）

键是 item_id (int), 值是 Item 实例

items_db: dict[int, Item] = {}
next_item_id = 1

app = FastAPI(
title=”简单的 FastAPI CRUD API”, # 在文档中显示的标题
description=”这是一个用于学习 FastAPI 的简单 CRUD 示例 API”, # 在文档中显示的描述
version=”1.0.0″ # 版本号
)

创建物品

@app.post(“/items/”, response_model=Item, status_code=201, summary=”创建新物品”)
async def create_item(item: Item = Body(…, description=”要创建的物品信息”)):
“””
创建新的物品。
– name: 物品名称
– description: 物品描述 (可选)
– price: 物品价格 (必须 > 0)
– tax: 税率 (可选, 0-100)
“””
global next_item_id
item_id = next_item_id
items_db[item_id] = item # 将 Item 实例存储到字典
next_item_id += 1
return item # 返回创建的物品信息

读取所有物品

@app.get(“/items/”, response_model=List[Item], summary=”获取所有物品”)
async def read_items():
“””
获取所有存储在数据库中的物品列表。
“””
return list(items_db.values()) # 返回所有 Item 实例的列表

读取单个物品

@app.get(“/items/{item_id}”, response_model=Item, summary=”根据 ID 获取物品”)
async def read_item(
item_id: int = Path(…, description=”要获取的物品的 ID”, gt=0)
):
“””
根据物品 ID 获取单个物品的详细信息。
如果物品不存在，返回 404 错误。
“””
if item_id not in items_db:
raise HTTPException(status_code=404, detail=”Item not found”)
return items_db[item_id]

更新物品

@app.put(“/items/{item_id}”, response_model=Item, summary=”更新物品”)
async def update_item(
item_id: int = Path(…, description=”要更新的物品的 ID”, gt=0),
item: Item = Body(…, description=”更新后的物品信息”)
):
“””
更新指定 ID 的物品信息。
如果物品不存在，返回 404 错误。
“””
if item_id not in items_db:
raise HTTPException(status_code=404, detail=”Item not found”)
items_db[item_id] = item # 更新物品信息
return item # 返回更新后的物品信息

删除物品

@app.delete(“/items/{item_id}”, status_code=204, summary=”删除物品”)
async def delete_item(
item_id: int = Path(…, description=”要删除的物品的 ID”, gt=0)
):
“””
删除指定 ID 的物品。
如果物品不存在，返回 404 错误。
成功删除返回 204 No Content。
“””
if item_id not in items_db:
raise HTTPException(status_code=404, detail=”Item not found”)
del items_db[item_id] # 从字典中删除物品
# 成功删除通常返回 204 No Content，响应体为空
# FastAPI 会自动处理 204 状态码时抑制响应体
return # 注意这里不返回任何内容

可选：直接在脚本中运行 Uvicorn (仅用于简单示例或开发)

生产环境通常使用 gunicorn 或 supervisor 等进程管理器来启动 uvicorn

if name == “main“:
uvicorn.run(“main:app”, host=”127.0.0.1″, port=8000, reload=True)
“`

在这个例子中：
* 我们定义了一个 Item Pydantic 模型，包含了字段的类型、描述、校验规则和示例。
* 使用一个简单的字典 items_db 模拟数据库存储。
* 为每个 CRUD 操作定义了对应的路径操作 (POST, GET, PUT, DELETE)。
* 使用了 Path 和 Body 添加参数描述和校验。
* 使用了 response_model 参数指定响应的数据模型，FastAPI 会自动验证响应数据并生成文档。
* 使用了 status_code 参数指定操作成功的 HTTP 状态码（如 201 Created, 204 No Content）。
* 使用了 summary 和 Docstring 为每个端点添加摘要和详细描述，这些都会出现在自动生成的文档中。
* 在 read_item, update_item, delete_item 中检查物品是否存在，如果不存在则抛出 HTTPException(status_code=404).

运行这个脚本 (python main.py)，然后访问 /docs 或 /redoc，你会看到一个漂亮且功能完整的 CRUD API 文档，可以直接进行测试。

7. 从本地到 GitHub 项目实践

将本地开发的应用组织成一个可分享、可协作的 GitHub 项目是现代软件开发的标准流程。以下是将上述 FastAPI 应用转化为一个基本 GitHub 项目的步骤和建议：

7.1 项目结构

一个清晰的项目结构非常重要。对于一个简单的 FastAPI 应用，可以采用以下结构：

my_fastapi_crud_project/
├── main.py # FastAPI 应用的入口文件
├── requirements.txt # 项目依赖列表
├── .gitignore # Git 忽略文件列表
├── README.md # 项目说明文档
└── (可选) app/ # 如果项目变大，可以将 main.py 内容拆分到这里
├── __init__.py
├── api.py # 路由定义
└── models.py # Pydantic 模型
└── crud.py # CRUD 逻辑 (如果需要分离)

对于我们的简单 CRUD 示例，一个包含 main.py, requirements.txt, .gitignore, README.md 的平铺结构就足够了。

7.2 requirements.txt 文件

requirements.txt 文件列出了项目所需的所有 Python 依赖。这样，其他开发者克隆你的项目后，只需安装这些依赖即可运行。

在你的虚拟环境中，运行以下命令生成 requirements.txt：

bash
pip freeze > requirements.txt

这将把当前虚拟环境中所有已安装的库及其版本写入 requirements.txt。对于这个项目，它应该包含 fastapi 和 uvicorn。

7.3 .gitignore 文件

.gitignore 文件告诉 Git 在版本控制中忽略哪些文件和目录。这通常包括：

  • 虚拟环境目录 (如 .venv/)
  • Python 编译生成的文件 (如 __pycache__/, *.pyc)
  • 编辑器或操作系统的临时文件
  • 敏感信息文件 (如数据库配置、.env 文件等)

在项目根目录创建 .gitignore 文件，并添加以下内容：

“`gitignore

Virtual environment

.venv/
venv/
env/

Python bytecode

pycache/
*.pyc

Editor specific files

.vscode/
.idea/

Operating System files

.DS_Store
Thumbs.db

Sensitive files (if any)

.env
config.yaml
“`

7.4 README.md 文件

README.md 文件是项目的门面，它应该包含项目的基本信息、如何安装、如何运行、如何使用以及其他重要说明。

创建一个 README.md 文件，并包含以下内容：

“`markdown

简单的 FastAPI CRUD 项目

这是一个使用 FastAPI 构建的简单 CRUD (Create, Read, Update, Delete) API 示例。

功能

  • 创建新的物品
  • 获取所有物品列表
  • 根据 ID 获取单个物品
  • 更新物品信息
  • 删除物品

数据存储在内存中，应用停止后数据会丢失。

技术栈

  • Python 3.7+
  • FastAPI
  • Uvicorn

安装与运行

  1. 克隆项目仓库：
    bash
    git clone https://github.com/你的用户名/你的仓库名.git
    cd your-repo-name

  2. 创建并激活虚拟环境：
    bash
    python -m venv .venv
    # macOS/Linux
    source .venv/bin/activate
    # Windows
    .\.venv\Scripts\activate

  3. 安装项目依赖：
    bash
    pip install -r requirements.txt

  4. 运行 FastAPI 应用：
    bash
    uvicorn main:app --reload
    应用将在 http://127.0.0.1:8000 启动。

API 文档

应用启动后，你可以访问自动生成的 API 文档：

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

你可以在文档页面直接测试各个 API 端点。

贡献

欢迎贡献代码，请提交 Pull Request。

许可证

本项目使用 MIT 许可证。详见 LICENSE 文件 (如果存在)。

“`

确保将 你的用户名 和 你的仓库名 替换为实际信息。

7.5 Git 初始化与推送到 GitHub

  1. 初始化本地 Git 仓库:
    在项目根目录运行：
    bash
    git init

  2. 暂存并提交文件:
    bash
    git add .
    git commit -m "Initial commit: add basic FastAPI app and project files"

  3. 在 GitHub 创建新仓库:
    登录 GitHub，点击右上角的 “+” 号，选择 “New repository”。填写仓库名称（例如 my-fastapi-crud-project），选择 Public 或 Private，不要勾选 “Add a README file”、”Add .gitignore”、”Choose a license” (因为我们已经在本地创建了)。点击 “Create repository”。

  4. 关联本地仓库与远程仓库:
    GitHub 会显示关联现有本地仓库的指令。通常是：
    bash
    git remote add origin https://github.com/你的用户名/你的仓库名.git
    git branch -M main # 将主分支命名为 main

  5. 推送代码到 GitHub:
    bash
    git push -u origin main
    -u 参数会在首次推送时建立本地分支和远程分支的关联，以后可以直接使用 git push。

现在，你的 FastAPI 项目代码就已经成功上传到 GitHub 了，其他开发者可以克隆、运行、测试你的项目，或者提交贡献。

8. 总结与展望

通过这篇入门指南，你应该已经对 FastAPI 有了一个全面的认识，包括：

  • FastAPI 的优势和特点
  • 如何安装和运行 FastAPI 应用
  • 第一个 “Hello, World!” 应用
  • 核心概念：路径操作、异步、Pydantic 模型、参数类型、额外的校验和元数据、依赖注入、错误处理
  • 构建一个简单的 CRUD API 示例
  • 将项目组织并发布到 GitHub 的基本流程

FastAPI 的世界远不止这些。它还有更多强大的功能等待你去探索，例如：

  • 安全性: 内置对 OAuth2 (JWT Token)、API Key 等多种认证方案的支持。
  • 后台任务: 执行不阻塞主线程的异步任务。
  • 中间件: 在请求到达路径操作之前或响应离开之后执行一些处理（如 CORS、GZip、自定义中间件）。
  • 测试: 方便的测试工具，基于 httpx 库。
  • 与其他库集成: 与数据库 (SQLAlchemy, Tortoise-ORM)、模板引擎 (Jinja2) 等轻松集成。
  • 子应用: 将大型应用拆分为多个独立的 FastAPI 应用。

继续学习的最佳资源是 FastAPI 的官方文档。它非常详细、清晰，并且包含大量示例。

希望这篇指南能帮助你迈出 FastAPI 开发的第一步。现在，是时候动手实践，构建你自己的高性能 API 了！祝你开发愉快！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部