Flask——接口路由技术

这篇具有很好参考价值的文章主要介绍了Flask——接口路由技术。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、Flask 简介

Flask 是一个轻量级的 web 开发框架。 它依赖 jinja2 和 Werkzeug WSGI 服务的一个微型框架。

1、环境安装:

pip install flask

2、一个最小的应用

# 1. 导入 Flask 模块
from flask import Flask
# 2. 创建Flask应用程序实例
app = Flask(__name__)

# 3. 定义路由及视图函数
@app.route("/")
def hello_world():
    return "<p>Hello, World!</p>"
# 4. 启动程序
if __name__ == '__main__':
    app.run()

3、两种运行方式

linux/mac: 命令行运行

$ export FLASK_APP=hello
$ flask run

windows: 命令运行

set FLASK_APP=app.py
flask run

代码调用

if name == ‘main’:
app.run()

二、定义路由

1、普通路由

通过装饰器 @app.route 添加路由

from flask import Flask

#2、创建flask应用程序的实例;__name__==__main__
app=Flask(__name__)

#添加路由
@app.route("/")
def hello_world():
    return "<p>hello world</p>"

@app.route("/demo")
def demo():
    return "<p>hello world 666</p>"

#启动入口
if __name__=='__main__':
    #flask服务启动起来
    #轮询等待的方式,等待浏览器发来请求
    #会一直接收请求,直到程序停止
    app.run()

Flask——接口路由技术,flask,flask,python,后端

2、动态路由

通过 app.route('/user/<username>') 添加动态路由

from flask import Flask

#2、创建flask应用程序的实例;__name__==__main__
app=Flask(__name__)

#添加路由
@app.route("/")
def hello_world():
    return "<p>hello world</p>"

@app.route("/demo")
def demo():
    return "<p>hello world 666</p>"

@app.route("/userinfo/<username>")
def demo1(username):
    return f"hello world 这是{username}同学"

#启动入口
if __name__=='__main__':
    #flask服务启动起来
    #轮询等待的方式,等待浏览器发来请求
    #会一直接收请求,直到程序停止
    app.run()

3、限定类型

路径中添加 <类型:变量名> 来限定变量的类型
@app.route('/post/<int:post_id>')

string:接收任何不包含斜杠的文本
int:接收正整数
float:接收正浮点数
path:类似string,但可以包含斜杠
uuid:接收UUID字符串

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2023/5/26 07:03
# @Author  : 杜兰特
# @File    : flask_demo.py

#1、导入flask模块
from log_utils import logger

from flask import Flask

#2、创建flask应用程序的实例;__name__ ==__main__
app=Flask(__name__)

#限定类型
@app.route("/user/<int:id>")
def demo2(id):
    return f"hello world 这是{id}"

@app.route("/user/<string:username>")
def demo3(username):
    return f"hello world 这是{username}同学"

#启动入口
if __name__=='__main__':
    #flask服务启动起来
    #轮询等待的方式,等待浏览器发来请求
    #会一直接收请求,直到程序停止
    app.run()

4、地址尾部的“/”

路由的尾部带有“/”(浏览器的地址栏中输入和不输入“/”的效果一样)

路由的尾部没有“/”(输入的 URL 的结尾不能加“/”,会报错)

#1、导入flask模块
from flask import Flask

#2、创建flask应用程序的实例;__name__ ==__main__
app=Flask(__name__)

#添加路由
@app.route("/demo")
def demo():
    return "<p>hello world 666</p>"

#启动入口
if __name__=='__main__':
    #flask服务启动起来
    #轮询等待的方式,等待浏览器发来请求
    #会一直接收请求,直到程序停止
    app.run()

Flask——接口路由技术,flask,flask,python,后端
Flask——接口路由技术,flask,flask,python,后端

三、请求与响应-请求方法

请求 说明

GET 获取服务器资源
POST 新增服务器资源
PUT 更新服务器资源(客户端提供改变后的完整资源)
DELETE 删除服务器资源

接口设计

查询:get
新增:post
修改:put
删除:delete


#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2023/5/27 00:01
# @Author  : 杜兰特
# @File    : http_request_demo.py
from flask import Flask

app=Flask(__name__)

#methods是列表类型,可以添加多种请求方式。get、post、put、delete
@app.route("/cases",methods=['get'])
def get_case():
    return {"code":0,"msg":"get success"}

@app.route("/cases",methods=['post'])
def post_case():
    return {"code":0,"msg":"post success"}

@app.route("/cases",methods=['put'])
def put_case():
    return {"code":0,"msg":"put success"}

@app.route("/cases",methods=['delete'])
def delete_case():
    return {"code":0,"msg":"delete success"}

if __name__ == '__main__':
    app.run(debug=True)

四、请求与响应-处理请求数据

1、request的常用属性/方法

args:记录请求中的查询参数
json:记录请求中的json数据
files:记录请求上传的文件
form:记录请求中的表单数据
method:记录请求使用的http方法
url:记录请求的URL地址
host:记录请求的域名
headers:记录请求的头信息

2、get 请求参数

场景:普通的 url 链接,接收一个 get 请求
解决办法:request.args

#需要导入request,而不是requests!!!
from flask import Flask,request
from log_utils import logger

app=Flask(__name__)

@app.route('/login',methods=['get'])
def demo1():
    logger.info(f"请求参数为:{request.args}")
    a=request.args.get("a")
    b=request.args.get("b")
    logger.info(f"a的值为{a},b的值为{b}")
    return {"code":0,"msg":"get success"}

if __name__ == '__main__':
    app.run(debug=True)
127.0.0.1 - - [27/May/2023 09:03:29] "GET /login HTTP/1.1" 200 -
[2023-05-27 09:04:04] [INFO] [flask_param_demo.py]/[line: 17]/[demo1] 请求参数为:ImmutableMultiDict([('a', '88'), ('b', '66')]) 
[2023-05-27 09:04:04] [INFO] [flask_param_demo.py]/[line: 20]/[demo1] a的值为88,b的值为66 

3、json 请求

场景:POST 相关的请求,带有 json 数据格式
解决办法:request.json

#需要导入request,而不是requests!!!
from flask import Flask,request
from log_utils import logger

app=Flask(__name__)

@app.route('/register',methods=['post'])
def demo2():
    logger.info(f"请求参数为:{request.json}")
    data=request.json.get("time")
    logger.info(f"时间为{data}")
    return {"code":0,"msg":"post success"}

if __name__ == '__main__':
    app.run(debug=True)
[2023-05-27 09:05:55] [INFO] [flask_param_demo.py]/[line: 26]/[demo2] 请求参数为:{'time': '2023-05-27', 'status': 'success'} 
[2023-05-27 09:05:55] [INFO] [flask_param_demo.py]/[line: 28]/[demo2] 时间为2023-05-27 

4、表单请求

场景:比如:测试人网站的登录接口,需要用户名和密码,前端会提交一个 form 表单给后台
解决办法:request.form

#需要导入request,而不是requests!!!
from flask import Flask,request
from log_utils import logger

app=Flask(__name__)

@app.route('/register',methods=['put'])
def demo3():
    logger.info(f"请求参数为:{request.form}")
    name=request.form.get("name")
    password=request.form.get("password")
    email=request.form.get("email")
    logger.info(f"请求参数name为:{name},password为:{password},email为;{email}")
    return {"code": 0, "msg": "put success"}

if __name__ == '__main__':
    app.run(debug=True)
[2023-05-27 09:07:42] [INFO] [flask_param_demo.py]/[line: 34]/[demo3] 请求参数为:ImmutableMultiDict([('name', 'kobe'), ('password', '666666'), ('email', '77777')]) 
[2023-05-27 09:07:42] [INFO] [flask_param_demo.py]/[line: 38]/[demo3] 请求参数name为:kobe,password为:666666,email为;77777 

5、文件请求

场景:
页面上有个更新头像的功能, 或者上传一个 excel 文件的功能, 允许我们提交一个图片,或者文件到后端服务器,那么
解决方法:
request.files.get(‘file’) 获取文件对象
filename 获取文件对象的文件名
save()方法 保存文件到指定路径下
Flask——接口路由技术,flask,flask,python,后端

#需要导入request,而不是requests!!!
from flask import Flask,request
from log_utils import logger


app=Flask(__name__)

@app.route('/file',methods=['post'])
def demo4():
    logger.info(f"请求方法为:{request.method}")
    logger.info(f"请求url为:{request.url}")
    logger.info(f"请求host为:{request.host}")
    logger.info(f"请求headers为:{request.headers}")
    fileobj=request.files.get("name")
    logger.info(f"fileobj的值为:{fileobj}")
    logger.info(f"文件名为:{fileobj.filename}")
    #保存文件
    fileobj.save(f"./{fileobj.filename}")
    return {"code": 0, "msg": "file success"}

if __name__ == '__main__':
    app.run(debug=True)
[2023-05-27 09:10:10] [INFO] [flask_param_demo.py]/[line: 43]/[demo4] 请求方法为:POST 
[2023-05-27 09:10:10] [INFO] [flask_param_demo.py]/[line: 44]/[demo4] 请求url为:http://127.0.0.1:5000/file 
[2023-05-27 09:10:10] [INFO] [flask_param_demo.py]/[line: 45]/[demo4] 请求host为:127.0.0.1:5000 
[2023-05-27 09:10:10] [INFO] [flask_param_demo.py]/[line: 46]/[demo4] 请求headers为:User-Agent: PostmanRuntime/7.32.2
Accept: */*
Postman-Token: 593d536e-4bbd-45a2-89be-d8670f66aa42
Host: 127.0.0.1:5000
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Type: multipart/form-data; boundary=--------------------------624583842625202752710421
Content-Length: 10016

 
[2023-05-27 09:10:10] [INFO] [flask_param_demo.py]/[line: 48]/[demo4] fileobj的值为:<FileStorage: '员工用车导入模板 (2).xlsx' ('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')> 
[2023-05-27 09:10:10] [INFO] [flask_param_demo.py]/[line: 49]/[demo4] 文件名为:员工用车导入模板 (2).xlsx 
127.0.0.1 - - [27/May/2023 09:10:10] "POST /file HTTP/1.1" 200 -

五、请求与响应-处理响应信息

1、文本型

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2023/5/27 09:27
# @Author  : 杜兰特
# @File    : http_response_demo.py

from flask import Flask
from flask import jsonify,render_template,make_response

app=Flask(__name__)

#返回文本
@app.route("/text")
def demo():
    return "文本信息"

if __name__ == '__main__':
    app.run(debug=True)

2、元组

返回元组
(response, status)
(response, headers)
(response, status, headers)
响应状态码默认为 200

from flask import Flask
from flask import jsonify,render_template,make_response

app=Flask(__name__)


#返回元组
@app.route("/tuple")
def tuple_res():
    return 'hello',200,{"status": 0, "type": "success"}


if __name__ == '__main__':
    #host
    #port
    #debug=True:热加载,方便调试
    app.run(debug=True)

Flask——接口路由技术,flask,flask,python,后端

3、Json

直接返回 dict 会转换为 json
使用jsonify()方法,通过参数传入键值对

from flask import Flask
from flask import jsonify,render_template,make_response

app=Flask(__name__)

#返回字典
@app.route("/dict")
def get_dict_res():
    return {"status":0}

@app.route("/json")
def get_json_res():
    #return jsonify({"status":0})
    #或者
    return jsonify(status=1,name="kobe")

if __name__ == '__main__':
    #host
    #port
    #debug=True:热加载,方便调试
    app.run(debug=True)

4、html

使用模板渲染技术
html 文件必须在同级的 templates 目录下

from flask import Flask
from flask import jsonify,render_template,make_response

app=Flask(__name__)


@app.route("/html")
def get_html():
    return render_template("demo.html")


if __name__ == '__main__':
    #host
    #port
    #debug=True:热加载,方便调试
    app.run(debug=True)

5、额外数据

设置额外数据-make_response()
添加更多的响应信息

设置 cookie
设置响应头信息等

from flask import Flask
from flask import jsonify,render_template,make_response

app=Flask(__name__)

@app.route("/")
def index():
    resp=make_response(render_template("demo.html"))
    #设置cookie
    resp.set_cookie("user","jimi")
    #设置响应头信息
    resp.headers["type"]="kobe"
    return resp

if __name__ == '__main__':
    #host
    #port
    #debug=True:热加载,方便调试
    app.run(debug=True)

Flask——接口路由技术,flask,flask,python,后端
Flask——接口路由技术,flask,flask,python,后端

六、测试平台环境配置

监听的主机

设置 host 参数
127.0.0.1 只能本机访问
0.0.0.0 服务发布到局域网

app.run(host="0.0.0.0")

监听的端口
设置 port 参数(默认端口号 5000)

app.run(host="0.0.0.0", port=5000)

Debug 模式
设置 debug=True(默认是 production)

实现热加载
开发调试方便

app.run(host="0.0.0.0", port=5000,debug=True)

七、接口配置

1、flask-restx 介绍

官方文档:https://github.com/python-restx/flask-restx
flask-restx 是一个支持 RESTFUL 的 flask 插件,用于规范化接口的编写,并且支持 swagger 文档。

2、插件安装

pip install flask-restx

3、demo 示例

from flask import Flask
#from flask_restful import Resource,Api
from flask_restx import Resource,Api

app=Flask(__name__)

#1、创建api实例对象
api=Api(app)

#2、使用api添加路由
@api.route('/hello')
class HelloWorld(Resource):     #3、类要继承Resource
    #4、定义restful风格的get方法
    def get(self):
        return {'hello':'world'}

    # restful风格的post方法
    def post(self):
        return {'post':'success'}

if __name__ == '__main__':
    app.run(debug=True)

Flask——接口路由技术,flask,flask,python,后端

八、接口使用

1、设计框架的原则

复用性
高内聚,低藕合

a、高耦合实例

问题:判断条件过多,业务逻辑非常复杂

@app.route("/testcase",methods=["GET","PUT","POST"])
def select_case():
    ### request:Request
    if request.method == "GET":
        pass
    elif request.method == "PUT":
        pass

b、低内聚示例

问题:同一个路径,对应多个请求方法,代码没有复用

# get 请求
@app.route("/testcase",methods=["get"])
def select_case():
    # request:Request
    # m = request.method
    print(dir(request))
    return {"code": 0, "msg":"get success"}

# post 请求
@app.route("/testcase",methods=["post"])
def post_case():
    return {"code": 0, "msg":"post success"}

# delete 请求
@app.route("/testcase",methods=["delete"])
def delete_case():
    return {"code": 0, "msg":"delete success"}


# put 请求
@app.route("/testcase",methods=["put"])
def put_case():
    return {"code": 0, "msg":"put success"}

2、编写 RESTFUL 风格的接口

导入from flask_restx import Resource,Api
app=Flask(name) 创建app实例对象
api=Api(app) 创建api实例对象
使用api添加路由
类要继承Resource
定义restful风格的方法

from flask import Flask
#from flask_restful import Resource,Api
from flask_restx import Resource,Api

app=Flask(__name__)

#1、创建api实例对象
api=Api(app)

#2、使用api添加路由
#@api.route('/user','/user1','/user2')  添加多个路由
@api.route('/user')
class User(Resource):     #3、类要继承Resource
    #4、定义restful风格的get方法
    def get(self,id):
        return {"id":id,'code':0,"msg":"get success"}

    # restful风格的post方法
    def post(self):
        return {'code':0,"msg":"post success"}

    # restful风格的put方法
    def put(self):
        return {'code':0,"msg":"put success"}

    # restful风格的delete方法
    def delete(self):
        return {'code':0,"msg":"delete success"}


api.add_resource(User,'/user/<int:id>','/user_1')

if __name__ == '__main__':
    app.run(debug=True)

3、添加路由的方式

方式一:

添加多个路由
@api.route('/user','/user1','/user2')

@api.route('/user','/user1','/user2')  添加多个路由
@api.route('/user')
class User(Resource):

方式二

api.add_resource(User,'/user/<int:id>','/user_1')

九、集成swagger

1、namespace 的使用

定义 Namespace 实例
为类添加装饰器 @namespace.route(“”) 控制子路由
为命名空间指定访问资源路径 api.add_namespace(case_ns, ‘/case’)

from flask import Flask
from flask_restx import Api,Resource,Namespace

app=Flask(__name__)
api=Api(app)

#定义了2个命名空间
hello_ns=Namespace("demo",description="demo学习")
case_ns=Namespace("case",description="用例管理")

#将api.route("case")  改为:case_ns.route("/case")
#@case_ns.route("") 定义子路由,如果没有的话,传空字符串即可
@case_ns.route("")
class TestCase(Resource):

    def get(self):
        pass

    def post(self):
        pass

    def put(self):
        pass

    def delete(self):
        pass


@hello_ns.route("/demo")	#子路由
class Demo(Resource):

    def get(self):
        pass

    def post(self):
        pass

    def put(self):
        pass

    def delete(self):
        pass

api.add_namespace(hello_ns,"/hello")
api.add_namespace(case_ns,"/case")

if __name__ == '__main__':
    app.run(debug=True)

2、swagger 接口文档配置

定义参数 parser = api.parser()
传递及校验参数 @api.expect(parser) 或者 @namespace.expect(parser)

a、api.parser()用法

格式:api.parser().add_argument(参数名, 关键字参数)
第一个参数是参数名
后面是关键字传参,常用的关键字有:
type :类型
required 约束控制
choices 枚举参数
location 对应 request 对象中的属性

参数名 参数值
type int,bool,float,string,FileStorage
required True/False
choices 枚举
location args,form,json,files

b、get 请求示例

from flask import Flask, request
from flask_restx import Resource, Api, Namespace,fields
from log_utils import logger
from werkzeug.datastructures import FileStorage

app = Flask(__name__)
api = Api(app)
hello_ns = Namespace("demo", description="demo学习")

@hello_ns.route("")
class Demo(Resource):
    #定义parser解析器对象
    get_parser = api.parser()
    #通过parser对象添加测试参数
    get_parser.add_argument('id',
                            type=int,
                            location="args",
                            required=True)

    get_parser.add_argument('case_title',
                            type=str,
                            location="args",
                            required=True)

    @hello_ns.expect(get_parser)
    def get(self):
        logger.info(f"request.args ===>{request.args}")
        return {"code": 0, "msg": "get success"}


api.add_namespace(hello_ns,"/hello")

if __name__ == '__main__':
    app.run(debug=True)

接口文档如下

Flask——接口路由技术,flask,flask,python,后端

c、post 请求示例

1、处理 json 格式
from flask import Flask, request
from flask_restx import Resource, Api, Namespace,fields
from log_utils import logger
from werkzeug.datastructures import FileStorage

app = Flask(__name__)
api = Api(app)
hello_ns = Namespace("demo", description="demo学习")

@hello_ns.route("")
class Demo(Resource):
    
    post_parser=api.parser()
    post_parser.add_argument("id",type=int,location="json",required=True)
    post_parser.add_argument("casetitle",type=str,location="json",required=True)


    @hello_ns.expect(post_parser)
    def post(self):
        logger.info(f"request.json ===>{request.json}")
        return {"code": 0, "msg": "post success"}


api.add_namespace(hello_ns,"/hello")

if __name__ == '__main__':
    app.run(debug=True)

Flask——接口路由技术,flask,flask,python,后端

2、处理 files格式
from flask import Flask, request
from flask_restx import Resource, Api, Namespace,fields
from log_utils import logger
from werkzeug.datastructures import FileStorage

app = Flask(__name__)
api = Api(app)
hello_ns = Namespace("demo", description="demo学习")

@hello_ns.route("")
class Demo(Resource):
    
    post_parser=api.parser()
    post_parser.add_argument("file",type=FileStorage,location="files",required=True)

    @hello_ns.expect(post_parser)
    def post(self):
        logger.info(f"request.files ===>{request.files}")
        return {"code": 0, "msg": "post success"}


api.add_namespace(hello_ns,"/hello")

if __name__ == '__main__':
    app.run(debug=True)

Flask——接口路由技术,flask,flask,python,后端
请求接口
Flask——接口路由技术,flask,flask,python,后端

3、处理 form格式
from flask import Flask, request
from flask_restx import Resource, Api, Namespace,fields
from log_utils import logger
from werkzeug.datastructures import FileStorage

app = Flask(__name__)
api = Api(app)
hello_ns = Namespace("demo", description="demo学习")

@hello_ns.route("")
class Demo(Resource):
    
    post_parser=api.parser()
    post_parser.add_argument("param1",help="username",type=int,location="form",required=True)
    post_parser.add_argument("param2",help="password",type=int,location="form",required=True)

    @hello_ns.expect(post_parser)
    def post(self):
        logger.info(f"request.form ===>{request.form}")
        return {"code": 0, "msg": "post success"}


api.add_namespace(hello_ns,"/hello")

if __name__ == '__main__':
    app.run(debug=True)

Flask——接口路由技术,flask,flask,python,后端

[2023-05-28 22:04:04] [INFO] [swagger_demo2.py]/[line: 53]/[post] request.form ===>ImmutableMultiDict([('param1', '24'), ('param2', '123567')]) 
127.0.0.1 - - [28/May/2023 22:04:04] "POST /hello HTTP/1.1" 200 -
4、处理choice格式
from flask import Flask, request
from flask_restx import Resource, Api, Namespace,fields
from log_utils import logger
from werkzeug.datastructures import FileStorage

app = Flask(__name__)
api = Api(app)
hello_ns = Namespace("demo", description="demo学习")

@hello_ns.route("")
class Demo(Resource):
    
    post_parser=api.parser()
    post_parser.add_argument("choice", location="args", required=True,choices=(1,2,3,4))

    @hello_ns.expect(post_parser)
    def post(self):
        logger.info(f"request.args ===>{request.args}")
        return {"code": 0, "msg": "post success"}


api.add_namespace(hello_ns,"/hello")

if __name__ == '__main__':
    app.run(debug=True)
[2023-05-28 22:06:14] [INFO] [swagger_demo2.py]/[line: 54]/[post] request.args ===>ImmutableMultiDict([('choice', '2')]) 
127.0.0.1 - - [28/May/2023 22:06:14] "POST /hello?choice=2 HTTP/1.1" 200 -

十、orm介绍

1、什么是持久化

持久化(Persistence) 即把数据保存到可永久保存的存储设备中(如磁盘)。持久化的主要应用是将内存中的数据存储在关系型的数据库中。当然也可以存储在磁盘文件中、XML数据文件中等等。

2、什么是 ORM

Object Relational Mapping 对象关系映射
作用是在关系型数据库和对象之间做一个映射,这样在具体操作数据库的时候,就不需要再去和复杂的 SQL 语句打交道,只要像平时操作对象一样操作就可以了
Flask——接口路由技术,flask,flask,python,后端

3、ORM 与 SQL 的对比

# 使用sql语句查询数据
sql = "SELECT
username, email, gender
FROM User  WHERE id = 1"

# 执行sql 代码
res = db.execSql(sql);

# 取出数据
name = res[0]
# 使用orm 查询数据,定义ORM对象,get 值 ,
res = db.session.query(\
    User.username, User.email, User.gender).\
    filter(User.id==1).first()
name = res.username

Flask——接口路由技术,flask,flask,python,后端

4、ORM 优缺点

优势:

隐藏了数据访问细节
ORM 使我们构造固化数据结构变得非常简单

缺点:

性能下降 ,添加了关联操作,性能不可避免的会下降一些
无法解决特别复杂的数据库操作

十一、orm中间件配置

from flask import Flask
# 实例化 Flask的类,并且绑定module
from flask_sqlalchemy import SQLAlchemy
# 实例化 Flask
app=Flask(__name__)
# mysql 数据库用户名
username="root"
# mysql 数据库密码
pwd="root"
# mysql 数据库的 host 地址
ip="127.0.0.1"
# mysql 数据库端口
port="3306"
# 代码使用的数据库名
datebase="demo"
# 设置mysql 链接方法是
app.config['SQLALCHEMY_DATABASE_URL']=f"mysql+pymysql://{username}:{pwd}@{ip}:{port}/{database}?charset=utf-8"
# 定义应用使用数据库的配置
# 设置SQLALCHEMY_TRACK_MODIFICATIONS参数 不设置该配置的时候会抛出警告
app.config['SQLALCHEMY_TRACK_MODIFICATIONS']=True
# 将 app 与 Flask-SQLAlchemy 的 db 进行绑定
db=SQLAlchemy(app)

十二、数据库与表管理

Flask-SQLAlchemy 数据库连接的配置

app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://username:password@host:port/database'

database:
  username: root
  password: root
  server: 127.0.0.1:3306
  db: flask_1

定义数据库的表 需要继承 db.Model,db 为 app 启动的时的 SQLAlchemy 绑定的实例
类名,相当于表名
驼峰命名的类名,转为下划线连接。例如 class UserInfo 建立的表名为 user_info
自定义表名,__tablename__= 自定义的表名

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2023/5/28 22:37
# @Author  : 杜兰特
# @File    : sqlachemy_demo.py

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
# 实例化app 对象
from sqlalchemy import *
import yaml

app = Flask(__name__)
with open("./data.yaml") as f :
    result = yaml.safe_load(f)
    username = result.get("database").get('username')
    password = result.get("database").get('password')
    server = result.get("database").get('server')
    db = result.get("database").get('db')
app.config['SQLALCHEMY_DATABASE_URI'] = \
    f"mysql+pymysql://{username}:{password}@{server}/{db}?charset=utf8"
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
# SQLAlchemy 绑定app
db = SQLAlchemy(app)

# 定义数据库的表 需要继承 db.Model,db 为 app 启动的时的 SQLAlchemy 绑定的实例

# 类名,相当于表名
#驼峰命名的类名,转为下划线连接。例如 class UserInfo 建立的表名为 user_info
#自定义表名,__tablename__= 自定义的表名
class User(db.Model):
    __tablename__="User"    #指定表名
    id = Column(Integer, primary_key=True)
    username = Column(String(80))

class StudentInfo(db.Model):
    id = Column(Integer, primary_key=True)
    username = Column(String(80))

if __name__ == '__main__' :
    #可以创建多个表
    db.create_all()

    #db.drop_all()

创建表操作

可以创建多个表
db.create_all()

删除表操作

db.drop_all()

十三、对象与数据模型

1、数据模型

数据模型(Data Model)是数据特征的抽象,它从抽象层次上描述了系统的静态特征、动态行为和约束条件,为数据库系统的信息表示与操作提供一个抽象的框架。

2、设计用户表字段

Flask——接口路由技术,flask,flask,python,后端

3、Flask-SQLAlchemy 的属性字段定义

通常类的属性相当于表的一个字段
定义的属性的方式为 name=Column(参数的类型, 其他的属性)
官方:https://flask-sqlalchemy.palletsprojects.com/en/2.x/models/?highlight=column

参数类型 含义
Integer 整型字段定义
String(20) 字符串字段定义,括号为字符串的最大长度
JSON json 字符串字段
DateTime 时间格式字段

4、Flask-SQLAlchemy 字段常用关键字参数

参数类型 含义
primary_key 是否主键
autoincrement 是否自增
nullable 是否允许为空
unique 是否允许重复
default 默认值

5、Flask-SQLAlchemy 对象与数据模型示例

每一个类变量表示一个数据库表的列名
第一个参数是表示数据的类型, primary_key=True 表示是主键
unique = True 表示是不能重复的
nullable=False 表示不可以为空

from sqlalchemy import *
from flask_sqlalchemy import SQLAlchemy
import yaml
# 导入 Query 以便于调用的时候代码提示
from sqlalchemy.orm import Query
from flask import Flask
app = Flask(__name__)

with open("./data.yaml") as f :
    result = yaml.safe_load(f)
    username = result.get("database").get('username')
    password = result.get("database").get('password')
    server = result.get("database").get('server')
    db = result.get("database").get('db')
app.config['SQLALCHEMY_DATABASE_URI'] = \
    f"mysql+pymysql://{username}:{password}@{server}/{db}?charset=utf8"
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
# SQLAlchemy 绑定app
db = SQLAlchemy(app)

# 定义数据库的表 需要继承 db.Model
class User(db.Model):
    __tablename__ = "user" # 设置数据库表名
    # 每一个类变量表示一个数据库表的列名
    # 第一个参数是表示数据的类型, primary_key=True 表示是主键
    id = Column(Integer, primary_key=True)
    # unique = True 表示是不能重复的  nullable=False 表示不可以为空
    username = Column(String(80), unique=False, nullable=False)
    email = Column(String(120), unique=True, nullable=False)
    gender = Column(String(3),unique=False)

    def __repr__(self):
        # 数据库的 魔法方法 直观展示数据
        '''[<User "张三">,<User "李四">]'''
        return f'<User {self.username}>'

十四、数据CRUD

1、添加数据(create)

a、单条数据新增

实例化类,创建表数据
将实例添加到 session(add)
提交更新 (commit)
关闭 session

# 新增表数据,需要导入 User 类,进行实例化
user=User(id=1,username="kobe",email="111@qq.com",gender="男")
print(user)
db.session.add(user)
db.session.commit()
db.session.close()

b、多条数据新增

多次实例化类,创建多条表数据
将多个实例依次添加到 session 中(add)或者一次性添加到 session 中(add_all)
提交更新 (commit)
关闭 session

# 批量添加数据操作
user1 = User(username="kobe1", email="1113@qq.com", gender="男")
user2 = User(username="kobe2", email="1114@qq.com", gender="女")
db.session.add_all([user1,user2])
db.session.commit()
db.session.close()

2、读取数据(read)

a、查询表中全部数据

格式:类.query.all()

# 读取全部数据
res = User.query.all()
# 遍历数据,得到想要的字段
for rs in res:
    print(rs.username, rs.email)

b、条件查询——单条件查询

格式:类.query.filter_by(条件).单条或多条

查询单条数据:类.query.filter_by(条件).first()

res=User.query.filter_by(gender='男').first()
print(res)

查询多条数据:类.query.filter_by(条件).all()

res_list=User.query.filter_by(gender="男").all()
print(res_list)

c、条件查询——多条件查询

查询单条数据:类.query.filter_by(条件).filter_by(条件)…first()

res1=User.query.filter_by(gender="男").filter_by(username="kobe1").first()
print(res1)

查询多条数据:类.query.filter_by(条件).filter_by(条件)…all()

res2 = User.query.filter_by(gender="男").filter_by(username="kobe1").all()
print(res2)

3、修改数据(update)

方式一:
首先查询出来需要的数据
对查询出来的数据对象进行属性的修改
提交 session

user3=User.query.filter_by(id=2).first()
user3.gender="女"
db.session.commit()
db.session.close()

方式二:
给定查询条件进行查询后,直接进行 update 操作
提交 session

res4=User.query.filter_by(id=3).update({"username":"butler"})
db.session.commit()
db.session.close()

4、删除数据(delete)

方式一:
查询数据
对查询出来的数据对象进行删除操作
提交 session

user5=User.query.filter_by(id=1).first()
db.session.delete(user5)
db.session.commit()
db.session.close()

方式二:
给定查询条件进行查询后,直接进行 delete 操作
提交 session

user5=User.query.filter_by(id=2).delete()
db.session.commit()
db.session.close()

十五、多表关系-一对多

1、一对多关系

场景:
一个班级有多个学生
一个学生只在一个班级
一对多关系中,通过外键来关联数据,外键设置在多的一方

SQLAlchemy提供了一个relationship,这个类可以定义属性,以后在访问相关联的表的时候就直接可以通过属性访问的方式就可以访问得到了。另外,可以通过backref来指定反向访问的属性名称。

特别注意:
classinfo=db.relationship(‘ClassInfo’,backref=“studentinfo”):代表学生所属的班级信息,backref:反向关联的属性名,classinfo=db.relationship(‘ClassInfo’,backref=“studentinfo”):中的ClassInfo必须是另外一个相关联的类名

from sqlalchemy import *
from flask_sqlalchemy import SQLAlchemy
import yaml
# 导入 Query 以便于调用的时候代码提示
from sqlalchemy.orm import Query
from flask import Flask
app = Flask(__name__)

with open("../data.yaml") as f :
    result = yaml.safe_load(f)
    username = result.get("database").get('username')
    password = result.get("database").get('password')
    server = result.get("database").get('server')
    db = result.get("database").get('db')
app.config['SQLALCHEMY_DATABASE_URI'] = \
    f"mysql+pymysql://{username}:{password}@{server}/{db}?charset=utf8"
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
# SQLAlchemy 绑定app
db = SQLAlchemy(app)


# 班级表
class ClassInfo(db.Model):
    __tablename__ = "Class"
    id = Column(Integer, primary_key=True)
    name = Column(String(80))

    def __repr__(self):
        return f"<Class:{self.name}>"

# 学生表
class StudentInfo(db.Model):
    # 指定表名__tablename__属性
    __tablename__ = "Student"
    id = Column(Integer, primary_key=True)
    name = Column(String(80))
    #添加外键
    classid = Column(Integer, ForeignKey("Class.id"))

    # 第一个参数:表示这个关系的另一端是 ClassInfo 类。比如班级id=1
    # 第二个参数:backref, 表示反向引用,需要从班级id为1 反向获取【多】的时候,使用的属性
    # 通过ClassInfo实例.studentinfo
    classinfo=db.relationship('ClassInfo',backref="studentinfo")

    def __repr__(self):
        return f"<Student:{self.name}>"

2、一对多表结构

创建表
db.create_all()
删除表
db.drop_all()

3、一对多增删查改

a、数据新增

Class 班级表:添加两条数据

class1 = ClassInfo(id=1, name="测开21期")
class2 = ClassInfo(id=2, name="测开22期")
db.session.add_all([class1, class2])
db.session.commit()
db.session.close()

要先完全创建好,数据库中的班级表,再去创建学生表
Student 学生表:添加两条数据

student1 = StudentInfo(id=1, name="学生一", classid=1)
student2 = StudentInfo(id=2, name="学生二", classid=1)
student3 = StudentInfo(id=3, name="学生三", classid=2)
student4 = StudentInfo(id=4, name="学生四", classid=2)
db.session.add_all([student1, student2,student3, student4])
db.session.commit()
db.session.close()

b、数据查询

多查一

通过学生id=1 查询学生所在的班级

stu1=StudentInfo.query.filter_by(id=1).first()
#获取classid信息
print(stu1.classid)
print(stu1.classinfo)
print(stu1.classinfo.name)
一查多

通过班级id=1,查询对应的学生

class1=ClassInfo.query.filter_by(id=1).first()
print(class1.studentinfo)
print(class1.studentinfo[0].name)

c、数据修改

一改多

通过班级修改学生信息

class1=ClassInfo.query.filter_by(id=1).first()
print(class1.studentinfo)
class1.studentinfo[0].name="学生修改1"
db.session.commit()
db.session.close()
多改一

通过学生修改班级信息

stu2=StudentInfo.query.filter_by(id=2).first()
print(stu2.classinfo)
stu2.classinfo.name="pythonvip"
db.session.commit()
db.session.close()

d、数据删除

删除一个班级下的所有学生文章来源地址https://www.toymoban.com/news/detail-744596.html

class1=ClassInfo.query.filter_by(id=1).first()
StudentInfo.query.filter(StudentInfo.classid==class1.id).delete()
db.session.commit()
db.session.close()

到了这里,关于Flask——接口路由技术的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • python基于flask实现swagger在线文档以及接口测试

    阅读对象:知道什么是restful,有了解swagger或者openAPI更佳。 Representional State Transfer(REST):表征状态转移。是一种一种基于HTTP协议的架构。采用Web 服务使用标准的 HTTP 方法 (GET/PUT/POST/DELETE) 将所有 Web 系统的服务抽象为资源。 如果REST满足一定条件(C/S、无状态、分层系统、

    2024年02月12日
    浏览(40)
  • python3-Flask实现Api接口

    1、:python3-Flask实现Api接口_flask api_Shiro to kuro的博客-CSDN博客 2、  Flask框架的web开发01(Restful API接口规范)_flask patch post_~须尽欢的博客-CSDN博客

    2024年02月11日
    浏览(29)
  • python+flask+eventSource打造流式chatGPT生成式API接口

    后端用python,前端用web,怎么打通chatGPT API连接? 如果你遇到这样的情况: 科学上网登chat.openai.com开启一个新聊天,总是出现网页错误,刷新几次就没有对话的想法了。 获取了chatGPT的APIkey,用网上一大堆PHP/JSP/CURL的代码去试,效果很差,不是反应慢,就是兼容性不好。 用

    2024年02月04日
    浏览(47)
  • 手把手教你使用Flask框架构建Python接口以及如何请求该接口

    Flask是一个轻量级的Web应用框架,基于Python编写,其核心思想是保持简洁,灵活性和易于扩展。 Flask是一个轻量级的Web应用框架,基于Python编写,其核心思想是保持简洁,灵活性和易于扩展。Flask提供了基本的Web开发工具和应用程序的结构,但同时也允许开发者自由选择其他库

    2024年02月06日
    浏览(103)
  • 人生苦短,我用Python 九:Flask接口并发处理:多进程、多线程

    Windows 我现在有一个flask接口文件,我有个需求:, 让这个接口可以并发处理10个请求任务,每个任务中有7个子线程任务,这7个子线程任务,为的是加快,每个请求任务的处理速度。 进程是操作系统中的一个基本概念,用于描述正在运行的程序。简单来说,进程是计算机中正

    2024年02月11日
    浏览(39)
  • 后端框架flask学习小记

    最近在和几个伙伴尝试搭建一个新闻推荐系统, 算是一个推荐算法的实战项目, 里面涉及到了前后端交互, 该项目里面,使用了Flask作为后台框架, 为了理清楚整个系统的交互,所以就快速参考着资料学习了下flask, 主要还是参考伙伴们写的flask简介和基础的内容, 加上了

    2023年04月27日
    浏览(42)
  • 视觉学习(七)---Flask 框架下接口调用及python requests 实现json字符串传输

    在项目实施过程中需要与其他系统进行接口联调,将图像检测的结果传递给其他系统接口,进行逻辑调用。这中间的过程可以通过requests库进行实现。 1.安装requests库 2.postman 接口测试 我们先通过postman 了解下接口调用,通过postman新增一个接口: 新增Collection -- 选中Collection,右

    2024年02月13日
    浏览(44)
  • Python爬虫技术系列-03/4flask结合requests测试静态页面和动态页面抓取

    flask内容参考:Flask框架入门教程(非常详细) 安装flask 创建一个webapp.py文件,内容如下 运行代码 终端输出如下: 在浏览器输入 返回如下 创建webapp_html_str.py文件,代码如下: 运行 运行代码 在浏览器输入 返回如下 返回一个静态html页面 在工程目录下,创建一个templates目录,在

    2024年02月04日
    浏览(45)
  • 搭建flask后端和微信小程序前端

    目录 一、准备工作 (1)我的前端代码 (2)我的后端代码 (3)后端运行成功的截图 (4)前端运行成功的截图  (5)整体运行成功的截图 二、部署后端  (1)在腾讯云的学生入口处购买服务器(建议选择ubuntu系统),设置管理秘钥,方便在本地远程连接。 (2)在本地的

    2024年02月04日
    浏览(52)
  • Flask源码篇:Flask路由规则与请求匹配过程

    源码系列: Flask源码篇:wsgi、Werkzeug与Flask启动工作流程 Flask源码篇:2w字彻底吃透Flask是上下文原理 如果不想看具体的解析过程,可以直接看总结,一样可以看懂! 所谓的路由原理,就是Flask如何创建自己的路由体系,并当一个请求到来时,如何根据路由体系准确定位处理函

    2023年04月08日
    浏览(30)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包