fastapi 入门系列_代码007(未授权)

本文介绍: FastAPI是一个现代、快速（高性能）的We b 框架，用于构建API。它基于Py th on 3.7+的类型提示（type hint s）和异步编程（async io）能力，使得代码易于编写、阅读和维护。FastAPI具有自动交互式文档（基于OpenAPI规范和JSON Sch ema）、数据验证、依赖注入（Dep endenc y Inject i on）等功能，这些功能使得API的开发速度更快、更可靠。Fa s tAPI还支持WebSoc ket和Gr ap hQL，可以轻松地扩展到更复杂的应用场景。

大纲

FastAPI是一个现代、快速（高性能）的Web 框架，用于构建API。它基于Py th on 3.7+的类型提示（type hints）和异步编程（async io）能力，使得代码易于编写、阅读和维护。FastAPI具有自动交互式文档（基于OpenAPI规范和JSON Sch ema）、数据验证、依赖注入（Dependency Inject i on）等功能，这些功能使得API的开发速度更快、更可靠。FastAPI还支持WebSoc ket和GraphQL，可以轻松地扩展到更复杂的应用场景。由于其高性能、易用性和可扩展性，FastAPI在人工智能、机器学习、数据科学等领域得到了广泛的应用。

FastAPI使用Pyd ant ic和Star lette等现代Pyth on库，可以实现比Flas k和Django等传统框架更快的性能。FastAPI的异步支持使其能够处理大量并发请求，并在高负载下保持稳定的性能。

FastAPI可以自动生成API文档，这是一个重要的优势。FastAPI使用OpenAPI标准，可以通过Swagger UI或Red oc自动生成交互式API文档。这使得API的使用和测试更加容易和直观。

FastAPI使用Pyth on的类型注解和Pydanti c库来自动验证请求和响应的数据。这使得代码更加清晰和易于维护，并可以在运行时自动检查数据类型和格式。这也可以帮助开发人员更早地发现和解决错误。

FastAPI提供了一些快速开发的功能，如自动路由和依赖注入。这使得开发人员可以更快地编写API，并且可以更容易地管理和维护代码。FastAPI还提供了一些常见的功能，如身份验证和数据库集成，以便开发人员可以更快地构建功能完整的API。

pip install fastapi

pip install uvicorn[standard]
pip install python-multipart

uvicorn main:app --reload

其中，main是你的主文件名，app是FastAPI实例的名称。--reload选项将自动重新加载代码更改，使开发更加高效。

安装完成后，可以在浏览器中访问http://localhost:8000/docs来查看自动生成的API文档和交互式API页面。

pip install uvicorn[standard]

pip install fastapi
pip install pydantic
pip install starlette

import fastapi
print(fastapi.__version__)

pip install fastapi uvicorn[standard]

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello World"}

uvicorn main:app --reload

pip install fastapi
pip install uvicorn[standard]

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello World"}

uvicorn main:app --reload

{"message": "Hello World"}

from fastapi import FastAPI

app = FastAPI()

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

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

在上面的例子中，@app.get("/")和@app.get("/items/{item_id}")都是路由定义的装饰器。其中，"/"和"/items/{item_id}"是路由路径，read_root()和read_item()是路由处理函数。路由路径中的{item_id}是路径参数，可以在路由处理函数中使用。路由处理函数中的q是查询参数，可以在请求URL中使用，例如/items/42?q=somequery。路由处理函数需要返回一个响应体，可以是字符串、字典、模型等。FastAPI会根据返回值的类型自动推断响应体的Content-Type和响应状态码。如果需要指定Content-Type和响应状态码，可以使用Response类，例如：

from fastapi import FastAPI, Response

app = FastAPI()

@app.get("/")
async def read_root(response: Response):
    response.headers["Content-Language"] = "en-US"
    return {"Hello": "World"}

在上面的例子中，使用Response类可以设置响应头。注意，在路由处理函数中，如果需要访问请求体、请求头、Cookie等信息，可以使用Request类，例如：

from fastapi import FastAPI, Request

app = FastAPI()

@app.get("/")
async def read_root(request: Request):
    user_agent = request.headers["user-agent"]
    return {"User-Agent": user_agent}

请求体是 HTTP 请求中的消息体，通常包含客户端向服务器端提交的数据。在 FastAPI 中，可以使用 Pydantic 模型定义请求体的结构，并使用 Body 参数将其注入到路由处理函数中。

以下是一个使用 Body 参数的示例：

from fastapi import FastAPI, Body
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None

@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item, q: str = None):
    result = {"item_id": item_id, "item": item}
    if q:
        result.update({"q": q})
    return result

在上面的示例中，我们定义了一个 Item 模型，其中包含 name、price 和 is_offer 三个字段。接着，在 update_item 路由处理函数中，我们使用 Body 参数将 Item 对象注入到函数中，并将其用作请求体。

from fastapi import FastAPI

app = FastAPI()

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

在上面的示例中，我们定义了一个 read_item 路由处理函数，其中包含一个名为 item_id 的路径参数和一个名为 q 的查询参数。在函数中，我们可以通过这些参数来访问客户端提交的数据。

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None

@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
    return {"item_id": item_id, "item": item}

在上面的示例中，我们定义了一个 Item 模型，并在 update_item 路由处理函数中将其作为响应数据返回给客户端。在返回数据时，我们将其转换为 Item 对象，并将其作为 JSON 格式的数据返回给客户端。

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "mysql+pymysql://user:password@host:port/db_name"

engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

from fastapi import FastAPI, Depends
from sqlalchemy.orm import Session
from .database import SessionLocal, engine
from . import models, schemas

app = FastAPI()

models.Base.metadata.create_all(bind=engine)

# Dependency
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.post("/users/")
def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
    db_user = models.User(username=user.username, email=user.email)
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user

在安装好相应的驱动程序后，我们需要在应用程序中配置数据库连接。我们可以使用Python的标准库中的sqlite3模块连接SQLite数据库，也可以使用第三方库如SQLAlchemy连接各种类型的数据库。在FastAPI中，我们可以使用第三方库如databases和SQLAlchemy等来连接数据库。

对于databases库，我们可以通过以下方式来配置数据库连接：

import databases

DATABASE_URL = "sqlite:///./test.db"

database = databases.Database(DATABASE_URL)

在上面的代码中，我们首先定义了一个名为DATABASE_URL的变量，它包含了SQLite数据库的连接信息。然后我们使用databases库中的Database类来创建一个名为database的数据库连接对象。

对于SQLAlchemy库，我们可以通过以下方式来配置数据库连接：

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "sqlite:///./test.db"

engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base = declarative_base()

在上面的代码中，我们首先定义了一个名为DATABASE_URL的变量，它包含了SQLite数据库的连接信息。然后我们使用create_engine函数创建一个名为engine的数据库引擎对象。接着，我们使用sessionmaker函数创建一个名为SessionLocal的数据库会话对象。最后，我们使用declarative_base函数创建一个名为Base的ORM基类对象。

from tortoise.models import Model
from tortoise import fields


class User(Model):
    id = fields.IntField(pk=True)
    username = fields.CharField(max_length=50, unique=True)
    password = fields.CharField(max_length=50)
    email = fields.CharField(max_length=50, unique=True)
    is_active = fields.BooleanField(default=True)

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

SQLALCHEMY_DATABASE_URL = "postgresql://user:password@postgresserver/db"

engine = create_engine(SQLALCHEMY_DATABASE_URL)

SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

from sqlalchemy.orm import Session
from . import models

def get_user(db: Session, user_id: int):
    return db.query(models.User).filter(models.User.id == user_id).first()

以上代码展示了如何使用SQLAlchemy库提供的ORM框架查询数据库表中的数据。在这个示例中，我们定义了一个函数get_user，它接受一个数据库会话对象和一个用户ID作为参数。函数使用ORM框架查询数据库表中ID等于用户ID的第一条记录，并返回该记录。

from sqlalchemy.orm import Session
from . import models, schemas

def create_user(db: Session, user: schemas.UserCreate):
    db_user = models.User(email=user.email, password=user.password)
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user

以上代码展示了如何使用SQLAlchemy库提供的ORM框架插入数据到数据库表中。在这个示例中，我们定义了一个函数create_user，它接受一个数据库会话对象和一个用户创建模型作为参数。函数使用ORM框架创建一个新的用户记录，并将其添加到数据库会话中。然后，函数提交会话以将新记录保存到数据库中，并使用ORM框架刷新会话以获取新记录的ID。最后，函数返回新记录。

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

COPY ./app /app

docker build -t my-fastapi-app .

docker run -d --name my-fastapi-app -p 80:80 my-fastapi-app

测试编号	测试输入	预期输出	执行步骤
TC001	2, 3	5	1. 输入2和3作为加数；2. 调用加法函数；3. 验证输出是否等于5。
TC002	-2, 3	1	1. 输入-2和3作为加数；2. 调用加法函数；3. 验证输出是否等于1。
TC003	0, 0	0	1. 输入0和0作为加数；2. 调用加法函数；3. 验证输出是否等于0。

显示所有内容

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。

1. 概述

1.1 什么是FastAPI

1.1 什么是FastAPI

1.2 FastAPI的优势

1.2.1 强大的性能

1.2.2 自动生成API文档

1.2.3 类型注解和自动验证

1.2.4 快速开发

1.2.5 强大的交互式API文档

2. 安装

2.1 安装FastAPI

3.1.1 安装##### 3.1.1 安装FastAPI

2.2 安装依赖项

3.2 安装依赖项

3. 快速入门

3.1 创建一个FastAPI应用

3.1.1 安装FastAPI依赖库

3.1.2 创建一个FastAPI应用

3.1.3 运行FastAPI应用

3.2 运行FastAPI应用

3.2.1 安装FastAPI和uvicorn

3.2.2 创建FastAPI应用

3.2.3 运行FastAPI应用

3.3 访问FastAPI应用

3.3.1 使用HTTPie访问FastAPI应用

4. 路由和请求处理

4.1 定义路由

3.1.1 定义路由

4.2 处理请求

4.2.1 请求体

4.2.2 请求参数

4.2.3 响应模型

5. 数据库集成

5.1 连接数据库

3.1.1 连接数据库

5.2 定义模型

3.1 数据库集成-5.2 定义模型

5.3 操作数据库

5.3.1 连接数据库

5.3.2 查询数据

5.3.3 插入数据

6. 部署

6.1 部署FastAPI应用

6.1.1 部署FastAPI应用到本地服务器

6.1.2 部署FastAPI应用到云服务器

6.2 使用Docker部署FastAPI应用

6.2.1 Docker基础知识

6.2.2 使用Docker部署FastAPI应用

7. 测试

7.1 编写测试用例

7.1.1 什么是测试用例

7.1.2 编写测试用例的步骤

7.1.3 示例测试用例

7.2 运行测试用例

7.2.1 编写测试用例

7.2.2 运行测试用例

7.2.3 分析测试结果

8. 总结

8.1 FastAPI的优点

3.1 FastAPI的优点

8.2 FastAPI的应用场景

8.2.1 Web应用程序

8.2.2 微服务

8.2.3 数据科学和机器学习

8.2.4 其他应用场景

相关文章

发表回复 取消回复

1.1 什么是Fa s tAPI

1.1 什么是Fa s tAPI

发表回复取消回复