(完结篇)Python web框架FastAPI——一个比Flask和Tornada更高性能的API 框架

前言

前几天给大家分别分享了(入门篇)简析Python web框架FastAPI——一个比Flask和Tornada更高性能的API 框架和(进阶篇)Python web框架FastAPI——一个比Flask和Tornada更高性能的API 框架。今天欢迎大家来到 FastAPI 系列分享的完结篇,本文主要是对于前面文章的补充和扩展。

当然这些功能在实际开发中也扮演者极其重要的角色。

(完结篇)简析一个比Flask和Tornado更高性能的API 框架FastAPI

1

中间件的使用

Flask 有 钩子函数,可以对某些方法进行装饰,在某些全局或者非全局的情况下,增添特定的功能。

同样在 FastAPI 中也存在着像钩子函数的东西,也就是中间件 Middleware了。

计算回调时间

# -*- coding: UTF-8 -*-
import time
from fastapi import FastAPI
from starlette.requests import Request

app = FastAPI()


@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time
    response.headers["X-Process-Time"] = str(process_time)
    print(response.headers)
    return response


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


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

请求重定向中间件

from fastapi import FastAPI
from starlette.middleware.httpsredirect import HTTPSRedirectMiddleware

app = FastAPI()

app.add_middleware(HTTPSRedirectMiddleware)

# 被重定向到 301
@app.get("/")
async def main():
    return {"message": "Hello World"}

授权允许 Host 访问列表(支持通配符匹配)

from fastapi import FastAPI
from starlette.middleware.trustedhost import TrustedHostMiddleware

app = FastAPI()

app.add_middleware(
    TrustedHostMiddleware, allowed_hosts=["example.com", "*.example.com"]
)


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

跨域资源共享

from fastapi import FastAPI
from starlette.middleware.cors import CORSMiddleware

app = FastAPI()

#允许跨域请求的域名列表(不一致的端口也会被视为不同的域名)
origins = [
    "https://gzky.live",
    "https://google.com",
    "http://localhost:5000",
    "http://localhost:8000",
]

# 通配符匹配,允许域名和方法
app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,   
    allow_credentials=True, 
    allow_methods=["*"],   
    allow_headers=["*"],   
)

在前端 ajax 请求,出现了外部链接的时候就要考虑到跨域的问题,如果不设置允许跨域,浏览器就会自动报错,跨域资源 的安全问题。

所以,中间件的应用场景还是比较广的,比如爬虫,有时候在做全站爬取时抓到的 Url 请求结果为 301,302, 之类的重定向状态码,那就有可能是网站管理员设置了该域名(二级域名) 不在 Host 访问列表 中而做出的重定向处理,当然如果你也是网站的管理员,也能根据中间件做些反爬的措施。

更多中间件参考 https://fastapi.tiangolo.com/advanced/middleware

2

BackgroundTasks

创建异步任务函数,使用 async 或者普通 def 函数来对后端函数进行调用。

发送消息

# -*- coding: UTF-8 -*-
from fastapi import BackgroundTasks, Depends, FastAPI

app = FastAPI()


def write_log(message: str):
    with open("log.txt", mode="a") as log:
        log.write(message)


def get_query(background_tasks: BackgroundTasks, q: str = None):
    if q:
        message = f"found query: {q}\n"
        background_tasks.add_task(write_log, message)
    return q


@app.post("/send-notification/{email}")
async def send_notification(
    email: str, background_tasks: BackgroundTasks, q: str = Depends(get_query)
):
    message = f"message to {email}\n"
    background_tasks.add_task(write_log, message)
    return {"message": "Message sent"}

使用方法极其的简单,也就不多废话了,write_log 当成 task 方法被调用,先方法名,后传参。

3

自定义 Response 状态码

在一些特殊场景我们需要自己定义返回的状态码

from fastapi import FastAPI
from starlette import status

app = FastAPI()

# 201
@app.get("/201/", status_code=status.HTTP_201_CREATED)
async def item201():
    return {"httpStatus": 201}

# 302
@app.get("/302/", status_code=status.HTTP_302_FOUND)
async def items302():
    return {"httpStatus": 302}

# 404
@app.get("/404/", status_code=status.HTTP_404_NOT_FOUND)
async def items404():
    return {"httpStatus": 404}

# 500
@app.get("/500/", status_code=status.HTTP_500_INTERNAL_SERVER_ERROR)
async def items500():
    return {"httpStatus": 500}


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

这么一来就有趣了,设想有个人写了这么一段代码

async def getHtml(self, url, session):    try:        async with session.get(url, headers=self.headers, timeout=60, verify_ssl=False) as resp:            if resp.status in [200, 201]:                data = await resp.text()                return data    except Exception as e:        print(e)        pass

那么就有趣了,这段获取 Html 源码的函数根据 Http状态码 来判断是否正常的返回。那如果根据上面的写法,我直接返回一个 404 或者 304 的状态码,但是响应数据却正常,那么这个爬虫岂不是什么都爬不到了么。所以,嘿嘿你懂的!!

4

关于部署

部署 FastAPI 应用程序相对容易

Uvicorn

FastAPI 文档推荐使用 Uvicorn 来部署应用( 其次是 hypercorn),Uvicorn 是一个基于 asyncio 开发的一个轻量级高效的 Web 服务器框架(仅支持 python 3.5.3 以上版本)

安装

pip install uvicorn

启动方式

uvicorn main:app --reload --host 0.0.0.0 --port 8000

Gunicorn

如果你仍然喜欢用 Gunicorn 在部署项目的话,请看下面

安装

pip install gunicorn

启动方式

gunicorn -w 4 -b 0.0.0.0:5000  manage:app -D
(完结篇)简析一个比Flask和Tornado更高性能的API 框架FastAPI

Docker部署

采用 Docker 部署应用的好处就是不用搭建特定的运行环境(实际上就是 docker 在帮你拉取),通过 Dockerfile 构建 FastAPI 镜像,启动 Docker 容器,通过端口映射可以很轻松访问到你部署的应用。

Nginx

在 Uvicorn/Gunicorn + FastAPI 的基础上挂上一层 Nginx 服务,一个网站就可以上线了,事实上直接使用 Uvicorm 或 Gunicorn 也是没有问题的,但 Nginx 能让你的网站看起来更像网站。

撒花 !!!

——————- End ——————-

往期精彩文章推荐:

看完本文有收获?请转发分享给更多的人

Python爬虫与数据挖掘

入群请在微信后台回复【入群】

在公众号后台回复下列关键词可以免费获取相应的学习资料:

Python、网络爬虫 、书籍、数据分析、机器学习、数据结构、

大数据、服务器、Spark、Redis、C++、C、php、

mysql、java、Android、面试题、课堂、其他

(进阶篇)Python web框架FastAPI——一个比Flask和Tornada更高性能的API 框架

前言

上一篇已经初步了解了 FastAPI 的基本使用,但是如果想要真正把 FastAPI 部署上线到服务器,那么你需要了解更多,学习更多。所以本篇内容将注重于 FastAPI 的项目生产环境,诸如 数据库,路由蓝图,数据验证等问题在 FastAPI 中的具体操作和一些自己碰到的坑,分享给正在进攻 FastAPI 的各位小伙伴。

蓝图

事实上,FastAPI 并没有关于蓝图 (Blueprint) 的定义,在 FastAPI 中使用 Include_route 方法来添加路由,也就是我们所熟知的蓝图了。

import time
from typing import List
from starlette.templating import Jinja2Templates
from fastapi import Depends, FastAPI, HTTPException
from starlette.staticfiles import StaticFiles
from starlette.templating import Jinja2Templates
from app import models
from app.database.database import SessionLocal, engine
from app.home import user,index


app = FastAPI()

app.mount("/static", StaticFiles(directory="app/static"), name="static") # 挂载静态文件,指定目录
templates = Jinja2Templates(directory="templates") # 模板目录

app.include_router(index.userRouter)
app.include_router(user.userRouter,prefix="/user")

可以看到在 home 目录引入了 user.py 和 index.py 文件,注意必须要在文件中初始化一个 APIRouter() 类对象 (当然如果需要,可以选择继承),prefix 指明子路由的路径,更多的参数使用请参考官方文档。

# user.pyfrom starlette.templating import Jinja2Templatesfrom app import schemas, models
from app.database.database import get_db
from app.home import crud
from fastapi import Depends, HTTPException, Form
from sqlalchemy.orm import Session
from app.models import User
from sqlalchemy.orm import Session
from fastapi import APIRouter, HTTPException,Request
from fastapi.responses import RedirectResponse

userRouter = APIRouter()
templates = Jinja2Templates(directory="app/templates") # 模板目录

@userRouter.post("/login/", response_model=schemas.UserOut)
async def login(*,request: Request,db: Session = Depends(get_db), username: str = Form(None), password: str = Form(None),):
    if request.method == "POST":
        db_user = db.query(models.User).filter(User.username == username).first()
        if not db_user:
            raise HTTPException(status_code=400, detail="用户不存在")
        print("验证通过 !!!")
        return RedirectResponse('/index')

    return templates.TemplateResponse("user/login.html", {"request": request})

看起来比 Flask 添加蓝图要轻松许多。

同时支持多种请求方式

在上面的 login 例子可以发现,我在上下文 request 中通过判断路由的请求方式来进行响应的逻辑处理,比如如果不是 Post请求 就把它重定向到 login 页面等等。那么就需要同时支持多种请求方式了,巧合的是,我在 FastAPI 文档中找不到相应的说明,刚开始的时候我也迷糊了一阵。所以,只能干源码了。

直接进入 APIRouter 类所在的文件,发现新大陆。

在 APIRouter 下有个叫 add_api_route 的方法,支持 http方法 以列表的形式作为参数传入,所以就换成了下面这种写法:

async def login(*,request: Request,db: Session = Depends(get_db), username: str = Form(None), password: str = Form(None),):
    if request.method == "POST":
        db_user = db.query(models.User).filter(User.username == username).first()
        if not db_user:
            raise HTTPException(status_code=400, detail="用户不存在")
        print("验证通过 !!!")
        return RedirectResponse('/index')

    return templates.TemplateResponse("user/login.html", {"request": request})


async def userList(*,request: Request,db: Session = Depends(get_db)):
    userList = db.query(models.User).all()
    return templates.TemplateResponse("user/user-index.html", {"request": request,'userList':userList})

userRouter.add_api_route(methods=['GET','POST'],path="/login",endpoint=login)
userRouter.add_api_route(methods=['GET','POST'],path="/list",endpoint=userList)

其中,methods 是非常熟悉的字眼,写入你想要的 http请求方式,path 指访问时的路径,endpoint 就是后端方法了。

这样就解决了同时存在于多个 http请求方式 的问题啦,编码也更为直观简洁。

数据库

在 FastAPI 中,我们一如既往的使用了 SQLAlchemy

初始化数据库文件:

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

# 创建数据库连接URI
SQLALCHEMY_DATABASE_URL = "mysql+pymysql://root:123456@127.0.0.1:3306/blog"

# 初始化
engine = create_engine(
    SQLALCHEMY_DATABASE_URL
)

# 创建DBSession类型
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# 创建基类 用于继承  也可以放到初始化文件中
Base = declarative_base()

# 获取数据库会话,用于数据库的各种操作
def get_db():
    db = SessionLocal()

数据库模型文件:

from sqlalchemy import Boolean, Column, ForeignKey, Integer, String, DateTime, Text
from sqlalchemy.orm import relationship
from datetime import datetime
from flask_login import  UserMixin
import uuid
from app.database.database import Base


class User(UserMixin,Base):
    __tablename__ = 'user'
    id = Column(Integer, primary_key=True)
    email = Column(String(64),)
    username = Column(String(64), )
    role = Column(String(64), )
    password_hash = Column(String(128))
    head_img = Column(String(128), )
    create_time  = Column(DateTime,default=datetime.now)

    def __repr__(self):
        return '<User %r>' % self.username

# 文章表
class Article(Base):
    __tablename__ = 'article'
    id = Column(Integer, primary_key=True)
    title=Column(String(32))
    author =Column(String(32))
    img_url = Column(Text,nullable=False)
    content=Column(Text,nullable=False)
    tag=Column(String(64),nullable=True)
    uuid = Column(Text,default=uuid.uuid4())
    desc = Column(String(100), nullable=False)
    create_time = Column(DateTime,default=datetime.now)
    articleDetail = relationship('Article_Detail', backref='article')

    def __repr__(self):
        return '<Article %r>' % self.title

async def articleDetailAdd(*,request: Request,db: Session = Depends(get_db),d_content:str,uid:int):
    if request.method == "POST":
        addArticleDetail= Article_Detail(d_content=d_content,uid=uid)
        db.add(addArticleDetail)
        db.commit()
        db.refresh(addArticleDetail)
        print("添加成功 !!!")
        return "添加成功"
    return "缺少参数"

async def articleDetailDel(*,request: Request,db: Session = Depends(get_db),aid:int):
    if request.method == "POST":
        db.query(Article_Detail).filter(Article_Detail.id == aid).delete()
        db.commit()
        print("删除成功 !!!")
        return "删除成功"
    return "缺少参数"

async def articleDetailUpdate(*,request: Request,db: Session = Depends(get_db),aid:int,d_content:str):
    if request.method == "POST":
        articleInfo= db.query(Article_Detail).filter(Article_Detail.id == aid).first()
        print(articleInfo)
        if not articleInfo:
            raise HTTPException(status_code=400, detail="no no no !!")

        articleInfo.d_content = d_content
        db.commit()
        print("提交成功 !!!")
        return "更新成功"
    return "缺少参数"

async def articleDetailIndex(*,request: Request,db: Session = Depends(get_db),):
    articleDetailList = db.query(models.Article_Detail).all()
    return templates.TemplateResponse("articleDetail/articleDetail-index.html", {"request": request,"articleDetailList":articleDetailList})

这里是一些示例的 crud,真正部署的时候可不能这么鲁莽哇,错误的捕捉,数据库的回滚,语句必须严谨。

数据验证

在路由方法中,有个叫 response_model 的参数,用于限制路由方法的返回字段。

官方文档实例:

from fastapi import FastAPI
from pydantic import BaseModel, EmailStr

app = FastAPI()

class UserIn(BaseModel):
    username: str
    password: str
    email: EmailStr
    full_name: str = None


class UserOut(BaseModel):
    username: str
    email: EmailStr
    full_name: str = None


@app.post("/user/", response_model=UserOut)
async def create_user(*, user: UserIn):
    return user

意思是 UserIn 作为请求体参数传入,返回时必须满足 UserOut 模型。

场景的话,可以想象用户登陆时需要传入用户名和密码,用户登陆成功之后在首页上展示用户名的邮件,不展示密码。嗯,这样就合理了。

所以在数据库操作的时候,可以自己定义传入和返回的模型字段来做有效的限制,你只需要继承 pydantic 中的 BaseModel 基类即可,看起来是那么的简单合理。

异常处理

在各种 http资源 不存在或者访问异常的时候都需要有 http状态码 和 异常说明,例如, 404 Not Found 错误,Post请求出现的 422,服务端的 500 错误,所以如何在程序中合理的引发异常,就变得格外重要了。

看看 FastAPI 中如何使用异常处理

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:
        raise HTTPException(status_code=404, detail="Item not found")
    return {"item": items[item_id]}

使用 HTTPException,传入状态码 和 详细说明,在出现逻辑错误时抛出异常。

改写 HTTPException

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse


class UnicornException(Exception):
    def __init__(self, name: str):
        self.name = name


app = FastAPI()


@app.exception_handler(UnicornException)
async def unicorn_exception_handler(request: Request, exc: UnicornException):
    return JSONResponse(
        status_code=418,
        content={"message": f"我家热得快炸了..."},
    )


@app.get("/unicorns/{name}")
async def read_unicorn(name: str):
    if name == "yolo":
        raise UnicornException(name=name)
    return {"unicorn_name": name}

UnicornException 继承自 Python 自带的 Exception 类,在出现服务端错误时抛出 418 错误,并附上错误说明。

自定义自己的异常处理代码

from fastapi import FastAPI, HTTPException
from fastapi.exceptions import RequestValidationError
from fastapi.responses import PlainTextResponse
from starlette.exceptions import HTTPException as StarletteHTTPException

app = FastAPI()


@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request, exc):
    return PlainTextResponse(str(exc.detail), status_code=exc.status_code)


@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request, exc):
    return PlainTextResponse(str(exc), status_code=400)


@app.get("/items/{item_id}")
async def read_item(item_id: int):
    if item_id == 3:
        raise HTTPException(status_code=418, detail="开空调啊")
    return {"item_id": item_id}

合理的使用异常处理机制,能让项目代码更健壮,客户端更友好,也易于维护。

还有吗?

在茫茫的 FastAPI 文档中我尽可能摸索出一些易用,实用,好用的功能来和大家分享,并尝试投入到实际的生产环境中,在这个过程中去学习更多的东西,体验更好的服务性能。

FastAPI 官方文档十分的庞大,有非常多的地方还没有普及和深入,比如 FastAPI 的安全加密,中间件的使用,应用部署等等。哈,来日方长 !!!

需要学习更多关于FastAPI 知识的话,可以戳阅读全部,获取详情:

参考文档:https://fastapi.tiangolo.com/tutorial

——————- End ——————-

往期精彩文章推荐:

看完本文有收获?请转发分享给更多的人

Python爬虫与数据挖掘

入群请在微信后台回复【入群】

在公众号后台回复下列关键词可以免费获取相应的学习资料:

Python、网络爬虫 、书籍、数据分析、机器学习、数据结构、

大数据、服务器、Spark、Redis、C++、C、php、

mysql、java、Android、面试题、课堂、其他

(入门篇)简析Python web框架FastAPI——一个比Flask和Tornada更高性能的API 框架

用官方的话来说,FastAPI 是一种现代,快速(高性能)的 Web 框架,基于标准Python 类型提示使用 Python 3.6+ 构建 API

FastAPI 站在巨人的肩膀上?

很大程度上来说,这个巨人就是指 Flask 框架。

FastAPI 从语法上和 Flask 非常的相似,有异曲同工之妙。

技术背景:Py3.6+,Starlette,Pydantic

其实不仅仅是 FastAPI ,就连 Sanic 也是基于 Flask 快速开发的 Web API 框架。

废话少说,代码总是能给人带来愉悦感 (抱头),直接开怼。

安装

pip install fastapi 
pip install uvicorn

创建一个 main.py 文件

from fastapi import FastAPI

app = FastAPI() # 创建 api 对象

@app.get("/") # 根路由
def root():
    return {"武汉": "加油!!!"}

@app.get("/say/{data}")
def say(data: str,q: int):
    return {"data": data, "item": q}

上面搭建了一个最简单的 FastAPI 应用,看起来和 Flask 完全一样,莫名的喜感。

使用以下命令来启动服务器:

uvicorn main:app --reload

FastAPI 推荐使用 uvicorn 来运行服务,Uvicorn 是基于uvloop 和 httptools 构建的闪电般快速的 ASGI 服务器。

uvicorn main:app 指的是:

main:文件main.py

app: 创建的启用对象

–reload: 热启动,方便代码的开发

启动界面如下:

INFO 信息告诉我们已经监听了本地的 8000 端口,访问 http://127.0.0.1:8000 得到结果

传入参数

再来看看 FastAPI 的异步代码

from fastapi import FastAPI

app = FastAPI() # 创建 api 对象

@app.get("/") # 根路由
async def root():
    return {"武汉": "加油!!!"}

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

开启服务后访问结果是一样的。

在上面的路由方法中,我们传入了一个 q 参数并且初始为 None,如果不给默认值,并且不传参,代码将直接报错。

来看看 FastAPI 是如何处理错误的:

可以看到,即使是报错,也是优美的输入一个带有错误字段的 JSON,这就非常的友好了,这也是体现了 FastAPI 减少更多的人为错误的特性,返回也更加的简洁直观。

在命令行输出:

再来看看 FastAPI 的交互文档

根据官方文档,打开 http://127.0.0.1:8000/docs

看到:

支持动态传入数据:

结果:

从交互体验上也是无比的友好,让代码在生产中更加健壮。

现在我们算是快速的体验了一波 FastAPI 骚操作,从代码上和 Flask 及其的类似,体验性更好。

那么再来看看最新的 Python web框架的性能响应排行版

从并发性上来说是完全碾压了 Flask (实际上也领先了同为异步框架的tornado 不少),看来 FastAPI 也真不是盖的,名副其实的高性能 API 框架呀!

查询参数

先来看看官方小 demo

from fastapi import FastAPI

app = FastAPI()

fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]


@app.get("/items/")
async def read_item(skip: int = 0, limit: int = 10):
    return fake_items_db[skip : skip + limit]

该查询是 ? URL中位于关键字之后的一组键值对,以&字符分隔。

在 url 中进行查询

http://127.0.0.1:8000/items/?skip=0&limit=10

skip:查询的起始参数

limit:查询的结束参数

成功返回查询列表。

查询参数类型转换

FastAPI 非常聪明,足以辨别 路径参数 和 查询参数。

来看看具体的例子:

from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")
async def read_item(item_id: str, q: str = None, short: bool = False):
    item = {"item_id": item_id}
    if q:
        item.update({"q": q})
    if not short:
        item.update(
            {"description": "This is an amazing item that has a long description"}
        )
    return item

看看其访问路径,执行以下的任何一种 url 访问方式

http://127.0.0.1:8000/items/武汉加油?short=1

http://127.0.0.1:8000/items/武汉加油?short=True

http://127.0.0.1:8000/items/武汉加油?short=true

http://127.0.0.1:8000/items/武汉加油?short=on

http://127.0.0.1:8000/items/武汉加油?short=yes

可以发现任何大小写的字母等都会被转换成 bool 值的参数 True,这就是所谓模糊验证参数,对于开发者来说这是个好消息。

要知道的是,如果 short 参数没有默认值,则必须传参,否则 FastAPI 将会返回类似以下的错误信息。

{
    "detail": [
        {
            "loc": [
                "query",
                "needy"
            ],
            "msg": "field required",
            "type": "value_error.missing"
        }
    ]
}

创建数据模型

前面说到 FastAPI 依赖 Pydantic 模块,所以首先,你需要导入 Pydantic 的 BaseModel 类。

from fastapi import FastAPI
from pydantic import BaseModel

# 请求主体类
class Item(BaseModel):
    name: str = "武汉加油 !!"
    description: str = None
    price: float = 233
    tax: float = None


app = FastAPI()


@app.post("/items/")
async def create_item(item: Item):
    return item

发送 post 请求来提交一个 Item(请求主体) 并返回,来看看提交过程。

成功提交并返回 200 状态码

请求主体+路径+查询参数,在请求主体的基础上加入 url 动态路径参数 和 查询参数

from fastapi import FastAPI
from pydantic import BaseModel


class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None


app = FastAPI()


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

put 方法用于更新,传入参数后成功返回一个字典。

关于模板引擎

FastAPI 不像 Flask 那样自带 模板引擎(Jinja2),也就是说没有默认的模板引擎,从另一个角度上说,FastAPI 在模板引擎的选择上变得更加灵活,极度舒适。

以 Jinja2 模板为例

安装依赖

pip install jinja2
pip install aiofiles # 用于 fastapi 的异步静态文件

具体的用法

# -*- coding:utf-8 -*-
from fastapi import FastAPI, Request
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
import uvicorn

app = FastAPI()

app.mount("/static", StaticFiles(directory="static"), name="static") # 挂载静态文件,指定目录


templates = Jinja2Templates(directory="templates") # 模板目录


@app.get("/data/{data}")
async def read_data(request: Request, data: str):
    return templates.TemplateResponse("index.html", {"request": request, "data": data})

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

html 文件渲染

<html>
<head>
    <title>武汉加油</title>
</head>
<body>
    <h1>高呼: {{ data }}</h1>
</body>
</html>

在浏览器键入 http://127.0.0.1:8000/data/武汉加油

值得注意的是,在返回的 TemplateRespone 响应时,必须带上 request 的上下文对象,传入参数放在同一字典。

这样一来,又可以像 Flask 一样的使用熟悉的 Jinja2 了,哈哈。

做个小总结的话就是 FastAPI 在用法上也是及其简单,速度更快,性能更好,容错率更高,整体上更牛逼。但是我在设想如此之快的框架,毕竟发布的时间不长,缺少像 Flask 框架的第三方库和各种插件,所以要想真正意义上替代还是需要一定的时间,要冷静,冷静。

好啊,至此 FastAPI 的一些基本用法就差不多结束啦,FastAPI 的官方文档有详细的介绍和实例,入门篇到此结束。

官方文档:https://fastapi.tiangolo.com/

——————- End ——————-

往期精彩文章推荐:

看完本文有收获?请转发分享给更多的人

Python爬虫与数据挖掘

入群请在微信后台回复【入群】

在公众号后台回复下列关键词可以免费获取相应的学习资料:

Python、网络爬虫 、书籍、数据分析、机器学习、数据结构、

大数据、服务器、Spark、Redis、C++、C、php、

mysql、java、Android、面试题、课堂、其他