Flask基础
虚拟环境解决的问题
我们都是通过pip install x方式安装
我们用新版本和旧版本冲突，可以通过虚拟环境解决
虚拟环境原理
虚拟环境相当于一个抽屉，在这个抽屉中安装的任何软件包都不会影响 到其他抽屉。并且在项目 中，我可以指定这个项目的虚拟环境来配合我的项目。比如我们现在有一个项 目是基于 Flask 1.0.x 版本，又有一个项目是基于 Flask 0.9.x 的版本， 那么这时候就可以创建两个虚拟环境，在这两个虚拟环境中分别安装 Flask 1.0.x 和 Flask 0.9.x 来适配我们的项目
安装virtualenv
pip install virtualenv
创建虚拟环境
virtualenv [虚拟环境名字]
momo_env
简单的理解为在当前目录下创建好了一个文件夹，文件中有一堆东西而 已
进入环境
虚拟环境创建好后，可以进入到这个虚拟环境，然后安装第三方包
-
windows 进入虚拟环境，进入到scripts文件夹，执行activate
-
Linux 、 Unix ： 进 入 虚 拟 环 境 ： source /path/to/virtualenv/bin/activate 一旦你进入到了这个虚拟环境中，你安装包，卸载包都是在这个虚拟环境中，不会影响到外面
-
deactivate 退出虚拟环境
创建虚拟环境时候指定python解释器
通过 -p 参数指定
virtualenv -p [python 的根目录，也就是环变量]
问题 1：使用 virtualenv 创建环境的时候，当前目录在哪儿就在哪儿创建，会
导致以后到处都是（C 盘 D 盘）环境，不便管理。
问题 2：需要记住环境目录所在，并使用 cd 命令 有可能 多次进入指定环境才
能激活，过程有点繁琐，
不便操作
virtualenvwrapper的安装使用
virtualenvwrapper 这个软件包可以让我们管理虚拟环境变得更加简单。不用 再跑到某个目录下通 过 virtualenv 来创建虚拟环境，并且激活的时候也要跑到具体的目录下去激 活
安装
Linux pip install virtualenvwrapper-win
Win pip install virtualenvwrapper
创建虚拟环境
mkvirtualenv 虚拟环境名字
直接在当前用户下创建一个虚拟环境，将这个虚拟环境安装到了这个目录，并且切换到
切换虚拟环境
workon [虚拟环境名字]
退出当前虚拟环境
deactivate
删除某个虚拟环境
rmvirtualenv [虚拟环境名字]
进入到虚拟环境
cdvirtualenv
列出虚拟环境
lsvirtualenv
注意 1： 修改 mkvirtualenv 的默认路径： 在 我的电脑->右键->属性->高级系统设置->环境变量->系统变量 中添加一个 参数 WORKON_HOME ，将这个参数的值设置为你需要的路径
配置虚拟环境管理器工作目录
# 配置环境变量：
# 控制面板 => 系统和安全 => 系统 => 高级系统设置 => 环境变量 => 系统变量 => 点击新建 => 填入变量名与值
变量名：WORKON_HOME 变量值：自定义存放虚拟环境的绝对路径
eg: WORKON_HOME: D:\Virtualenvs
# 同步配置信息：
# 去向Python3的安装目录 => Scripts文件夹 => virtualenvwrapper.bat => 双击
注意 2：
创建虚拟环境的时候指定 Python 版本：
在使用 mkvirtualenv 的时候，可以指定 --python 的参数来指定具体的
python 路径：
mkvirtualenv --python==C:\Python36\python.exe hy_en
认识Web
互联网三大基石
URL : Uniform Resource Locator 的简写，统一资源定位符。
一个 URL 由以下几部分组成：
scheme://host:port/path/?query-string=xxx#anchor
scheme：代表的是访问的协议，一般为 http 或者 https 以及 ftp 等。
host：主机名，域名，比如 www.baidu.com 。
port：端口号。当你访问一个网站的时候，浏览器默认使用80端口。
path：查找路径。比如： www.jianshu.com/trending/now ，后面的 trending/now 就
是 path 。
query-string：查询字符串，也叫请求参数，比如： www.baidu.com/s?wd=python ，后面的 wd=python 就是查
询字符串。
anchor：锚点，后台一般不用管，前端用来做页面定位的。
注意： URL 中的所有字符都是 ASCII 字符集，如果出现非 ASCII 字符，比如中文，浏览器会进行
编码再进行传输。
如：https://baike.baidu.com/item/%E9%BB%84%E6%99%93%E6%98%8E/6597?fr=aladdin#6
web服务器和应用服务器以及web应用框架
web服务器：负责处理http请求，响应静态文件，常见的有 Apache ， Nginx 以及微软的 IIS
应用服务器：负责处理逻辑的服务器。比如 php 、 python 的代码，是不能直接通过 nginx 这种web服务器来处理的，只能通过应用服务器来处理，常见的应用服务器有 uwsgi 、 tomcat 等。
web应用框架：一般使用某种语言，封装了常用的 web 功能的框架就是web应用框
架， flask 、 Django 以及Java中的 SSM(Spring+SpringMVC+Mybatis) 框架都是web应用框架。
Content-type和Mime-type的作用和区别：
两者都是指定服务器和客户端之间传输数据类型
Content-type：既可以指定传输数据类型，也可以指定数据编码类型，例如： text/html;charset=utf-8
Mime-type：不能指定传输的数据编码类型。例如： text/html
常用的数据类型如下：
text/html（默认的，html文件）
text/plain（纯文本）
text/css（css文件）
text/javascript（js文件）
application/x-www-form-urlencoded（普通的表单提交）
multipart/form-data（文件提交）
application/json（json传输）
application/xml（xml文件）
Flask简介：
是Python的一个WEB框架
此外，还有Django、tornado、cherryPy、WEB2PY
中文网站：https://dormousehole.readthedocs.org
github上的flask：https://github.com/pallets
github上的flask作者：https://github.com/mitsuhiko
flask 是一款非常流行的 Python Web 框架，出生于2010年，作者是 Armin Ronacher ,本来这个项
目只是作者在愚人节的一个玩笑，后来由于非常受欢迎，进而成为一个正式的项目。目前为止最新
的版本是 1.0.2 。
flask 自2010年发布第一个版本以来，大受欢迎，深得开发者的喜爱，并且在多个公司已经得到
了应用，flask能如此流行的原因，可以分为以下几点：
1.微框架、简洁、只做他需要做的，给开发者提供了很大的扩展性。
2.Flask和相应的插件写得很好，用起来很爽。
3.开发效率非常高，比如使用 SQLAlchemy 的 ORM 操作数据库可以节省开发者大量书写 sql 的时间。
Flask 的灵活度非常之高，他不会帮你做太多的决策，一些你都可以按照自己的意愿进行更改。
比如：
1.使用 Flask 开发数据库的时候，具体是使用 SQLAlchemy 还是 MongoEngine ，选择权完全掌握在你自己的手中。区别于 Django ， Django 内置了非常完善和丰富的功能，并且如果你想替
换成你自己想要的，要么不支持，要么非常麻烦。
2.把默认的 Jinja2 模板引擎替换成其他模板引擎都是非常容易的。
第一个flask程序：
用 pycharm2018.2.2 新建一个 flask 项目，新建项目的截图如下：
用 pycharm2017.1.4 新建一个 flask 项目，新建项目的截图如下：
#从flask包中导入Flask类
#Flask这个类是项目的核心，以后很多操作都基于这个类的对象
#注册url、注册蓝图等都是基于这个类的对象
from flask import Flask
#创建一个Flask对象，传递__name__参数进去
#__name__参数的作用：
#1.可以规定模版和静态文件的查找路径
#2.以后一些flask插件，如Flask-SQLAlchemy如果报错了，可通过__name__参数找到具体错误位置
app = Flask(__name__)
#@app.route:是一个装饰器
#@app.route('/')就是将url中 / 映射到hello_world设个视图函数上面
#以后你访问我这个网站的 / 目录的时候 会执行hello_world这个函数，然后将这个函数的返回值返回给浏览器
#如：www.bjsxt.com/----->hello_world 函数执行
@app.route('/')
def hello_world():
# return 'Hello World!'
return '尚学堂'
#如：www.bjsxt.com/list----->my_list 函数执行
@app.route('/list')
def my_list():
return 'my list'
#如果这个文件是作为一个主文件运行，那么就执行app.run()方法
# app.run()：Flask中的一个测试应用服务器
#也就是启动这个网站
if __name__ == '__main__':
#默认为5000端口
app.run()
#app.run(port=8000)
Pycharm开启debug模式和修改host：
在代码中制作一个错误:
@app.route(**'/'**)
**def** hello_world():
a = 1
b = 0
c = a/b
**return** **'Hello World!'
启动并访问：
控制台倒是给出了错误提示信息，但是 我们希望在浏览器也能有相应的提示信息
对于 pycharm2017，可这样处理
**if** __name__ == **'__main__'**:
#app.run()
#PyCharm2017.xx 开启debug调式模式
app.run(debug=**True**)
在 Pycharm 2018 中，如果想要开启 debug 模式和更改端口号，则需要编辑项目配置。直接在 app.run 中更改是无效的。示例图如下：
此时，注意 运行技巧
看结果
看浏览器访问结果
总结1：为什么需要开启DEBUG模式
-
1. 如果开启了DEBUG模式，那么在代码中如果抛出了异常，在浏览器的页面中可以看到具体的错误信息，以及具体的错误代码位置。方便开发者调试。 2. 如果开启了DEBUG模式，那么以后在`Python`代码中修改了任何代码，只要按`ctrl+s`，`flask`就会自动的重新加载最新代码。不需要手动点击重新运行。
总结2：配置DEBUG模式的四种方式
-
1. 在`app.run()`中传递一个参数`debug=True`就可以开启`DEBUG`模式。 pycharm2017适用 但pycharm2018需要配置项目信息才行 2. 给`app.deubg=True`也可以开启`debug`模式。 如： app = Flask(__name__) app.debug = **True** pycharm2017适用 但pycharm2018不适用 3. 通过配置参数的形式设置DEBUG模式：`app.config.update(DEBUG=True)`。 如： app = Flask(__name__) app.config.update(DEBUG=**True**) pycharm2017适用 但pycharm2018不适用 4. 通过配置文件的形式设置DEBUG模式：`app.config.from_object(config)`。 如：
pycharm2017适用 但pycharm2018不适用
扩展点：了解即可
如果想要在网页上调试代码，那么应该输入PIN码。
注意问题
从导入文件修改配置
# app.debug = False
# app.config.update(DEBUG=True)
# app.config.from_object(config)
# 以上方法都不生效，在新的版本里
# app.config.from_pyfile('config.py') 从文件中导入配置
# app.config.from_pyfile('config.txt') 普通的txt文件也可以
# 如果文件名写错了，可以添加一个silent=True
# app.config.from_pyfile('config.txt',silent=True)
配置文件的使用（两种）
方式1：
使用app.config.from_object的方式加载配置文件：
1. 导入`import config`。
2. 使用`app.config.from_object(config)`。
方式2：
使用'app.config.from_pyfile'的方式加载配置文件
这种方式不需要'import',直接使用'app.config.from_pyfile("config.py")'
注意这时 必须要写文件的全名，后缀名不能少
1.这种方式加载配置文件 ，不局限于".py"文件，普通的".txt"也可以。
2.这种方式，可以传递'silent=True',那么这个静态文件没有找到的时候，不会抛出异常
模版中使用url_for
模版中使用url_for
模版中的`url_for`跟我们后台视图函数中的`url_for`使用起来基本是一模一样的。也是传递视图函数的名字，也可以传递参数。使用的时候，需要在`url_for`左右两边加上一个`{{ url_for('func') }}`
传参也分为两种方式
路径式传参：
python文件如：
@app.route('/accounts/login/<name>/')
def login(name):
print(name)
return render_template('login.html')
html页面使用如：
<a href="{{ url_for('login',p1='abc',p2='ddd',name='momo') }}">登录4</a>
点击变为：
http://127.0.0.1:5000/accounts/login/momo/?p1=abc&p2=ddd
查询式传参：
html页面使用如：
<a href="{{ url_for('login',p1='abc',p2='ddd') }}">登录3</a>
点击变为：
http://127.0.0.1:5000/accounts/login/?p1=abc&p2=ddd
URL与函数的映射：
URL与函数的映射：
一个 URL 要与执行函数进行映射，使用的是 @app.route 装饰器。 @app.route 装饰器中，可以指定 URL 的规则来进行更加详细的映射。比如现在要映射一个文章详情的 URL ，文章详情的 URL 是 /article/id/ ，id有可能为1、2、3...,那
么可以通过以下方式：
@app.route('/article/<id>/')
def article_detail(id):
return '您请求的文章是：%s'% id
其中 <id> ，尖括号是固定写法，语法为 <variable> ， variable 默认的数据类型是字符串。如果需要指定类型，则要写成 <converter:variable> ，其中 converter 就是类型名称，可以有以下几种：
1. string:如果没有指定具体的数据类型，那么默认就是使用`string`数据类型。
2. int:数据类型只能传递`int`类型。
3. float:数据类型只能传递`float`类型。
4. path:数据类型和`string`有点类似，都是可以接收任意的字符串，但是`path`可以接收路径，也就是说可以包含斜杠。
5. uuid:数据类型只能接收符合`uuid`的字符串。`uuid`是一个全宇宙都唯一的字符串，一般可以用来作为表的主键。
6. any:数据类型可以在一个`url`中指定多个路径。例如：
# /blog/<id>/
# /user/<id>/
@app.route('/<any(user,blog):url_path>/<id>')
def detail(url_path,id):
if url_path=='blog':
return "博客详情：%s" %id
else :
return "用户详情：%s" %id
URL传递参数的两种方式：
URL传递参数的两种方式：
两种方式传递参数
第一种：/路径/参数,（就是将参数嵌入到路径中），就是上面讲的。
第二种:/路径?参数名1=参数值1&参数名2=参数值2...，如：
http://127.0.0.1:5000/test/?wd=python&ie=ok
from flask import Flask,request
@app.route('/test/')
def test():
wd = request.args.get('wd')
ie = request.args.get('ie')
print('ie:',ie)
return '您通过查询字符串的方式传递的参数是：%s' % wd
额外补充：如果是 post 方法，则可以通过 request.form.get('id') 来进行获取。
使用总结：
如果你的这个页面的想要做`SEO`优化，就是被搜索引擎搜索到，那么推荐使用第一种形式（path的形式）。如果不在乎搜索引擎优化，那么就可以使用第二种（查询字符串的形式）。
# @app.route('/list/')
# def my_list():
# return 1
# @app.route('/aid/<id>/')
# def article(id):
# return 'aid' + id
# @app.route('/aid2/<int:id>/') # 默认参数是str,自己可以定义数据类型
# def article(id):
# return 'id是%s' % id
# @app.route('/aid2/<float:id>/') # 默认参数是str,自己可以定义数据类型
# def article(id):
# return 'id是%s' % id
# @app.route('/aid2/<path:id>/') # 默认参数是str,自己可以定义数据类型
# def article(id):
# return 'id是%s' % id
# @app.route('/<any(user,blog):module>/<int:id>/') # 默认参数是str,自己可以定义数据类型
# def article(module, id):
# return 'id是%s' % id
url_for 好处
# 将来如果修改了url ,但是没有修改url函数名，就不用导出替换url了，路径变化的概率要高于函数名变化
# 函数接收两个以上参数，接收函数名作为第一个参数
# 接收对应url规则命名参数
# 如果出现其他参数,则会添加url 后面作为查询参数
# 自动转义特殊字符
# @app.route('/list', methods=['GET', 'POST']) # 默认参数是str,自己可以定义数据类型
# def list7():
# if request.method == 'GET':
# username = request.args.get('username')
# password = request.args.get('password')
# # username = request.form.get('username')
# # password = request.form.get('password')
#
# return render_template('index1.html')
# elif request.method == 'POST':
# username = request.form.get('username')
# password = request.form['password']
#
# return 'post请求方式接收到参数 %s %s' % (username, password)
url_for使用详解
一般我们通过一个 URL 就可以执行到某一个函数。如果反过来，我们知道一个函数，怎么去获得
这个 URL 呢？ url_for 函数就可以帮我们实现这个功能。
url_for() ：函数接收两个及以上的参数，他接收函数名作为第一个参数，接收对应URL规则的命名参数，如果还出现其他的参数，则会添加到 URL 的后面作为查询参数。
如：
@app.route('/post/list/<page>/')
def my_list(page):
return 'my list'
@app.route('/')
def hello_world():
# 构建出来的url：/post/my_list/2?num=8
return url_for('my_list',page=2,num=8)
# return "/post/list/2？num=8"
为什么选择`url_for` 而不选择直接在代码中拼 URL 的原因有两点：
1. 将来如果修改了 URL ，但没有修改该 URL 对应的函数名，就不用到处去替换 URL 了。
2. url_for() 函数会转义一些特殊字符和 unicode 字符串，这些事情 url_for 会自动的帮我们
搞定。
如：
@app.route('/login/')
def login():
return 'login'
@app.route('/')
def hello_world():
return url_for('login', next='/')
# /login/?next=/
# 会自动的将/编码，不需要手动去处理。
# url=/login/?next=%2F
# @app.route('/')
# def hello_world():
# # a = 1/0
# return url_for('tel')
# @app.route('/')
# def list1():
# return url_for('list2', next='/哈哈')
# 将来如果修改了url ,但是没有修改url函数名，就不用导出替换url了，路径变化的概率要高于函数名变化
# 函数接收两个以上参数，接收函数名作为第一个参数
# 接收对应url规则命名参数
# 如果出现其他参数,则会添加url 后面作为查询参数
# 自动转义特殊字符
# @app.route('/ss/list2')
# def list2():
# return 'list2'
# @app.route('/list2/<page>')
# def list2(page):
# return page
# @app.route('/list2/')
# def list2():
# return
自定义URL转换器
自定义URL转换器的步骤：
转换器是一个类，且必须继承自werkzeug.routing.BaseConverter。
1. 实现一个类，继承自`BaseConverter`。
2. 在自定义的类中，重写`regex`，也就是这个变量的正则表达式。
3. 将自定义的类，映射到`app.url_map.converters`上。理解为加入字典DEFAULT_CONVERTERS中
比如：
app.url_map.converters['tel']=TelephoneConveter
注意：to_python方法和to_url方法的作用
1.在转换器类中，实现to_python(self,value)方法，这个方法的返回值，将会传递到 view函数中作为参数。
2.在转换器类中，实现to_url(self,values)方法，这个方法的返回值，将会在调用url_for函数的时候生成符合要求的URL形式。
# 自定义url转换器，在路径中，能匹配一个电话号码的类型参数
# 实现一个类，继承 'BaseConverter'
# 在自定义中的类，重写 regex 也就是这个变量的正则表达式
# 将自定义类，映射到app.url_map.converters上，理解为加入字典
#
# class TelephoneCoverNum(BaseConverter):
# regex = r'1[0-9]\d{9}'
#
#
# app.url_map.converters['tel'] = TelephoneCoverNum
#
#
# @app.route('/telephone/<tel:num>')
# def tel(num):
# return '%s' % num
@app.route('/new_list/<modules>/')
def new_list(modules):
# modules 是路径参数
# 需要对modules进行拆分
# 拆分后需要去数据库做查询操作
lm = modules.split('+')
return '%s' % lm
必须会的细节知识
class LiCovert(BaseConverter):
def to_python(self, value: str):
# 重写 to_python
# 可以对value重新加工处理
return value
app.url_map.converters['li'] = LiCovert
@app.route('/new_list/<li:modules>/')
def new_list(modules):
# modules 是路径参数
# 需要对modules进行拆分
# 拆分后需要去数据库做查询操作
# lm = modules.split('+')
print(modules)
# print(modules[1])
return '%s' % modules
在局域网中让其他电脑访问我的网站：
如果想在同一个局域网下的其他电脑访问自己电脑上的Flask网站，那么可以设置`host='0.0.0.0'`才能访问得到。如：
app.run(host='0.0.0.0')
指定端口号：
Flask项目，默认使用`5000`端口。如果想更换端口，那么可以设置`port=9000`。如：
app.run(host='0.0.0.0',port=9000)
url唯一：
在定义url的时候，一定要记得在最后加一个斜杠。
1. 如果不加斜杠，那么在浏览器中访问这个url的时候，如果最后加了斜杠，那么就访问不到。这样用户体验不太好。
2. 搜索引擎会将不加斜杠的和加斜杠的视为两个不同的url。而其实加和不加斜杠的都是同一个url，那么就会给搜索引擎造成一个误解。加了斜杠，就不会出现没有斜杠的情况。
`GET`请求和`POST`请求：
在网络请求中有许多请求方式，比如：GET、POST、DELETE、PUT请求等。那么最常用的就是`GET`和`POST`请求了。
1. `GET`请求：只会在服务器上获取资源，不会更改服务器的状态。这种请求方式推荐使用`GET`请求。
2. `POST`请求：会给服务器提交一些数据或者文件。一般POST请求是会对服务器的状态产生影响，那么这种请求推荐使用POST请求。
3. 关于参数传递：
`GET`请求：把参数放到`url`中，通过`?xx=xxx`的形式传递的。因为会把参数放到url中，一眼就能看到你传递给服务器的参数。这样不太安全。
`POST`请求：把参数放到`Form Data`中。会把参数放到`Form Data`中，避免了被偷瞄的风险，但是如果别人想要偷看你的密码，那么其实可以通过抓包的形式。因为POST请求可以提交一些数据给服务器，比如可以发送文件，那么这就增加了很大的风险。所以POST请求，对于那些有经验的黑客来讲，其实是更不安全的。
4. 在`Flask`中，`route`方法，默认将只能使用`GET`的方式请求这个url，如果想要设置自己的请求方式，那么应该传递一个`methods`参数。
如：
@app.route('/login/',methods=['GET','POST'])
def login():
if request.method =='GET':
return render_template('login.html')
else:
return "success"
页面跳转和重定向
重定向分为永久性重定向和'暂时性重定向'，在页面上体现的操作就是浏览器会从一个页面自动跳转到另外一个页面。比如用户访问了一个需要权限的页面，但是该用户当前并没有登录，因此我们应该给他重定向到登录页面。
永久性重定向： http 的状态码是 301 ，多用于旧网址被废弃了要转到一个新的网址确保用户的访问，最经典的就是京东网站，你输入 www.jingdong.com 的时候，会被重定向到 www.jd.com ，因为 jingdong.com 这个网址已经被废弃了，被改成 jd.com ，所以这种情况下应该用永久重定向。
暂时性重定向：http 的状态码是 302 ，表示页面的暂时性跳转。比如访问一个需要权限的网址，如果当前用户没有登录，应该重定向到登录页面，这种情况下，应该用暂时性重定向。用淘宝网演示为例进行讲解。
flask中重定向：重定向是通过 redirect(location,code=302) 这个函数来实现的， location 表示需要重定向到的 URL ，应该配合之前讲的 url_for() 函数来使用， code 表示采用哪个重定向，默认是 302 也即 暂时性重定向 ，可以修改成 301 来实现永久性重定向。
例如：
from flask import Flask,request,url_for,redirect
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello World!'
@app.route('/login/')
def login():
return '这是登录页面'
#falsk中重定向
@app.route('/profile/')
def proflie():
if request.args.get('name'):
return '个人中心页面'
else:
# return redirect(url_for('login'))
return redirect(url_for('login'),code=302)
if __name__ == '__main__':
app.run(debug=True)
# ----------------------------------
# 页面跳转和重定向
#
# @app.route('/login/')
# def login():
# return '登录页面'
#
#
# @app.route('/profile/')
# # 如果已经登录，去查看个人信息
# # 如果没有登录，则跳转到登录页面
# def profile():
# uname = request.args.get('uname')
# if uname and uname == 'momo':
# return '登录成功'
# else:
# return redirect(url_for('login'),code=302)
视图函数Response返回值详解
视图函数Response返回值详解
关于响应（Response）
视图函数中可以返回以下类型的值：
1.Response 对象及其子类对象
2.字符串。其实 Flask 是根据返回的字符串类型，重新创建一个 werkzeug.wrappers.Response 对象， Response 将该字符串作为主体，状态码为200， MIME 类型为 text/html ，然后返回该 Response 对象
3.元组。元组中格式是 (response,status,headers) 。 response 为一个字符串， status 值是
状态码， headers 是一些响应头。即(响应体,状态码,头部信息)，也不一定三个都要写，写两个也是可以的。
4.如果不是以上三种类型。即如果视图函数返回的数据，不是字符串，也不是元组，也不是Response对象，那么就会将返回值传给` Response.force_type(rv,request.environ) `，然后再将`force_type`的返回值返回给前端。
自定义的`Response`对象的步骤
1. 继承自`Response`类。
2. 实现方法`force_type(cls,rv,environ=None)`。
3. 指定`app.response_class`为你自定义的`Response`对象。
如：自定义的`Response`对象将视图中返回的字典，转换成json对象，然后返回
class JSONResponse(Response):
@classmethod
def force_type(cls, response, environ=None):
"""
这个方法只有视图函数返回 非字符串 非Response对象 非元组时才会调用
response：视图函数的返回值
"""
if isinstance(response,dict):
response = jsonify(response)
#调用父类方法
return super(JSONResponse, cls).force_type(response,environ)
app.response_class = JSONResponse
@app.route('/')
def resp1():
content = '哈哈'
resp = Response(content, status=200)
resp.set_cookie('username', 'momo')
resp.set_cookie('password', '123')
# resp.content_type = 'str'
return resp
# Response 对resp 对象加工后返回
class JSONResponse(Response):
@classmethod
def force_type(cls, response, environ=None):
if isinstance(response, dict):
# res = json.dumps(response)
# 将字典类型数据转成一个长得像JSON对象，其实不是json
# 满足类型是字典,再对其做加工操作
resp = jsonify(response) # 转成json # 将字典类型数据转成一个JSON对象
return super(JSONResponse,cls).force_type(resp) # force_type里面必须传入一个json 格式的字符串
app.response_class = JSONResponse
@app.route('/myfile/')
def myfile():
return {'sex':'man','age':18}
JinJa2 模板简介：
在之前的意节中，视图园数只是直接返回文本，而在实际生产环境中其实根少这样用，因为实际的页面大多是带有样式和夏杂逻辑的HTML代码，这可以让浏览器演染出非常漂亮的页面。目前市面上有非常参的模板系统，其中最知名最好用的就是时2和州ak?，我们先来看一下这两个模板的特点和不同：
1,J列a2:1n时a是日本寺庙的意思，并且寺庙的英文是tp1e和模板的英文tmp1ate的发音类似。|31n5a2是认的仿D时翰80模板的一个横板号引辈，由1致的作者开发。它速度快，被广泛使用，并且提供了可选的箱模板来保证执行环缓的安全，它有以下优点：
·让前演开发者和后端开发者工作分离。
。减少F1k项目代码的调合性，页面逻辑放在模板中，业务逻辑放在视图逊数中，将页面逻福和业务逻辑解耦有利厅代码的维护。
·提供了控制语句、继承等高级功能，减少开发的复杂度。
2.Marko:arko是另一个知名的模板。他从Django、3in时a2等模板倡鉴了很多语法和AP列，他有以下优点：
·性能和312相近，在这里可以看到：
。有大型网站在使用，有成功的案例。Redd1t和豆着都在使用。
。有知名的web框架支持，ylons和Pyranid这两个web框架内置模板就是ako。
·支持在模板中写几乎原生的Pythoni语法的代码，对Python.工程师比较友好，开发效率高，·自带完整的暖存系统。当然也提供了非常好的扩展借口，與容易切换成其他的暖存系统。
Updated 2 days
jinja2模版介绍和查找路径
jinja2模版介绍和查找路径
模板是一个 web 开发必备的模块。因为我们在渲染一个网页的时候，并不是只渲染一个纯文本字符串，而是需要渲染一个有富文本标签的页面。这时候我们就需要使用模板了。在 Flask 中，配
套的模板是 Jinja2 ， Jinja2 的作者也是 Flask 的作者。这个模板非常的强大，并且执行效率
高。
不建议去官网学习，多，乱。
官网：http://jinja.pocoo.org/
查找路径：
1. 在渲染模版的时候，默认会从项目根目录下的`templates`目录下查找模版。
2. 如果不想把模版文件放在`templates`目录下，那么可以在`Flask`初始化的时候指定`template_folder`来指定模版的路径。
Flask渲染 Jinja 模板：
要渲染一个模板，通过 render_template 方法即可，如:
from flask import Flask,render_template
app = Flask(__name__)
@app.route('/')
def hello_world():
return render_template('index.html')
模版传参及其技巧
模版传参及其技巧
1. 在使用`render_template`渲染模版的时候，可以传递关键字参数（命名参数）。以后直接在模版中使用就可以了。
模版传参
from flask import Flask,render_template
app = Flask(__name__)
@app.route('/')
def hello_world():
return render_template('index.html',uname='momo')
页面取参
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>SXT</title>
</head>
<body>
从模版中渲染的数据
<br>
{{ uname}}
</body>
</html>
2. 如果你的参数项过多，那么可以将所有的参数放到一个字典中，然后在传这个字典参数的时候，使用两个星号，将字典打散成关键字参数（也叫命名参数）。
如：
@app.route('/')
def hello_world():
context = {
'uname': 'momo',
'age': 18,
'country': 'china',
'childrens': {
'name': 'mjz',
'height': '62cm'
}
}
return render_template('index.html',**context)
注意访问技巧：{{childrens.name}} 或者{{childrens['name'}}}
模版中使用url_for
模版中使用url_for
模版中的`url_for`跟我们后台视图函数中的`url_for`使用起来基本是一模一样的。也是传递视图函数的名字，也可以传递参数。使用的时候，需要在`url_for`左右两边加上一个`{{ url_for('func') }}`
传参也分为两种方式
路径式传参：
python文件如：
@app.route('/accounts/login/<name>/')
def login(name):
print(name)
return render_template('login.html')
html页面使用如：
<a href="{{ url_for('login',p1='abc',p2='ddd',name='momo') }}">登录4</a>
点击变为：
http://127.0.0.1:5000/accounts/login/momo/?p1=abc&p2=ddd
查询式传参：
html页面使用如：
<a href="{{ url_for('login',p1='abc',p2='ddd') }}">登录3</a>
点击变为：
http://127.0.0.1:5000/accounts/login/?p1=abc&p2=ddd
Jinja2过滤器
过滤器基本使用
举个例子，哪里用到了过滤器
访问：https://www.bufanbiz.com/，说明提示时间处就用到了过滤器
简单使用一下:
python文件如：
@app.route('/')
def hello_world():
return render_template('index.html',postion=-1)
'''
html页面如:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>SXT</title>
</head>
<body>
<h3>过滤器的基本使用</h3>
<p>位置的绝对值为[未使用过滤器]：{{ postion}}</p>
<p>位置的绝对值为[使用过滤器]：{{ postion|abs}}</p>
</body>
</html>
'''
简单总结:
1. 有时候我们想要在模版中对一些变量进行处理，那么就必须需要类似于Python中的函数一样，可以将这个值传到函数中，然后做一些操作。在模版中，过滤器相当于是一个函数，把当前的变量传入到过滤器中，然后过滤器根据自己的功能，再返回相应的值，之后再将结果渲染到页面中。
2. 基本语法：`{{ variable|过滤器名字 }}`。使用管道符号`|`进行组合。
过滤器介绍：
过滤器介绍：
过滤器是通过管道符号（|）进行使用的，例如：{{ name|length }}，将返回name的长度。过滤器相当于是一个函数，把当前的变量传入到过滤器中，然后过滤器根据自己的功能，再返回相应的值，之后再将结果渲染到页面中。Jinja2中内置了许多过滤器，
查看所有过滤器:http://jinja.pocoo.org/docs/dev/templates/#builtin-filters
现对一些常用的过滤器进行讲解：
abs(value)：返回一个数值的绝对值。 例如：-1|abs。
default(value,default_value,boolean=false)：如果当前变量没有值，则会使用参数中的值来代替。name|default('xiaotuo')——如果name不存在，则会使用xiaotuo来替代。boolean=False默认是在只有这个变量为undefined的时候才会使用default中的值，如果想使用python的形式判断是否为false，则可以传递boolean=true。也可以使用or来替换。
escape(value)或e：转义字符，会将<、>等符号转义成HTML中的符号。例如：content|escape或content|e。
first(value)：返回一个序列的第一个元素。names|first。
format(value,*arags,**kwargs)：格式化字符串。例如以下代码：
{{ "%s" - "%s"|format('Hello?',"Foo!") }}将输出：Helloo? - Foo!
last(value)：返回一个序列的最后一个元素。示例：names|last。
length(value)：返回一个序列或者字典的长度。示例：names|length。
join(value,d='+')：将一个序列用d这个参数的值拼接成字符串。
safe(value)：如果开启了全局转义，那么safe过滤器会将变量关掉转义。示例：content_html|safe。
int(value)：将值转换为int类型。
float(value)：将值转换为float类型。
lower(value)：将字符串转换为小写。
upper(value)：将字符串转换为小写。
replace(value,old,new)： 替换将old替换为new的字符串。
truncate(value,length=255,killwords=False)：截取length长度的字符串。
striptags(value)：删除字符串中所有的HTML标签，如果出现多个空格，将替换成一个空格。
trim：截取字符串前面和后面的空白字符。
string(value)：将变量转换成字符串。
wordcount(s)：计算一个长字符串中单词的个数。
default过滤器详解
default过滤器详解
使用场景：个性签名
用户设置了签名: 写什么就是什么
用户没设置签名：默认给出“此人狠懒，暂无任何签名”
例：
#default过滤器的使用
@app.route('/')
def hello_world():
context={
'postion':-1
}
return render_template('index.html',**context)
html页面
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>SXT</title>
</head>
<body>
<h3>过滤器的基本使用</h3>
<p>个性签名[使用过滤器]：{{ signature|default('此人很懒，没有任何说明')}}</p>
</body>
</html>
访问结果：
但若将上述的例子代码稍微改一改，例：
#default过滤器的使用
@app.route('/')
def hello_world():
context={
'postion':-1,
'signature':None
}
return render_template('index.html',**context)
html页面
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>SXT</title>
</head>
<body>
<h3>过滤器的基本使用</h3>
<p>个性签名[使用过滤器]：{{ signature|default('此人很懒，没有任何说明')}}</p>
</body>
</html>
访问结果：
若此时需要让default过滤器生效的话，需要在default中添加'boolean=True'
如：
<p>个性签名[使用过滤器]：{{ signature|default('此人很懒，没有任何说明',boolean=True)}}</p>
default过滤器使用总结：
使用方式`{{ value|default('默认值') }}`。
如果value这个`key`不存在，那么就会使用`default`过滤器提供的默认值。
如果value这个`key`存在，就不会使用`default`过滤器提供的默认值。但对于value的一些特殊值（例如：None、空字符串、空列表、空字典等），想使用`default`过滤器提供的默认值。，那么就必须要传递另外一个参数`{{ value|default('默认值',boolean=True) }}`。
扩展：
可以使用`or`来替代`default('默认值',boolean=True)`。例如：`{{ signature or '此人很懒，没有留下任何说明' }}`。
如：两种写法等价
<p>个性签名[使用过滤器]：{{ signature|default('此人很懒，没有任何说明',boolean=True)}}</p>
<p>个性签名[使用过滤器]：{{ signature or '此人很懒，没有任何说明'}}</p>
常用过滤器讲解
常用过滤器讲解
abs(value)：返回一个数值的绝对值。 例如：-1|abs。
default(value,default_value,boolean=false)：如果当前变量没有值，则会使用参数中的值来代替。name|default('xiaotuo')——如果name不存在，则会使用xiaotuo来替代。boolean=False默认是在只有这个变量为undefined的时候才会使用default中的值，如果想使用python的形式判断是否为false，则可以传递boolean=true。也可以使用or来替换。
escape(value)或e：转义字符，会将<、>等符号转义成HTML中的符号。例如：content|escape或content|e。
first(value)：返回一个序列的第一个元素。names|first。
format(value,*arags,**kwargs)：格式化字符串。例如以下代码：
{{ "%s" - "%s"|format('Hello?',"Foo!") }}将输出：Helloo? - Foo!
last(value)：返回一个序列的最后一个元素。示例：names|last。
length(value)：返回一个序列或者字典的长度。示例：names|length。
join(value,d=u'')：将一个序列用d这个参数的值拼接成字符串。
safe(value)：如果开启了全局转义，那么safe过滤器会将变量关掉转义。示例：content_html|safe。
int(value)：将值转换为int类型。
float(value)：将值转换为float类型。
lower(value)：将字符串转换为小写。
upper(value)：将字符串转换为小写。
replace(value,old,new)： 替换将old替换为new的字符串。
truncate(value,length=255,killwords=False)：截取length长度的字符串。
striptags(value)：删除字符串中所有的HTML标签，如果出现多个空格，将替换成一个空格。
trim：截取字符串前面和后面的空白字符。
string(value)：将变量转换成字符串。
wordcount(s)：计算一个长字符串中单词的个数。
总结:自动转译过滤器
jinja2模版 默认全局开启了 自动转译功能
1. `safe`过滤器：可以关闭一个字符串的自动转义。
2. `escape`过滤器：对某一个字符串进行转义。
3. `autoescape`jinja标签，可以对他里面的代码块关闭或开启自动转义。
{% autoescape off/on %}
...代码块
{% endautoescape %}
自定义过滤器
自定义模版过滤器：
只有当系统提供的过滤器不符合需求后，才须自定义过滤器
过滤器本质上就是一个函数。
如果在模版中调用这个过滤器，那么就会将这个变量的值作为第一个参数传给过滤器这个函数，
然后函数的返回值会作为这个过滤器的返回值。
需要使用到一个装饰器：`@app.template_filter('过滤器名称')`
例如：将新闻中出现的 所有“十大酷刑” 删除掉
#将模版设置为自动加载模式
app.config['TEMPLATES_AUTO_RELOAD']=True
@app.template_filter('cut')
def cut(value):
value=value.replace("十大酷刑",'')
return value
使用：
<p>使用自定义过滤器：{{新闻内容值|cut}}</p>
过滤器案例
from datetime import datetime
#需求：操作发布新闻 与现在的时间间隔
@app.template_filter('handle_time')
def handle_time(time):
"""
time距离现在的时间间隔
1. 如果时间间隔小于1分钟以内，那么就显示“刚刚”
2. 如果是大于1分钟小于1小时，那么就显示“xx分钟前”
3. 如果是大于1小时小于24小时，那么就显示“xx小时前”
4. 如果是大于24小时小于30天以内，那么就显示“xx天前”
5. 否则就是显示具体的时间 2018/10/20 16:15
"""
if isinstance(time, datetime):
now = datetime.now()
timestamp = (now - time).total_seconds()
if timestamp < 60:
return "刚刚"
elif timestamp >= 60 and timestamp < 60 * 60:
minutes = timestamp / 60
return "%s分钟前" % int(minutes)
elif timestamp >= 60 * 60 and timestamp < 60 * 60 * 24:
hours = timestamp / (60 * 60)
return '%s小时前' % int(hours)
elif timestamp >= 60 * 60 * 24 and timestamp < 60 * 60 * 24 * 30:
days = timestamp / (60 * 60 * 24)
return "%s天前" % int(days)
else:
return time.strftime('%Y/%m/%d %H:%M')
else:
return time
控制语句
if语句详解
所有的控制语句都是放在{% ... %}中，并且有一个语句{% endxxx %}来进行结束，Jinja中常用的控制语句有if/for..in..，现逐一对他们进行讲解：
if：if语句和python中的类似，可以使用>，<，<=，>=，==，!=来进行判断，也可以通过and，or，not，()来进行逻辑合并操作，以下看例子：
{% if uname =='momo' %}
<p>莫莫</p>
{% else %}
<p>露露</p>
{% endif %}
{% if age >= 18 %}
<p>{{ age }}岁，成年人，能进入网吧</p>
{% else %}
<p>{{ age }}岁，未成年人，禁止能进入网吧</p>
{% endif %}
注意：
`if`条件判断语句必须放在`{% if statement %}`中间，并且还必须有结束的标签`{% endif %}`。
控制语句
for循环语句详解
for...in...：for循环可以遍历任何一个序列包括列表、字典、元组。并且可以进行反向遍历，以下将用几个例子进行解释：
普通的遍历 列表：
<ul>
{% for user in users%}
<li>{{ user}}</li>
{% endfor %}
</ul>
遍历字典：
<tr>
{% for key in person.keys() %}
<td>{{ key}}</td>
{% endfor %}
</tr>
<tr>
{% for val in person.values() %}
<td>{{ val}}</td>
{% endfor %}
</tr>
<tr>
{% for item in person.items() %}
<td>{{ item}}</td>
{% endfor %}
</tr>
<tr>
{% for key,value in person.items() %}
<td>{{ value}}</td>
{% endfor %}
</tr>
如果序列中没有值的时候，进入else，反向遍历用过滤器 reverse：
<ul>
{% for user in users|reverse %}
<li>{{ user}}</li>
{% else %}
<li>没有任何用户</li>
{% endfor %}
</ul>
并且Jinja中的for循环还包含以下变量，可以用来获取当前的遍历状态：
| 变量 | 描述 | | --- | --- |
| loop.index | 当前迭代的索引（从1开始） |
| loop.index0 | 当前迭代的索引（从0开始） |
| loop.first | 是否是第一次迭代，返回True或False |
| loop.last | 是否是最后一次迭代，返回True或False |
| loop.length | 序列的长度 |
总结：
在`jinja2`中的`for`循环，跟`python`中的`for`循环基本上是一模一样的。也是`for...in...`的形式。并且也可以遍历所有的序列以及迭代器。但是唯一不同的是，`jinja2`中的`for`循环没有`break`和`continue`语句。
for99乘法表案例：
代码如下：
<table border="1px">
{% for x in range(1,10) %}
<tr>
{% for y in range(1,x + 1) %}
<td>{{y}}*{{x}}={{ x*y }}</td>
{% endfor %}
</tr>
{% endfor %}
</table>
宏的概念及基本使用
宏的概念及基本使用
宏：
模板中的宏跟python中的函数类似，可以传递参数，但是不能有返回值，可以将一些经常用到的代码片段放到宏中，然后把一些不固定的值抽取出来当成一个变量，以下将用一个例子来进行解释：
1. 定义宏：
```html
{% macro input(name,value="",type="text") %}
<input type="{{type}}" name="{{name}}" value="{{ value}}">
{% endmacro %}
```
2.使用宏：
```html
<table>
<tr>
<td>用户名：</td>
<td>{{ input('username')}}</td>
</tr>
<tr>
<td>密码：</td>
<td>
{{ input('pwd',type='password') }}
</td>
</tr>
<tr>
<td></td>
<td>{{ input(value='提交',type='submit') }}</td>
</tr>
</table>
```
3.访问结果：
宏的导入和注意事项
宏的导入和注意事项
引入:实际开发中，不会把宏在一个页面内定义 并直接使用
一般把宏定义放到一个专门的文件夹中，方便进行统一管理
之后，哪一个页面需要使用某个宏，需要导入宏才能使用
导入宏两种方式：
1. `from '宏文件的路径' import 宏的名字 [as xxx]`。
如：
{% from "macros/macros.html" import input as inp %}
2. `import "宏文件的路径" as xxx [with context]`。
如：
{% import "macros/macros.html" as macros with context %}
注意两点：
1. 宏文件路径，不要以相对路径去寻找，都要以`templates`作为绝对路径去找。
2. 如果想要在导入宏的时候，就把当前模版的一些参数传给宏所在的模版，那么就应该在导入的时候使用`with context`。
如：
{% import "macros/macros.html" as macros with context %}
include标签使用详解
include标签使用详解
include标签：
1. 这个标签相当于是直接将指定的模版中的代码复制粘贴到当前位置。
2. `include`标签，如果想要使用父模版中的变量，直接用就可以了，不需要使用`with context`。
3. `include`的路径，也是跟`import`一样，直接从`templates`根目录下去找，不要以相对路径去找。
如：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>SXT</title>
</head>
<body>
<!--通过include 引入头部log信息-->
{% include "common/head.html" %}
<div>
这是首页内容
{{ major }}
</div>
<hr>
<!--通过include 引入底部版权信息-->
{% include "common/footer.html" %}
</body>
</html>
set和with语句以及模版中定义变量
set和with语句以及模版中定义变量
set语句：
在模版中，可以使用`set`语句来定义变量。示例如下：
```html
<!--set语句来定义变量，之后，那么在后面的代码中，都可以使用这个变量-->
{% set uname='momo'%}
<p>用户名：{{ uname }}</p>
```
一旦定义了这个变量，那么在后面的代码中，都可以使用这个变量，就类似于Python的变量定义是一样的。
with语句：
`with`语句定义的变量，只能在`with`语句块中使用，超过了这个代码块，就不能再使用了。示例代码如下：
```html
<!--with语句来定义变量，只有在指定区域 才能使用这个变量-->
{% with classroom='python202'%}
<p>班级：{{ classroom }}</p>
{% endwith %}
```
注意：
关于定义的变量，`with`语句也不一定要跟一个变量，可以定义一个空的`with`语句， 需要在指定的区域才能使用的情况，可以set与with组合使用。
```html
{% with %}
{% set pname='李思思' %}
<p>娱乐县县长：{{ pname }}</p>
{% endwith %}
```
加载静态文件
静态文件：css文件 js文件 图片文件等文件
加载静态文件使用的是url_for函数。然后第一个参数需要为static，第二个参数需要为一个关键字参数filename='路径'。
语法：
{{ url_for("static",filename='xxx') }}
例如:
注意：
路径查找，要以当前项目的static目录作为根目录。
模版继承详解
模版继承详解
为什么需要模版继承：
模版继承可以把一些公用的代码单独抽取出来放到一个父模板中。以后子模板直接继承就可以使用了。这样可以重复的利用代码，并且以后修改起来也比较方便。
模版继承语法：
使用`extends`语句，来指明继承的父模板。父模板的路径，也是相对于`templates`文件夹下的绝对路径。示例代码如下：
{% extends "base.html" %}
block语法：
一般在父模版中，定义一些公共的代码。子模板可能要根据具体的需求实现不同的代码。这时候父模版就应该有能力提供一个接口，让子模板来实现。从而实现具体业务需求的功能。
在父模板中：
```html
{% block block的名字 %}
{% endblock %}
```
在子模板中：
```html
{% block block的名字 %}
子模板中的代码
{% endblock %}
```
调用父模版代码block中的代码：
默认情况下，子模板如果实现了父模版定义的block。那么子模板block中的代码就会覆盖掉父模板中的代码。如果想要在子模板中仍然保持父模板中的代码，那么可以使用`{{ super() }}`来实现。示例如下：
父模板：
```html
{% block block_body %}
<p style="background-color: blue">我是 父模版block_body处的内容</p>
{% endblock %}
```
子模板：
```html
{% block block_body%}
{{ super() }}
<p style="background-color: green">我是 子模版block_body处的内容</p>
{% endblock %}
```
调用另外一个block中的代码：
如果想要在另外一个模版中使用其他模版中的代码。那么可以通过`{{ self.其他block名字() }}`就可以了。示例代码如下：
```html
{% block title %}
sxt首页
{% endblock %}
{% block block_body%}
{{ self.title() }}
<p style="background-color: green">我是 子模版block_body处的内容</p>
{% endblock %}
```
其他注意事项：
1. 子模板中的代码，第一行，应该是`extends`。
2. 子模板中，如果要实现自己的代码，应该放到block中。如果放到其他地方，那么就不会被渲染。
add_url_rule和app.route原理剖析
add_url_rule和app.route原理剖析
`add_url_rule(rule,endpoint=None,view_func=None)`
这个方法用来添加url与视图函数的映射。如果没有填写`endpoint`，那么默认会使用`view_func`的名字作为`endpoint`。以后在使用`url_for`的时候，就要看在映射的时候有没有传递`endpoint`参数，如果传递了，那么就应该使用`endpoint`指定的字符串，如果没有传递，那么就应该使用`view_func`的名字。
例：
def my_list():
return "我是列表页"
app.add_url_rule('/list/',endpoint='sxt',view_func=my_list)
`app.route(rule,**options)`装饰器：
这个装饰器底层，其实也是使用`add_url_rule`来实现url与视图函数映射的。
from flask import Flask,url_for
app = Flask(__name__)
@app.route('/',endpoint='hello')
def hello_world():
#构建url ：/list/
#研究app.add_url_rule()方法，若方法中【没有加】上endpoint时，可通过原来的函数名构建url，即url_for('原函数名')
# print(url_for('my_list'))
#研究app.add_url_rule()方法，若方法中【加上】endpoint时，不能再通过原来的函数名构建url，而需要endpoint的值才行
# 即url_for('endpoint值')
print(url_for('li'))
return 'Hello World!'
def my_list():
return "这是列表页"
#通过app对象的add_url_rule方法 来完成url与视图函数的映射
app.add_url_rule('/list/',endpoint='li',view_func = my_list)
#讨论：add_url_rule()方法 与@app.route()装饰器的关系
#结论：@app.route()装饰器 底层就是借助于add_url_rule()方法来实现的
#请求上下文对象 项目一启动就会执行
with app.test_request_context():
# print(url_for('hello_world'))
print(url_for('hello'))
if __name__ == '__main__':
app.run(debug=True)
类视图
类视图
之前我们接触的视图都是函数，所以一般简称视图函数。其实视图也可以基于类来实现，类视图的好处是支持继承，但是类视图不能跟函数视图一样，写完类视图还需要通过app.add_url_rule(url_rule,view_func)来进行注册。以下先对标准类视图进行讲解：
1.标准类视图使用步骤
1. 标准类视图，必须继承自`flask.views.View`.
2. 必须实现`dipatch_request`方法，以后请求过来后，都会执行这个方法。这个方法的返回值就相当于是之前的函数视图一样。也必须返回`Response`或者子类的对象，或者是字符串，或者是元组。
3. 必须通过`app.add_url_rule(rule,endpoint,view_func)`来做url与视图的映射。`view_func`这个参数，需要使用类视图下的`as_view`类方法类转换：`ListView.as_view('list')`。
4. 如果指定了`endpoint`，那么在使用`url_for`反转的时候就必须使用`endpoint`指定的那个值。如果没有指定`endpoint`，那么就可以使用`as_view(视图名字)`中指定的视图名字来作为反转。
from flask import Flask,views,url_for
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello World!'
#定义一个类视图
class ListView(views.View):
def dispatch_request(self):
return "这是List列表"
#注册类视图
app.add_url_rule('/list/',endpoint='mlist',view_func=ListView.as_view('my_list'))
with app.test_request_context():
#若注册url时，没有指定endpoint，使用as_view（）方法中的名称 来构建url
# print(url_for('my_list'))
# 若注册url时，有指定endpoint，就不能再使用as_view（）方法中的名称 来构建url，而要使用endpoint的值来构建url
print(url_for('mlist'))
2.类视图的好处
1.可以继承，把一些共性的东西抽取出来放到父视图中，子视图直接拿来用就可以了。
2.但是也不是说所有的视图都要使用类视图，这个要根据情况而定。视图函数用得最多
#类视图的好处：
#需求：以后有 好几个url，都需要返回json对象的格式
class ListView2(views.View):
def getData(self):
raise NotImplementedError
def dispatch_request(self):
return jsonify(self.getData())
class JSONView(ListView2):
def getData(self):
return {'uname':'momo','age':'22'}
class JSONView2(ListView2):
def getData(self):
return {'bname':'水浒传','price':'89'}
app.add_url_rule('/json/',view_func=JSONView.as_view('my_json'))
app.add_url_rule('/json2/',view_func=JSONView2.as_view('my_json2'))
3.标准类视图使用场景
#需求2：有好几个url，跳转到到不同的页面时，会带一个相同的参数过去
# #登录功能
# class LoginView(views.View):
# def dispatch_request(self):
# return render_template('login.html',ads="茅台酒 998")
#
# #注册功能
# class RegisterView(views.View):
# def dispatch_request(self):
# return render_template('register.html',ads="茅台酒 998")
#改进：突出类视图的好处
class ADSView(views.View):
def __init__(self):
super(ADSView, self).__init__()
self.context={
'ads':'华为 5G'
}
#登录功能
class LoginView(ADSView):
def dispatch_request(self):
self.context.update({'pid':'好牛的一本书'})
return render_template('login.html',**self.context)
#注册功能
class RegisterView(ADSView):
def dispatch_request(self):
return render_template('register.html',**self.context)
app.add_url_rule('/login/',view_func=LoginView.as_view('login'))
app.add_url_rule('/register/',view_func=RegisterView.as_view('register'))
基于调度方法的类视图
基于调度方法的类视图
1. 基于方法的类视图，是根据请求的`method`来执行不同的方法的。如果用户是发送的`get`请求，那么将会执行这个类的`get`方法。如果用户发送的是`post`请求，那么将会执行这个类的`post`方法。其他的method类似，比如`delete`、`put`。
2. 这种方式，可以让代码更加简洁。所有和`get`请求相关的代码都放在`get`方法中，所有和`post`请求相关的代码都放在`post`方法中。就不需要跟之前的函数一样，通过`request.method == 'GET'`。
代码演示：
#定义一个基于方法调度的 类视图
class LoginView(views.MethodView):
def get(self):
return render_template('login.html')
def post(self):
#模拟实现
#拿到前端页面传过来的 账号 和密码 去数据库做查询操作 查询到 (跳转主页面) ,反之跳转到login.html页面并给出错误提示信息
uname = request.form['uname']
pwd = request.form['pwd']
if uname=="momo" and pwd =="123":
return render_template('index.html')
else:
return render_template('login.html',error="用户名或者密码错误")
# 注册类视图
app.add_url_rule('/login/', view_func=LoginView.as_view('my_login'))
改进1：
#改进1
class LoginView(views.MethodView):
def get(self,error=None):
return render_template('login.html',error=error)
def post(self):
#模拟实现
#拿到前端页面传过来的 账号 和密码 去数据库做查询操作 查询到 (跳转主页面) ,反之跳转到login.html页面并给出错误提示信息
uname = request.form['uname']
pwd = request.form['pwd']
if uname=="momo" and pwd =="123":
return render_template('index.html')
else:
return self.get(error="用户名或者密码错误")
# 注册类视图
app.add_url_rule('/login/', view_func=LoginView.as_view('my_login'))
html页面
<form action="/login/" method="post">
<table>
<tr>
<td>账号：</td>
<td><input type="text" name="uname"></td>
</tr>
<tr>
<td>密码：</td>
<td><input type="password" name="pwd"></td>
</tr>
<tr>
<td></td>
<td><input type="submit" value="立即登录"></td>
</tr>
<tr>
<td colspan="2">
{# <font color="red">{{ error }}</font>#}
{# 优化写法 ：判断 #}
{% if error %}
<font color="red">{{ error }}</font>
{% endif %}
</td>
</tr>
</table>
</form>
改进2:
# 改进2 :基于调度方法的类视图 ，通常get()方法处理get请求,post()方法处理post请求，为了便于管理,不推荐post方法和get方法互相调用
class LoginView(views.MethodView):
def __jump(self,error=None):
return render_template('login.html', error=error)
def get(self, error=None):
return self.__jump()
def post(self):
# 模拟实现
#拿到前端页面传过来的 账号 和密码 去数据库做查询操作 查询到 (跳转主页面) ,反之跳转到login.html页面并给出错误提示信息
uname = request.form['uname']
pwd = request.form['pwd']
if uname == "momo" and pwd == "123":
return render_template('index.html')
else:
return self.__jump(error="用户名或者密码错误")
# 注册类视图
app.add_url_rule('/login/', view_func=LoginView.as_view('my_login'))
类视图中使用装饰器
类视图中使用装饰器
简言之，python装饰器就是用于拓展【原来函数功能】的一种函数，这个【函数的特殊之处在于它的返回值也是一个函数】，使用python装饰器的 【好处】就是在不用更改原函数的代码前提下给函数增加新的功能。
1. 在视图函数中使用自定义装饰器，那么自己定义的装饰器必须放在`app.route`下面。否则这个装饰器就起不到任何作用。
例：
定义一个装饰器
#需求：查看设置个人信息时，只有检测到用户已经登录了才能查看，若没有登录，则无法查看并给出提示信息
def login_requierd(func):
@wraps(func)
def wrapper(*args,**kwargs):
username = request.args.get("username")
if username and username =='momo':
return func(*args,**kwargs)
else:
return '请先登录'
return wrapper
使用自定义装饰器：
@app.route('/settings/')
@login_requierd
def settings():
return '这是设置界面'
2. 在类视图中使用装饰器,需要重写类视图的一个类属性`decorators`，这个类属性是一个列表或者元组都可以，里面装的就是所有的装饰器。
定义一个装饰器
#需求：查看设置个人信息时，只有检测到用户已经登录了才能查看，若没有登录，则无法查看并给出提示信息
def login_requierd(func):
@wraps(func)
def wrapper(*args,**kwargs):
username = request.args.get("username")
if username and username =='momo':
return func(*args,**kwargs)
else:
return '请先登录'
return wrapper
使用自定义装饰器：
class ProfileView(views.View):
decorators = [login_requierd]
def dispatch_request(self):
return '这是个人中心界面'
app.add_url_rule('/profile/',view_func=ProfileView.as_view('profile'))
蓝图的基本使用
蓝图的基本使用
蓝图：
之前我们写的url和视图函数都是处在同一个文件，如果项目比较大的话，这显然不是一个合理的结构，而蓝图可以优雅的帮我们实现这种需求。
1. 蓝图的作用就是让我们的Flask项目更加模块化，结构更加清晰,为了更好的管理项目 让项目达到分层解耦 而产生的。可以将相同模块的视图函数放在同一个蓝图下，同一个文件中，方便管理。
2. 基本语法：
* 在蓝图文件中导入Blueprint：
from flask import Blueprint
user_bp = Blueprint('user',__name__)
* 在主app文件中注册蓝图：
from flask import Flask
from blueprints.user import user_bp
app = Flask(__name__)
app.register_blueprint(user_bp)
3. 如果想要某个蓝图下的所有url都有一个url前缀，那么可以在定义蓝图的时候，指定url_prefix参数：
user_bp = Blueprint('user',__name__,url_prefix='/user')
#个人中心的 url与视图函数
@user_bp.route('/profile/')
def profile():
return '个人中心页面'
#个人设置中心的 url与视图函数
@user_bp.route('/settings/')
def settings():
return '个人设置页面'
注意： 在定义url_prefix的时候，要注意后面的斜杠，如果给了，那么以后在定义url与视图函数的时候，就不要再在url前面加斜杠了。
访问结果如：
蓝图中模版文件寻找规则
蓝图中模版文件寻找规则
4. 蓝图模版文件的查找：
* 如果项目中的templates文件夹中有相应的模版文件，就直接使用了。
* 如果项目中的templates文件夹中没有相应的模版文件，那么就到在定义蓝图的时候指定的路径中寻找。并且蓝图中指定的路径可以为相对路径，相对的是当前这个蓝图文件所在的目录。比如：
news_bp = Blueprint('news',__name__,url_prefix='/news',template_folder='news_page')
项目截图为：
因为这个蓝图文件是在blueprints/news.py，那么就会到blueprints这个文件夹下的news_page文件夹中寻找模版文件。
小总结：
常规：蓝图文件在 查找模版文件时，会以templates为根目录进行查找
news_bp = Blueprint('news',__name__,url_prefix='/news')
注意1：个性化coder 喜欢在【创建蓝图对象的时候】 指定 模版文件的查找路径 如下：
news_bp = Blueprint('news',__name__,url_prefix='/news',template_folder='news_page')
注意2：只有确定templates目录下没有对应的 html文件名的时候，才会去蓝图文件指定的目录下查找，指定才会生效
注意3：若templates目录下，有一个与蓝图文件指定的目录下同名的一个 html文件时，优先走templates目录下的东西
蓝图中静态文件寻找规则
蓝图中静态文件寻找规则
5. 蓝图中静态文件的查找规则：
* 在模版文件中，加载静态文件，如果使用url_for('static')，那么就只会在app指定的静态文件夹目录下查找 静态文件。如：
html：
<link rel="stylesheet" href="{{ url_for('static',filename='news_list.css') }}">
寻找结果如图：
* 如果在加载静态文件的时候，指定的蓝图的名字，比如`news.static`，那么就会到这个蓝图指定的static_folder下查找静态文件。如：
python：
from flask import Blueprint,render_template,url_for
news_bp = Blueprint('news',__name__,url_prefix='/news',template_folder='news_page',static_folder='news_page_static')
html：
<link rel="stylesheet" href="{{ url_for('news.static',filename='news_list.css') }}">
寻找结果如图：
小总结：
蓝图文件查找方式1【掌握】：查找静态文件时，正常情况下，会以static为根目录进行查找
<link href="{{ url_for('static',filename='news_list.css') }}" rel="stylesheet" type="text/css">
蓝图文件查找方式2【了解】：查找静态文件时，非正常情况下，需要用url_for('蓝图的名字.static'),
然后会去蓝图对象在创建时指定的静态文件夹目录下 去查找静态文件
news_bp = Blueprint('news',__name__,url_prefix='/news',template_folder='news_page',static_folder='news_statics')
<link href="{{ url_for('news.static',filename='news_list.css') }}" rel="stylesheet" type="text/css">
url_for反转蓝图注意事项
url_for反转蓝图注意事项
6. url_for反转蓝图中的视图函数为url：
如果使用蓝图，那么以后想要反转蓝图中的视图函数为url，那么就应该在使用url_for的时候指定这个蓝图名字。 app类中、模版中、同一个蓝图类中都是如此。否则就找不到这个endpoint。
如app类 blueprint_demo.py中：
#如下写法：才找得到 url_for('蓝图名称.方法名')
print(url_for('news.news_list'))#/news/list/
如模版/templates/index.html中：
<a href="{{ url_for('news.news_list')}}">新闻列表 OK写法</a>
{# <a href="{{ url_for('news_list')}}">新闻列表 no Ok写法</a>#}
如同一个蓝图类/blueprints/news.py中：
from flask import Blueprint,render_template,url_for
news_bp = Blueprint('news',__name__,url_prefix='/news',template_folder='news_page',static_folder='news_page_static')
@news_bp.route('/list/')
def news_list():
print(url_for('news.news_detail')) #/news/detail/
return render_template('news_list.html')
@news_bp.route('/detail/')
def news_detail():
return '新闻详情页面'
子域名实现详解
子域名实现详解
蓝图实现子域名：
1. 使用蓝图技术。
2. 在创建蓝图对象的时候，需要传递一个`subdomain`参数，来指定这个子域名的前缀。
例如：cms_bp= Blueprint('cms',__name__,subdomain='cms')
3. 需要在主app文件中，需要配置app.config的SERVER_NAME参数。例如：
app.config['SERVER_NAME']='momo.com:5000'
4. 在`C:\Windows\System32\drivers\etc`下，找到hosts文件，然后添加域名与本机的映射。 域名和子域名都需要做映射。例如：
127.0.0.1 momo.com
127.0.0.1 cms.momo.com
注意：
* ip地址不能有子域名。
* localhost也不能有子域名。
1.什么是cookie：
在网站中，http请求是无状态的。也就是说即使第一次和服务器连接后并且登录成功后，第二次请求服务器依然不能知道当前请求是哪个用户。
cookie的出现就是为了解决这个问题，第一次登录后服务器返回一些数据（cookie）给浏览器，然后浏览器保存在本地，当该用户发送第二次请求的时候，就会自动的把上次请求存储的cookie数据自动的携带给服务器，服务器通过浏览器携带的数据就能判断当前用户是哪个了。
cookie存储的数据量有限，不同的浏览器有不同的存储大小，但一般不超过4KB。因此使用cookie只能存储一些小量的数据。
2. cookie的有效期：
服务器可以设置cookie的有效期，以后浏览器会自动的清除过期的cookie。
3. cookie有域名的概念：
只有访问同一个域名，才会把之前相同域名返回的cookie携带给服务器。也就是说，访问百度的时候，不会把新浪网站的cookie发送给百度。
4.画个图演示Cookie的工作过程
。。。。。。
1. 设置cookie：
设置cookie是在Response的对象上设置。
`flask.Response`对象有一个`set_cookie`方法，可以通过这个方法来设置`cookie`信息。
key,value形式设置信息
2.查看cookie信息
在Chrome浏览器中查看cookie的方式：
* 方式1.借助于 开发调式工具进行查看
* 方式2.在Chrome的设置界面->高级设置->内容设置->所有cookie->找到当前域名下的cookie。
3. 删除cookie：
方式1：通过`Response对象.delete_cookie`，指定cookie的key，就可以删除cookie了。
方式2：在客户端浏览器 人为的删除（清除浏览器浏览历史记录后，很多网站之前免密登录的都不好使了）
4. 设置cookie的有效期：
5. 设置cookie的有效域名：
演示代码如下：
from flask import Flask,request,Response
app = Flask(__name__)
@app.route('/')
def hello_world():
resp = Response("SXT")
#设置Cookie信息
resp.set_cookie('username','momo')
resp.set_cookie('pwd','123456')
return resp
@app.route('/del/')
def delete_cookie():
resp = Response("删除cookie")
#删除Cookie信息
resp.delete_cookie('username')
return resp
if __name__ == '__main__':
app.run(debug=True)
4. 设置cookie的有效期：
4. 设置cookie的有效期：
* max_age：以秒为单位，距离现在多少秒后cookie会过期。
* expires：为datetime类型。这个时间需要设置为格林尼治时间，相对北京时间来说 会自动+8小时
* 如果max_age和expires都设置了，那么这时候以max_age为标准。
* 默认的过期时间：如果没有显示的指定过期时间，那么这个cookie将会在浏览器关闭后过期。
注意：
max_age在IE8以下的浏览器是不支持的。
expires虽然在新版的HTTP协议中是被废弃了，但是到目前为止，所有的浏览器都还是能够支持，所以如果想要兼容IE8以下的浏览器，那么应该使用expires，否则可以使用max_age。
演示代码如下：
from flask import Flask,request,Response
from datetime import datetime,timedelta
app = Flask(__name__)
@app.route('/createCookie/')
def createCookie():
resp = Response("服务器端通过Response对象创建Cookie信息 并返回给客户端 并保存在客户端")
#设置Cookie的有效期【存活时间】方式1 ：max_age=以秒为单位【距离现在多少秒后cookie会过期】
# resp.set_cookie('uname',"momo",max_age=1200)
#设置Cookie的有效期【存活时间】方式2 ： expires= datetime类型。
#这个时间需要设置为格林尼治时间，相对北京时间来说 会自动+8小时
# ex = datetime(year=2019, month=2, day=28, hour=0, minute=0, second=0)
ex = datetime(year=2019, month=2, day=27, hour=16, minute=0, second=0)
# resp.set_cookie('uname', "momo", expires=ex)
ex2 =datetime.now() + timedelta(days=30,hours=16)
#如果max_age和expires都设置了，那么这时候以max_age为标准
# resp.set_cookie('pwd',"123456",max_age=300,expires=ex2)
resp.set_cookie('pwd',"123456",expires=ex2)
return resp
if __name__ == '__main__':
app.run(debug=True)
5. 设置cookie的有效域名：
5. 设置cookie的有效域名：
cookie默认是只能在主域名下使用。
如果想要在子域名下使用，那么应该给`set_cookie`传递一个参数`domain='.momo.com'`，这样其他子域名才能访问到这个cookie信息。
代码演示如下:
from flask import Blueprint,request
bp = Blueprint('cms',__name__,subdomain='cms')
@bp.route('/')
def index():
# request.args
# request.form
# request.files
uname = request.cookies.get('uname')
return uname or "没有获取到cookie"
windows上的hosts文件如下：
from flask import Flask,Response,request
from datetime import datetime,timedelta
from cmsblueprint import bp
app = Flask(__name__)
app.register_blueprint(bp)
app.config['SERVER_NAME'] = 'momo.com:5000'
@app.route('/createCookie/')
def createCookie():
resp = Response("服务器端通过Response对象创建Cookie信息 并返回给客户端 并保存在客户端")
ex = datetime(year=2019, month=2, day=27, hour=16, minute=0, second=0)
ex2 =datetime.now() + timedelta(days=30,hours=16)
resp.set_cookie('pwd',"123456",expires=ex2)
#给Cookie信息设置 存活时间 【有效域名---》子域名】
resp.set_cookie('uname', "momo", expires=ex,domain=".momo.com")
return resp
if __name__ == '__main__':
app.run(debug=True)
session：
session：
session技术 也叫 会话技术。
1. session的基本概念：
session和cookie的作用有点类似，都是为了存储用户相关的信息，都是为了解决http协议无状态的这个特点。不同的是，cookie信息是存储在客户端，而session信息是存储在服务器端。
需要注意的是，不同的语言，不同的框架，有不同的实现。虽然底层的实现不完全一样，但目的都是让服务器端能方便的存储数据而产生的。
session的出现，是为了解决cookie存储数据不安全的问题的。
2. session的跟踪机制跟cookie有关：
Flask框架中，session的跟踪机制跟Cookie有关，这也就意味着脱离了Cookie，session就不好使了。
因为session跟踪机制跟cookie有关，所以，要分服务器端和客户端分别起到什么功能来理解。
* session工作过程：
服务器端可以采用类似于mysql、redis等技术来存储session信息。
原理是，客户端发送验证信息过来（比如用户名和密码），服务器验证成功后，
把用户的相关信息存储到服务器端的session中（可想象为一个容器），
再通过盐的机制，盐起到混淆原数据的作用（类似于加密），
然后随机生成一个唯一的session_id，用来标识(用户名和密码)并存储到session中，
之后再把这个session_id存储到cookie中返回给浏览器。
浏览器以后再请求我们服务器的时候，就会把这个session_id通过Cookie技术自动的发送给服务器，
服务器端再从cookie中提取session_id，然后从服务器的session容器中找到这个用户的相关信息。
这样就可以达到安全识别用户的需求了。
存储在服务器的数据会更加的安全，不容易被窃取。
但存储在服务器也有一定的弊端，就是会占用服务器的资源，但现在服务器已经发展至今，一些session信息还是绰绰有余的。
*服务器端功能：
1.把用户的相关信息存储到服务器端的session中
2.通过盐的机制加密随机生成一个唯一的session_id,用来标识用户相关信息并将session_id也存入session中
3.把session作为cookie的key，session_id作为cookie的value创建cookie信息并返回给客户端
4.客户端发送第二次以后的请求时，获取cookie信息，与服务器端session容器中session_id对比，得出指定 用户信息。
* 客户端功能：
1.通过cookie存储session加密后的session_id信息
2.以后浏览器再请求服务器的时候，就会自动的把cookie信息（包含session_id）发送给服务器
3.扩展面试题：
若客户端禁用了浏览器的Cookie功能，session功能想继续保留，该咋整？给出你的实现思路(能代码实现最好)
Flask操作session：
Flask操作session：
1. 设置session：
通过`flask.session`就可以操作session了。操作`session`就跟操作字典是一样的。
session['uname']='momo'。
2. 获取session：
也是类似字典，
session.get(key)。
3. 删除session中的值：
也是类似字典。可以有2种方式删除session中的值。
* session.pop(key)。
* session.clear()：删除session中所有的值。
4. 设置session的有效期：
如果没有设置session的有效期。那么默认就是浏览器关闭后过期。
如果设置session.permanent=True，那么就会默认在31天后过期。
如果不想在31天后过期，按如下步骤操作
1：session.permanent=True
2：可以设置`app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(hour=2)`在两个小时后过期。
代码演示如下：
from flask import Flask,session,Response
import os
from datetime import timedelta
app = Flask(__name__)
#设置SECRET_KEY
app.config['SECRET_KEY'] = os.urandom(24)
# 5.设置session的有效期方式2【指session可以往后活多长时间】
app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(hours=2)
# 1.设置session
@app.route('/')
def index():
session['uname'] = 'momo'
session['pwd'] = '123'
#底层
# resp = Response()
# resp.set_cookie('session')
#4.设置session的有效期方式1【持久化 31天】
session.permanent = True
# print(type(session))
return 'Hello World!'
#2.获取session
@app.route('/getSession/')
def getSession():
uname = session.get('uname')
pwd = session.get('pwd')
print(pwd)
return uname or '没有session'
#3.删除session
@app.route('/deleteSession/')
def deleteSession():
#删除指定的key的session
# session.pop('uname')
#删除session中的所有的key 【删除所有】
session.clear()
return '删除成功'
if __name__ == '__main__':
app.run(debug=True)
Local对象隔离线程间的对象_即ThreadLocal变量
Local对象隔离线程间的对象_即ThreadLocal变量
1.Local对象：
在Flask中，类似于`request`对象，其实是绑定到了一个`werkzeug.local.Local`对象上。
这样，即使是同一个对象，那么在多个线程中都是隔离的。类似的对象还有`session`以及`g`对象。
from werkzeug.local import Local
#flask=werkzeug + sqlalchemy + jinja2
2.ThreadLocal变量：
Python提供了ThreadLocal 变量，它本身是一个全局变量，
但是每个线程却可以利用它来保存属于自己的私有数据，
这些私有数据对其他线程也是不可见的。
3.总结：
只要满足绑定到"local"或"Local"对象上的属性，在每个线程中都是隔离的，那么他就叫做`ThreadLocal`对象,也叫'ThreadLocal'变量。
4.代码演示：
from threading import Thread,local
local =local()
local.request = '具体用户的请求对象'
class MyThread(Thread):
def run(self):
local.request = 'haha'
print('子线程：',local.request)
mythread = MyThread()
mythread.start()
mythread.join()
print('主线程：',local.request)
from werkzeug.local import Local
local = Local()
local.request = '具体用户的请求对象'
class MyThread(Thread):
def run(self):
local.request = 'tantan'
print('子线程：',local.request)
mythread = MyThread()
mythread.start()
mythread.join()
print('主线程：',local.request)
Flask_app上下文详解:
Flask_app上下文详解:
app上下文，也叫应用上下文。
应用上下文：
应用上下文是存放到一个`LocalStack`的栈中。和应用app相关的操作就必须要用到应用上下文，
比如通过`current_app`获取当前的这个`app`名字。
注意1：
在视图函数中，不用担心应用上下文的问题。因为视图函数要执行，那么肯定是通过访问url的方式执行的，
那么这种情况下，Flask底层就已经自动的帮我们把应用上下文都推入到了相应的栈中。
注意2：
如果想要在视图函数外面执行相关的操作，
比如获取当前的app名称，那么就必须要手动推入应用上下文：
第一种方式：便于理解的写法
from flask import Flask,current_app
app = Flask(__name__)
#app上下文
app_context = app.app_context()
app_context.push()
print(current_app.name)
@app.route('/')
def hello_world():
print(current_app.name) #获取应用的名称
return 'Hello World!'
if __name__ == '__main__':
app.run(debug=True)
第二种方式：用with语句
from flask import Flask,current_app
app = Flask(__name__)
#app上下文
#换一种写法
with app.app_context():
print(current_app.name)
@app.route('/')
def hello_world():
print(current_app.name) #获取应用的名称
return 'Hello World!'
if __name__ == '__main__':
app.run(debug=True)
Flask_request上下文详解：
Flask_request上下文详解：
请求上下文：
请求上下文也是存放到一个`LocalStack`的栈中。
和请求相关的操作就必须用到请求上下文，比如使用`url_for`反转视图函数。
注意1：
在视图函数中，不用担心请求上下文的问题。
因为视图函数要执行，那么肯定是通过访问url的方式执行的，
那么这种情况下，Flask底层就已经自动的帮我们把应用上下文和请求上下文都推入到了相应的栈中。
注意2：
如果想要在视图函数外面执行相关的操作，
比如反转url，那么就必须要手动推入请求上下文：
底层代码执行说明：
* 推入请求上下文到栈中，会首先判断有没有应用上下文，
* 如果没有那么就会先推入应用上下文到栈中，
* 然后再推入请求上下文到栈中
from flask import Flask,url_for
app = Flask(__name__)
#request上下文
@app.route('/hi')
def hi():
print(url_for('my_list')) #获取构建得到的url
return 'Hello World!'
@app.route('/list/')
def my_list():
return '返回列表'
# print(url_for('my_list')) #获取构建得到的url
# with app.app_context():
# print(url_for('my_list'))
#查看报错源码
with app.test_request_context():
#手动推入一个请求上下文到请求上下文栈中
#如果当前app应用上下文栈中没有app应用上下文
#那么会首先推入一个app应用上下文到栈中
print(url_for('my_list'))
if __name__ == '__main__':
app.run(debug=True)
总结：
为什么上下文需要放在栈中？
1.应用上下文：Flask底层是基于werkzeug，werkzeug是可以包含多个app的，所以这时候用一个栈来保存。
如果你在使用app1，那么app1应该是要在栈的顶部，如果用完了app1，那么app1应该从栈中删除。方便其他代码使用下面的app。
2.如果在写测试代码，或者离线脚本的时候，我们有时候可能需要创建多个请求上下文，这时候就需要存放到一个栈中了。使用哪个请求上下文的时候，就把对应的请求上下文放到栈的顶部，用完了就要把这个请求上下文从栈中移除掉。
Flask_线程隔离的g对象使用详解：
Flask_线程隔离的g对象使用详解：
保存为全局对象g对象的好处：
g对象是在整个Flask应用运行期间都是可以使用的。
并且也跟request一样，是线程隔离的。
这个对象是专门用来存储开发者自己定义的一些数据，方便在整个Flask程序中都可以使用。
一般使用就是，将一些经常会用到的数据绑定到上面，以后就直接从g上面取就可以了，而不需要通过传参的形式，这样更加方便。
g对象使用场景：有一个工具类utils.py 和 用户办理业务：
def funa(uname):
print('funa %s' % uname)
def funb(uname):
print('funb %s' % uname)
def func(uname):
print('func %s' % uname)
用户办理业务：
from flask import Flask,request
from utils import funa,funb,func
app = Flask(__name__)
#Flask_线程隔离的g对象使用详解
@app.route("/profile/")
def my_profile():
#从url中取参
uname = request.args.get('uname')
#调用功能函数办理业务
funa(uname)
funb(uname)
func(uname)
#每次都得传参 麻烦，引入g对象进行优化
return "办理业务成功"
if __name__ == '__main__':
app.run(debug=True)
优化工具类utils.py：
from flask import g
def funa():
print('funa %s' % g.uname)
def funb():
print('funb %s' % g.uname)
def func():
print('func %s' % g.uname)
优化用户办理业务：
from flask import Flask,request,g
from utils import funa,funb,func
app = Flask(__name__)
#Flask_线程隔离的g对象使用详解
@app.route("/profile/")
def my_profile():
#从url中取参
uname = request.args.get('uname')
#调用功能函数办理业务
# funa(uname)
# funb(uname)
# func(uname)
#每次都得传参 麻烦，引入g对象进行优化
g.uname = uname
funa()
funb()
func()
return "办理业务成功"
if __name__ == '__main__':
app.run(debug=True)
Flask_钩子函数概念_常见的钩子函数：
Flask_钩子函数概念_常见的钩子函数：
1.钩子函数概念：
在Flask中钩子函数是使用特定的装饰器装饰的函数。为什么叫做钩子函数呢，是因为钩子函数可以在正常执行的代码中，插入一段自己想要执行的代码。那么这种函数就叫做钩子函数。
2.常见的钩子函数：
before_first_request：处理项目的第一次请求之前执行。
@app.before_first_request
def first_request():
print 'first time request'
before_request：在每次请求之前执行。通常可以用这个装饰器来给视图函数增加一些变量。请求已经到达了Flask，但是还没有进入到具体的视图函数之前调用。一般这个就是在视图函数之前，我们可以把一些后面需要用到的数据先处理好，方便视图函数使用。
@app.before_request
def before_request():
if not hasattr(g,'glo1'):
setattr(g,'glo1','想要设置的')
teardown_appcontext：不管是否有异常，注册的函数都会在每次请求之后执行。
@app.teardown_appcontext
def teardown(exc=None):
if exc is None:
db.session.commit()
else:
db.session.rollback()
db.session.remove()
template_filter：在使用Jinja2模板的时候自定义过滤器。
@app.template_filter("upper")
def upper_filter(s):
return s.upper()
context_processor：上下文处理器。使用这个钩子函数，必须返回一个字典。这个字典中的值在所有模版中都可以使用。这个钩子函数的函数是，如果一些在很多模版中都要用到的变量，那么就可以使用这个钩子函数来返回，而不用在每个视图函数中的`render_template`中去写，这样可以让代码更加简洁和好维护。
@app.context_processor
def context_processor():
if hasattr(g,'user'):
return {"current_user":g.user}
else:
return {}
errorhandler：errorhandler接收状态码，可以自定义返回这种状态码的响应的处理方法。在发生一些异常的时候，比如404错误，比如500错误,那么如果想要优雅的处理这些错误，就可以使用`errorhandler`来出来。
@app.errorhandler(404)
def page_not_found(error):
return 'This page does not exist',404
Flask_before_first_request和before_request详解：
Flask_before_first_request和before_request详解：
1.before_first_request：处理项目的第一次请求之前执行。
from flask import Flask,request,session,current_app,url_for,g
import os
app = Flask(__name__)
@app.route('/')
def hello_world():
print("hi")
return "hello world "
@app.before_first_request
def first_request():
print('hello world')
if __name__ == '__main__':
app.run(debug=True)
2.before_request：在每次请求之前执行。通常可以用这个装饰器来给视图函数增加一些变量。
请求已经到达了Flask，但是还没有进入到具体的视图函数之前调用。一般这个就是在视图函数之前，
我们可以把一些后面需要用到的数据先处理好，方便视图函数使用。
from flask import Flask,request,session,current_app,url_for,g
import os
app = Flask(__name__)
app.config['SECRET_KEY']=os.urandom(24) #加盐 混淆原数据的作用
@app.route('/')
def hello_world():
print("hi")
session['uname']="momo"
return "hello world "
@app.route('/li')
def mylist():
print("mylist")
# print("直接取出",g.user)
if hasattr(g,"user"):
print("条件取出", g.user)
return "hello world "
@app.before_request
def before_request():
# print('在视图函数执行之前执行的钩子函数')
# 场景：若用户已经登录了，验证时把用户名放入session中,之后取出来，放入钩子函数，以后访问的视图函数中可直接取出来使用
uname = session.get('uname')
print(uname)
if uname:
g.user = uname
if __name__ == '__main__':
app.run(debug=True)
钩子函数context_processor详解：
钩子函数context_processor详解：
1.context_processor：上下文处理器。使用这个钩子函数，必须返回一个字典。这个字典中的值在所有模版中都可以使用。这个钩子函数的函数是，如果一些在很多模版中都要用到的变量，那么就可以使用这个钩子函数来返回，而不用在每个视图函数中的`render_template`中去写，这样可以让代码更加简洁和好维护。
2.代码演示：
from flask import Flask,request,session,current_app,url_for,g,render_template
import os
app = Flask(__name__)
app.config['SECRET_KEY']=os.urandom(24) #加盐 混淆原数据的作用
@app.route('/')
def hello_world():
print("hi")
session['uname']="momo"
# return "hello world "
return render_template("index.html")
@app.route('/li')
def mylist():
print("mylist")
# print("直接取出",g.user)
if hasattr(g,"user"):
print("条件取出", g.user)
# return "hello world "
return render_template('list.html')
@app.before_request
def before_request():
# print('在视图函数执行之前执行的钩子函数')
# 场景：若用户已经登录了，验证时把用户名放入session中,之后取出来，放入钩子函数，以后访问的视图函数中可直接取出来使用
uname = session.get('uname')
print(uname)
if uname:
g.user = uname
@app.context_processor
def context_processor():
if hasattr(g,'user'):
return {"current_user":g.user}
else:
return {}
if __name__ == '__main__':
app.run(debug=True)
钩子函数errorhandler详解：
钩子函数errorhandler详解：
1.errorhandler：errorhandler接收状态码，可以自定义返回这种状态码的响应的处理方法。在发生一些异常的时候，比如404错误，比如500错误,那么如果想要优雅的处理这些错误，就可以使用`errorhandler`来出来。
需要注意几点：
* 在errorhandler装饰的钩子函数下，记得要返回相应的状态码。
* 在errorhandler装饰的钩子函数中，必须要写一个参数，来接收错误的信息，如果没有参数，就会直接报错。
* 使用`flask.abort`可以手动的抛出相应的错误，比如开发者在发现参数不正确的时候可以自己手动的抛出一个400错误。
2.常见的500错误处理：
from flask import Flask,request,session,current_app,url_for,g,render_template,abort
import os
app = Flask(__name__)
app.config['SECRET_KEY']=os.urandom(24) #加盐 混淆原数据的作用
@app.route('/')
def hello_world():
print("hi")
session['uname']="momo"
#500
print(g.user)
return render_template("index.html")
@app.errorhandler(500)
def server_error(error):
return render_template('500.html'),500
if __name__ == '__main__':
app.run()
3.常见的404错误处理：
from flask import Flask,request,session,current_app,url_for,g,render_template,abort
import os
app = Flask(__name__)
@app.route('/li')
def mylist():
print("mylist")
if hasattr(g,"user"):
print("条件取出", g.user)
return render_template('list.html')
@app.errorhandler(404)
def page_not_found(error):
return render_template('404.html'),404
if __name__ == '__main__':
app.run()
4.Flask中的abort函数可以手动的抛出相应的错误（如400）：
from flask import Flask,request,session,current_app,url_for,g,render_template,abort
import os
app = Flask(__name__)
app.config['SECRET_KEY']=os.urandom(24) #加盐 混淆原数据的作用
@app.route('/')
def hello_world():
print("hi")
session['uname']="momo"
return render_template("index.html")
@app.errorhandler(400)
def args_error(error):
return '您的参数不正确',400
#该功能需要先登录才能访问
@app.route('/setting/')
def setting():
uname = session.get("uname")
if uname :
return '欢迎来到设置页面'
else:
# 如果没有登录，这时候我就让他跳转到400错误
abort(400)
return render_template('list.html')
if __name__ == '__main__':
app.run()
Flask_信号机制：
Flask_信号机制：
1.信号机制：
大白话来说，类似于两方属于敌对关系时，某人在敌对方阵营进行交谈，一旦遇到特殊情况，某人便会发送信号，他的同伙接收（监听）到他发的信号后，同伙便会做出一系列的应对策略(杀进去|撤退)。
flask中的信号使用的是一个第三方插件，叫做blinker。通过pip list看一下，如果没有安装，通过以下命令即可安装blinker：
pip install blinker
2.自定义信号步骤
自定义信号可分为3步来完成。
第一是创建一个信号，第二是监听一个信号，第三是发送一个信号。
以下将对这三步进行讲解：
1. 创建信号：定义信号需要使用到blinker这个包的Namespace类来创建一个命名空间。比如定义一个在访问了某个视图函数的时候的信号。示例代码如下：
# Namespace的作用：为了防止多人开发的时候，信号名字冲突的问题
from blinker import Namespace
mysignal = Namespace()
signal1 = mysignal.signal('信号名称')
2. 监听信号：监听信号使用signal1对象的connect方法，在这个方法中需要传递一个函数，用来监听到这个信号后做该做的事情。示例代码如下：
def func1(sender,uname):
print(sender)
print(uname)
signal1.connect(func1)
3. 发送信号：发送信号使用signal1对象的send方法，这个方法可以传递一些其他参数过去。示例代码如下：
signal1.send(uname='momo')
3.代码演示：
from flask import Flask
from blinker import Namespace
app = Flask(__name__)
#【1】信号机制 3步走
# Namespace：命名空间
#1.定义信号
sSpace = Namespace()
fire_signal = sSpace.signal('发送信号火箭')
#2.监听信号
def fire_play(sender):
print(sender)
print("start play")
fire_signal.connect(fire_play)
#3.发送一个信号
fire_signal.send()
if __name__ == '__main__':
app.run(debug=True)
4.了解Flask中文网信号：
http://docs.jinkan.org/docs/flask/signals.html
Flask_信号使用场景_存储用户登录日志：
Flask_信号使用场景_存储用户登录日志：
1.信号使用场景
定义一个登录的信号，以后用户登录进来以后
就发送一个登录信号，然后能够监听这个信号
在监听到这个信号以后，就记录当前这个用户登录的信息
用信号的方式，记录用户的登录信息即登录日志
2.编写一个signals.py文件创建登录信号
from blinker import Namespace
from datetime import datetime
from flask import request,g
namespace = Namespace()
#创建登录信号
login_signal = namespace.signal('login')
def login_log(sender):
# 用户名 登录时间 ip地址
now = datetime.now()
ip = request.remote_addr
log_data = "{uname}*{now}*{ip}".format(uname=g.uname, now=now, ip=ip)
with open('login_log.txt','a') as f:
f.write(log_data + "\n")
f.close()
#监听信号
login_signal.connect(login_log)
3.使用信号存储用户登录日志
from flask import Flask,request,g
from signals import login_signal
app = Flask(__name__)
@app.route('/login/')
def login():
# 通过查询字符串的形式来传递uname这个参数
uname = request.args.get('uname')
if uname:
g.uname = uname
# 发送信号
login_signal.send()
return '登录成功！'
else:
return '请输入用户名！'
if __name__ == '__main__':
app.run(debug=True)
Flask_内置信号:
Flask_内置信号:
flask内置了10个常用的信号。
1. template_rendered：模版渲染完成后的信号。
2. before_render_template：模版渲染之前的信号。
3. request_started：请求开始之前，在到达视图函数之前发送信号。
4. request_finished：请求结束时，在响应发送给客户端之前发送信号。
5. request_tearing_down：请求对象被销毁时发送的信号，即使在请求过程中发生异常也会发送信号。
6. got_request_exception：在请求过程中抛出异常时发送信号，异常本身会通过exception传递到订阅（监听）的函数中。一般可以监听这个信号，来记录网站异常信息。
7. appcontext_tearing_down：应用上下文被销毁时发送的信号。
8. appcontext_pushed：应用上下文被推入到栈上时发送的信号。
9. appcontext_popped：应用上下文被推出栈时发送的信号。
10. message_flashed：调用了Flask的`flash`方法时发送的信号。
代码演示：
template_rendered的使用：
from flask import Flask,request,g,template_rendered,got_request_exception,render_template
app = Flask(__name__)
#内置信号
#模版渲染完成后的信号。
def template_rendered_func(sender,template,context):
print(sender) #发送者
print(template) #跳转到的模版名称
print(context) #跳转到模版时带过去的参数
template_rendered.connect(template_rendered_func)
@app.route('/')
def hello_world():
return render_template("index.html",data="momo")#去看发送信号的底层
if __name__ == '__main__':
app.run(debug=True)
got_request_exception的使用：
from flask import Flask,request,g,template_rendered,got_request_exception,render_template
app = Flask(__name__)
#内置信号
#got_request_exception：在请求过程中抛出异常时发送信号，异常本身会通过exception传递到订阅（监听）的函数中。
# 一般可以监听这个信号，来记录网站异常信息。
# def request_exception_log(sender,*args,**kwargs): #掌握写参数技巧
# print(sender)
# print(args)
# print(kwargs)
def request_exception_log(sender,exception):
print(sender)
print(exception) # division by zero
got_request_exception.connect(request_exception_log)
@app.route('/')
def hello_world():
#制造bug
a = 1/0
return render_template("index.html",data="momo")
if __name__ == '__main__':
app.run(debug=True)
WTForms介绍和基本使用：
WTForms介绍和基本使用：
1.WTForms介绍：
这个插件库主要有两个作用。
第一个是做表单验证，将用户提交上来的数据进行验证是否符合系统要求。
第二个是做模版渲染。 （了解即可）
官网：https://wtforms.readthedocs.io/en/latest/index.html
Flask-WTF是简化了WTForms操作的一个第三方库。WTForms表单的两个主要功能是验证用户提交数据的合法性以及渲染模板。而Flask-WTF还包括一些其他的功能：CSRF保护，文件上传等。
安装Flask-WTF默认也会安装WTForms，因此使用以下命令来安装Flask-WTF和WTForms:
pip install flask-wtf
2.WTForms做表单验证的基本使用：
1. 自定义一个表单类，继承自wtforms.Form类。
2. 定义好需要验证的字段，字段的名字必须和模版中那些需要验证的input标签的name属性值保持一致。
3. 在需要验证的字段上，需要指定好具体的数据类型。
4. 在相关的字段上，指定验证器。
5. 以后在视图函数中，只需要使用这个表单类的对象，并且把需要验证的数据，也就是request.form传给这个表单类，再调用表单类对象.validate()方法进行，如果返回True，那么代表用户输入的数据都是符合格式要求的，Flase则代表用户输入的数据是有问题的。如果验证失败了，那么可以通过表单类对象.errors来获取具体的错误信息。
如注册页面register.html：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>某系统注册页面</title>
</head>
<body>
<form action="/register/" method="post">
<table>
<tr>
<th>用户名：</th>
<td><input type="text" name="uname"></td>
</tr>
<tr>
<th>密码：</th>
<td><input type="password" name="pwd"></td>
</tr>
<tr>
<th>确认密码：</th>
<td><input type="password" name="pwd2"></td>
</tr>
<tr>
<td></td>
<td><input type="submit" value="注册"></td>
</tr>
</table>
</form>
</body>
</html>
如app.py文件：
from flask import Flask,request,render_template
from wtforms import Form,StringField
from wtforms.validators import Length,EqualTo
app = Flask(__name__)
class RegisterForm(Form):
uname =StringField(validators=[Length(min=2,max=15,message='用户名长度必须在2-15之间')])
pwd = StringField(validators=[Length(min=6,max=12)])
pwd2 = StringField(validators=[Length(min=6,max=12),EqualTo("pwd")])
@app.route('/')
def hello_world():
return render_template("register.html")
@app.route('/register/',methods=['GET','POST'])
def register():
if request.method == 'GET':
return render_template('register.html')
else:
form = RegisterForm(request.form)
if form.validate(): #验证 要么ok 要么no
return "验证通过"
else:
print(form.errors)
return "数据验证通不过"
if __name__ == '__main__':
app.run(debug=True)
WTForms常用验证器：
WTForms常用验证器：
页面把数据提交上来，需要经过表单验证，进而需要借助验证器来进行验证，以下是常用的内置验证器：
1. Length：字符串长度限制，有min和max两个值进行限制。
2. EqualTo：验证数据是否和另外一个字段相等，常用的就是密码和确认密码两个字段是否相等。
3. Email：验证上传的数据是否为邮箱数据格式 如：223333@qq.com。
4. InputRequired：验证该项数据为必填项，即要求该项非空。
5. NumberRange：数值的区间，有min和max两个值限制，如果处在这两个数字之间则满足。
6. Regexp：定义正则表达式进行验证，如验证手机号码。
7. URL：必须是URL的形式 如http://www.bjsxt.com。
8. UUID：验证数据是UUID类型。
注意：
数据项的类型，一般常用的有
from wtforms import Form,StringField,IntegerField,RadioField,BooleanField,SelectField,TextAreaField,DateField
class RegisterForm2(Form):
uname = StringField(validators=[InputRequired()])
age = IntegerField(validators=[NumberRange(18,40)])
代码演示：
register2.html文件
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>注册页面2</title>
</head>
<body>
<form action="/register2/" method="post">
<table>
<tr>
<th>邮箱：</th>
<td><input type="email" name="email"></td>
</tr>
<tr>
<th>用户名：</th>
<td><input type="text" name="uname"></td>
</tr>
<tr>
<th>年龄：</th>
<td><input type="number" name="age"></td>
</tr>
<tr>
<th>手机号码：</th>
<td><input type="text" name="phone"></td>
</tr>
<tr>
<th>个人主页：</th>
<td><input type="text" name="phomepage"></td>
</tr>
<tr>
<th>uuid：</th>
<td><input type="text" name="uuid"></td>
</tr>
<tr>
<th></th>
<td><input type="submit" value="注册"></td>
</tr>
</table>
</form>
</body>
</html>
formscheck.py表单验证工具类文件
from wtforms import Form,StringField,IntegerField
from wtforms.validators import Length,EqualTo,Email,InputRequired,NumberRange,Regexp,URL,UUID
class RegisterForm(Form):
uname =StringField(validators=[Length(min=2,max=15,message='用户名长度必须在2-15之间')])
pwd = StringField(validators=[Length(min=6,max=12)])
pwd2 = StringField(validators=[Length(min=6,max=12),EqualTo("pwd")])
class RegisterForm2(Form):
email = StringField(validators=[Email()])
uname = StringField(validators=[InputRequired()])
age = IntegerField(validators=[NumberRange(18,40)])
phone = StringField(validators=[Regexp(r'1[34578]\d{9}')])
phomepage = StringField(validators=[URL()])
uuid = StringField(validators=[UUID()])
app.py文件
from flask import Flask,request,render_template
from formscheck import RegisterForm,RegisterForm2
app = Flask(__name__)
@app.route('/')
def hello_world():
return render_template("register.html")
#基本使用
@app.route('/register/',methods=['GET','POST'])
def register():
if request.method == 'GET':
return render_template('register.html')
else:
form = RegisterForm(request.form)
if form.validate(): #验证 要么ok 要么no
return "验证通过"
else:
print(form.errors)
return "数据验证通不过"
#常用验证器使用
@app.route('/register2/',methods=['GET','POST'])
def login():
if request.method == 'GET':
return render_template("register2.html")
else:
form = RegisterForm2(request.form)
if form.validate():
return "验证OK"
else:
print(form.errors)
return "验证失败"
import uuid
print(uuid.uuid4())#edbfa1d6-28f2-4f40-9111-528141a8e77d
if __name__ == '__main__':
app.run(debug=True)
WTForms自定义验证器：
WTForms自定义验证器：
只有当WTForms内置的验证器不够使的时候，才需要使用自定义验证器。
如果想要对表单中的某个字段进行更细化的验证，那么可以针对这个字段进行单独的验证。
自定义验证器步骤如下：
1. 定义一个方法，方法的名字规则是：`validate_字段名(self,field)`。
2. 在方法中，使用`field.data`可以获取到这个字段的具体的值。
3. 验证时，如果数据满足条件，那么可以什么都不做。如果验证失败，
那么应该抛出一个`wtforms.validators.ValidationError`的异常，并且把验证失败的信息传到这个异常类中。
场景：验证码实现
关键代码演示：(实现验证码 验证)
from flask import session
from wtforms import Form,StringField,IntegerField
from wtforms.validators import Length,EqualTo,Email,InputRequired,NumberRange,Regexp,URL,UUID,ValidationError
class RegisterForm2(Form):
email = StringField(validators=[Email()])
uname = StringField(validators=[InputRequired()])
age = IntegerField(validators=[NumberRange(18,40)])
phone = StringField(validators=[Regexp(r'1[34578]\d{9}')])
phomepage = StringField(validators=[URL()])
uuid = StringField(validators=[UUID()])
code = StringField(validators=[Length(4,4)])
#取到的值 和服务器上 session上存储的值对比
def validate_code(self,field):
print(field.data,session.get('code'))
if field.data != session.get('code'):
raise ValidationError('验证码不一致！')
WTForms渲染模版：
WTForms渲染模版：
渲染模版是WTForms的第二个作用，不过，我们只需要了解即可，不需要花太多精力和时间去研究它。
除非那一天你能达到真正的全栈，才有可能考虑使用它。
看代码：
formscheck.py文件
from wtforms import Form,StringField,IntegerField,BooleanField,SelectField,DateField
from wtforms.validators import Length,EqualTo,Email,InputRequired,NumberRange,Regexp,URL,UUID,ValidationError
#渲染模版
class CreateForm(Form):
uname = StringField("用户名：",validators = [InputRequired()])
age = IntegerField("年龄：",validators = [NumberRange(18,40)])
remember = BooleanField("记住我：")
addr = SelectField('地址：',choices=[('bj',"北京"),('sj','上海'),('tj','天津')])
app.py文件
from flask import Flask,render_template
from formscheck import CreateForm
#WTForms渲染模版 了解
@app.route('/createform/')
def createform():
form = CreateForm()
return render_template('create_form.html',form=form)
if __name__ == '__main__':
app.run(debug=True)
create_form.html文件
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<style>
.hot{
background: red;
}
</style>
</head>
<body>
<h2>WTForms创建表单</h2>
<form action="#" method="post">
<table>
<tr>
<td>{{ form.uname.label }}</td>
<td>{{ form.uname(class='hot') }}</td>
</tr>
<tr>
<td>{{ form.age.label }}</td>
<td>{{ form.age() }}</td>
</tr>
<tr>
<td>{{ form.remember.label }}</td>
<td>{{ form.remember() }}</td>
</tr>
<tr>
<td>{{ form.addr.label }}</td>
<td>{{ form.addr() }}</td>
</tr>
<tr>
<td></td>
<td><input type="submit" value="提交"></td>
</tr>
</table>
</form>
</body>
</html>
代码结果：
若感兴趣，可看官网了解更多：
https://wtforms.readthedocs.io/en/latest/index.html
https://wtforms.readthedocs.io/en/latest/fields.html
https://wtforms.readthedocs.io/en/latest/fields.html#field-definitions
Flask_上传文件_访问文件：
Flask_上传文件_访问文件：
1.上传文件步骤：
1. 在模版html中，表单需要指定`encotype='multipart/form-data'`才能上传文件。
2. 在后台如果想要获取上传的文件，那么应该使用`request.files.get('文件名')`来获取。
3. 保存文件之前，先要使用`werkzeug.utils.secure_filename`来对上传上来的文件名进行一个过滤。能保证不会有安全问题。
4. 获取到上传上来的文件后，使用`文件对象.save(路径)`方法来保存文件。路径=完整路径=路径名+文件名
upload.html页面
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>上传文件</title>
</head>
<body>
<form action="" method="post" enctype="multipart/form-data">
<table>
<tr>
<td>头像：</td>
<td><input type="file" name="pichead"></td>
</tr>
<tr>
<td>描述：</td>
<td><input type="text" name="desc"></td>
</tr>
<tr>
<td></td>
<td><input type="submit" value="提交"></td>
</tr>
</table>
</form>
</body>
</html>
app.py文件
from flask import Flask,request,render_template
import os
from werkzeug.utils import secure_filename
app = Flask(__name__)
UPLOAD_PATH = os.path.join(os.path.dirname(__file__),'images')
@app.route('/upload/',methods=['GET','POST'])
def upload():
if request.method == 'GET':
return render_template('upload.html')
else:
desc = request.form.get("desc")
pichead = request.files.get("pichead")
filename = secure_filename(pichead.filename) #包装一下 保证文件安全
# pichead.save(os.path.join(UPLOAD_PATH,pichead.filename)) #可优化
pichead.save(os.path.join(UPLOAD_PATH,filename)) #已优化
print(desc)
return '文件上传成功'
if __name__ == '__main__':
app.run(debug=True)
2.访问文件
从服务器上读取文件，应该定义一个url与视图函数，来获取指定的文件。
在这个视图函数中，使用`send_from_directory(文件的目录,文件名)`来获取。
from flask import Flask
import os
from flask import send_from_directory
app = Flask(__name__)
UPLOAD_PATH = os.path.join(os.path.dirname(__file__),'images')
@app.route('/images/<filename>/')
def get_image(filename):
return send_from_directory(UPLOAD_PATH,filename)
if __name__ == '__main__':
app.run(debug=True)
利用flask-wtf验证上传的文件：
利用flask-wtf验证上传的文件：
关键点：
1. 定义验证表单类的时候，对文件类型的字段，需要采用`FileField`这个类型，即wtforms.FileField。
2. 验证器需要从`flask_wtf.file`中导入。`flask_wtf.file.FileRequired`和`flask_wtf.file.FileAllowed`
3.`flask_wtf.file.FileRequired`是用来验证文件上传不能为空。
4.`flask_wtf.file.FileAllowed`用来验证上传的文件的后缀名， 如常见图片后缀 .jpg 和.png以及.gif等。
5. 在视图函数中，需要使用`from werkzeug.datastructures import CombinedMultiDict`来把`request.form`与`request.files`来进行合并。
6.最后使用 表单验证对象.validate()进行验证。
代码如下：
upload.html页面
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>上传文件</title>
</head>
<body>
<form action="" method="post" enctype="multipart/form-data">
<table>
<tr>
<td>头像：</td>
<td><input type="file" name="pichead"></td>
</tr>
<tr>
<td>描述：</td>
<td><input type="text" name="desc"></td>
</tr>
<tr>
<td></td>
<td><input type="submit" value="提交"></td>
</tr>
</table>
</form>
</body>
</html>
formscheck.py文件
from wtforms import Form,FileField,StringField
from wtforms.validators import InputRequired
# flask_wtf
from flask_wtf.file import FileRequired,FileAllowed
class UploadForm(Form):
pichead = FileField(validators=[FileRequired(),FileAllowed(['jpg','png','gif'])])
desc = StringField(validators=[InputRequired()])
app.py文件
from flask import Flask,request,render_template
import os
from werkzeug.utils import secure_filename
from formscheck import UploadForm
from werkzeug.datastructures import CombinedMultiDict
app = Flask(__name__)
UPLOAD_PATH = os.path.join(os.path.dirname(__file__),'images')
#利用flask-wtf验证上传的文件
@app.route('/upload/',methods=['GET','POST'])
def upload():
if request.method == 'GET':
return render_template('upload.html')
else:
form = UploadForm(CombinedMultiDict([request.form,request.files]))
if form.validate():
# desc = request.form.get("desc")
# pichead = request.files.get("pichead")
desc = form.desc.data
pichead = form.pichead.data
filename = secure_filename(pichead.filename)
pichead.save(os.path.join(UPLOAD_PATH,filename))
print(desc)
return '文件上传成功'
else:
print(form.errors)
return "文件上传失败"
if __name__ == '__main__':
app.run(debug=True)
1.Restful接口规范介绍
1.Restful接口规范介绍
REST：Representational State Transfer，
REST 指的是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是 RESTful。
是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。
它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁，更有层次。
restful接口规范是用于在前端与后台进行通信的一套规范。使用这个规范可以让前后端开发变得更加轻松。
2.适用场景：一个系统的数据库数据，展现的平台有PC端、移动端、app端、ios端。
前端工程师：都遵循RESTful编程规范
后端工程师：都遵循RESTful编程规范
最终结果：开发效率高，便于管理
3.协议：用http或者https协议。
4.数据传输格式：
数据传输的格式应该都用json格式。
5.url链接规则：
url链接中，不能有动词，只能有名词。
并且对于一些名词，如果出现复数，那么应该在后面加s。
比如：获取新闻列表，应该使用`/news/`，而不应该使用/get_news/
6.HTTP请求方式：
GET：从服务器上获取资源。
POST：在服务器上新增或者修改一个资源。
PUT：在服务器上更新资源。（客户端提供所有改变后的数据）
PATCH：在服务器上更新资源。（客户端只提供需要改变的属性）
DELETE：从服务器上删除资源。
7.状态码：
状态码 原因描述 描述
200 OK 服务器成功响应客户端的请求。
400 INVALID REQUEST 用户发出的请求有错误，服务器没有进行新建或修改数据的操作
401 Unauthorized 用户没有权限访问这个请求
403 Forbidden 因为某些原因禁止访问这个请求
404 NOT FOUND 用户请求的url不存在
406 NOT Acceptable 用户请求不被服务器接收（比如服务器期望客户端发送某个字段，但是没有发送）。
500 Internal server error 服务器内部错误，比如遇到bug
Flask_RESTful的基本使用
1.介绍：
优势：
Flask-Restful是一个专门用来写restful api的一个插件。
使用它可以快速的集成restful api接口功能。
在系统的纯api的后台中，这个插件可以帮助我们节省很多时间。
缺点：
如果在普通的网站中，这个插件就没有优势了，因为在普通的网站开发中，是需要去渲染HTML代码的，
而Flask-Restful在每个请求中都是返回json格式的数据。
2.安装：
pip install flask-restful
3.基本使用：
定义Restful的类视图：
1. 从`flask_restful`中导入`Api`，来创建一个`api`对象。
2. 写一个类视图，让他继承自`Resource`类，然后在这个里面，
使用你想要的请求方式来定义相应的方法，比如你想要将这个类视图只能采用`post`请求，那么就定义一个`post`方法。
3. 使用`api.add_resource`来添加类视图与`url`。
from flask import Flask,url_for,render_template
from flask_restful import Api,Resource
app = Flask(__name__)
api = Api(app)
class LoginView(Resource):
def post(self):
return {"flag":"yes"}
def get(self):
return {"flag":"no"}
# api.add_resource(LoginView,'/login/')
api.add_resource(LoginView,'/login/','/login2/',endpoint="login")
with app.test_request_context():
# print(url_for('loginview'))
print(url_for('login'))
@app.route('/')
def hello_world():
return render_template('index.html')
if __name__ == '__main__':
app.run(debug=True)
4.注意：
如果你想返回json数据，那么就使用flask_restful，如果你是想渲染模版，那么还是采用之前的方式，就是`app.route`的方式。
url还是跟之前的一样，可以传递参数。也跟之前的不一样，可以指定多个url。
endpoint是用来给url_for反转url的时候指定的。如果不写endpoint，那么将会使用视图的名字的小写来作为endpoint。
Flask_RESTful功能之参数验证
Flask_RESTful功能之参数验证：
1.参数验证：也叫参数解析
Flask-Restful插件提供了类似WTForms来验证提交的数据是否合法的包，叫做reqparse。
2.基本用法：(借助于测试工程师 常用的接口测试工具postman来检验)
from flask import Flask,url_for,render_template
from flask_restful import Api,Resource,reqparse,inputs
app = Flask(__name__)
api = Api(app)
class RegisterView(Resource):
def post(self):
#验证用户名
#1.创建解析器对象
parser = reqparse.RequestParser()
#2.利用解析器对象添加 需要验证的参数
parser.add_argument('uname',type=str,help='用户名验证错误！',required=True,trim=True)
#3.利用解析器对象进行验证，若正确，直接返回验证后合格的参数值，若错误，抛异常信息给客户端
args = parser.parse_args()
print(args)
return {"tips":"注册成功"}
api.add_resource(RegisterView,'/register/')
@app.route('/')
def hello_world():
return render_template('index.html')
if __name__ == '__main__':
app.run(debug=True)
3.其中add_argument方法使用详解
add_argument方法可以指定这个字段的名字，这个字段的数据类型等，验证错误提示信息等，具体如下：
default：默认值，如果这个参数没有值，那么将使用这个参数指定的默认值。
required：是否必须。默认为False，如果设置为True，那么这个参数就必须提交上来。
type：这个参数的数据类型，如果指定，那么将使用指定的数据类型来强制转换提交上来的值。
choices：固定选项。提交上来的值只有满足这个选项中的值才符合验证通过，否则验证不通过。
help：错误信息。如果验证失败后，将会使用这个参数指定的值作为错误信息。
trim：是否要去掉前后的空格。
其中的type，
可以使用python自带的一些数据类型(如str或者int)，
也可以使用flask_restful.inputs下的一些特定的数据类型来强制转换。
比如一些常用的：
url：会判断这个参数的值是否是一个url，如果不是，那么就会抛出异常。
regex：正则表达式。
date：将这个字符串转换为datetime.date数据类型。如果转换不成功，则会抛出一个异常。
4.代码案例：
from flask import Flask,url_for,render_template
from flask_restful import Api,Resource,reqparse,inputs
app = Flask(__name__)
api = Api(app)
#Flask_RESTful功能之参数验证
class RegisterView(Resource):
def post(self):
#用户名 密码 年龄 性别 出生日期 号码 个人主页
# 1.创建解析器对象
parser = reqparse.RequestParser()
#2.利用解析器对象添加 需要验证的参数
parser.add_argument('uname',type=str,help='用户名验证错误！',required=True,trim=True)
parser.add_argument('pwd', type=str, help='密码验证错误！',default="123456")
parser.add_argument('age',type=int,help='年龄验证错误！')
parser.add_argument('gender',type=str,choices=['男','女','双性'])
parser.add_argument('birthday',type=inputs.date,help='生日字段验证错误！')
parser.add_argument('phone',type=inputs.regex(r'1[3578]\d{9}'))
parser.add_argument('phomepage',type=inputs.url,help='个人中心链接验证错误！')
#3.利用解析器对象进行验证，若正确，直接返回验证后合格的参数值，若错误，抛异常信息给客户端
args = parser.parse_args()
print(args)
return {"tips":"注册成功"}
api.add_resource(RegisterView,'/register/')
@app.route('/')
def hello_world():
return render_template('index.html')
if __name__ == '__main__':
app.run(debug=True)
Flask_RESTful返回标准化参数：
Flask_RESTful返回标准化参数：
对于一个类视图，你可以指定好一些字段作标准化用于返回。
以后使用ORM模型或者自定义模型的时候，他会自动的获取模型中的相应的字段，
生成json格式数据，然后再返回给客户端。
这需要导入flask_restful.marshal_with装饰器。
还需要写一个字典变量，来指定需要返回的标准化字段，以及该字段的数据类型。
在get方法中，返回自定义对象的时候，flask_restful会自动的读取对象模型上的所有属性。
组装成一个符合标准化参数的json格式字符串返回给客户端。
代码演示：
from flask import Flask
from flask_restful import Api,Resource,fields,marshal_with
app = Flask(__name__)
api = Api(app)
#flask_restful返回标准化参数
class News(object):
def __init__(self,title,content):
self.title =title
self.content =content
news = News('能力强的体现','能屈能伸')
class NewsView(Resource):
resource_fields ={
'title': fields.String,
'content':fields.String
}
@marshal_with(resource_fields)
def get(self):
# restful规范中，要求，定义好了返回的参数个数 和 内容
# return {'title':"世界太大",'content':"可钱包太小"}
#好处1：体现规范化，即使content这个参数没有值，也应该返回，返回一个null回去
# return {'title':"世界太大"}
#好处2：体现规范化，还可以返回一个对象模型回去
return news
api.add_resource(NewsView,'/news/')
if __name__ == '__main__':
app.run(debug=True)
Flask_RESTful返回标准化参数强化
Flask_RESTful返回标准化参数强化：
1.重命名属性和默认值：
需求1：
有的时候你对外给出的属性名和模型内部的属性名不相同时，
可使用 attribute可以配置这种映射。
比如想要返回模型对象user.username的值，但是在返回给外面的时候，想以uname返回去。
需求2：
在返回某些字段的时候，有时候可能没有值，但想给一个值用以提示，
那么这时候可以在指定fields的时候使用default指定默认值
from flask import Flask,url_for,render_template
from flask_restful import Api,Resource,reqparse,inputs,fields,marshal_with
app = Flask(__name__)
api = Api(app)
#flask_restful返回标准化参数强化
class User():
def __init__(self,username,age):
self.username=username
self.age=age
self.signature=None
class UserView(Resource):
resource_fields={
#1.重命名属性
'uname':fields.String(attribute='username'),
'age':fields.Integer,
#2.默认值
'signature':fields.String(default='此人很懒，什么也没写')
}
@marshal_with(resource_fields)
def get(self):
user = User('莫莫',18)
return user
api.add_resource(UserView,'/user/')
if __name__ == '__main__':
app.run(debug=True)
2.复杂的参数结构：
大型的互联网项目中，返回的数据格式，是比较复杂的结构。
如：小米商城，
https://www.mi.com/
https://a.huodong.mi.com/flashsale/getslideshow
总结，无非就是key对应的value又是一个json，或者key对应的是一个列表，列表中的每项都是json
那么可以使用一些特殊的字段来实现。
如在一个字段中放置一个列表，那么可以使用fields.List，
如在一个字段下面又是一个字典，那么可以使用fields.Nested。
from flask import Flask,url_for,render_template
from flask_restful import Api,Resource,reqparse,inputs,fields,marshal_with
app = Flask(__name__)
api = Api(app)
#flask_restful返回标准化参数强化
#复杂的参数结构
#实体间关系有 1：1 1:n n:n(转为2个1:n)
#新闻系统后台 用户 新闻 新闻标签
class User():
def __init__(self,id,uname,age):
self.id = id
self.uname = uname
self.age = age
def __repr__(self):
return "<User:{id},{uname},{age}>".format(id=self.id, uname=self.uname,age=self.age)
class News():
def __init__(self,id,title,content):
self.id=id
self.title=title
self.content=content
#关系映射
self.author=None
self.tags=[]
def __repr__(self):
return "<News:{id},{title},{content},{author},{tags}>"\
.format(id=self.id, title=self.title,content=self.content,author=self.author,tags=self.tags)
class NewsTag():
def __init__(self,id,name):
self.id=id
self.name=name
def __repr__(self):
return '<NewsTage:{id},{name}>'.format(id =self.id , name=self.name)
def createData():
user = User(110,'莫莫',30)
tag1 = NewsTag(200,"要闻")
tag2 = NewsTag(210,"娱乐")
news =News(300,'吴京征服了世界上海拔最高的派出所','4月23日中午11点，吴京发了一条微博，配文“世界上海拔最高的派出所”，并@了另外一名演员张译。微博中有两张图片，第一张是吴京和张译两人坐在地上的合照，背后几个大字“中国边防”。第二张则是两人与派出所民警们的合照。 ')
news.author = user #绑定新闻作者
news.tags.append(tag1) #绑定新闻标签1
news.tags.append(tag2) #绑定新闻标签2
print(news)
return news
class NewsView2(Resource):
resource_fields={
'id':fields.Integer,
'title': fields.String,
'content': fields.String,
#如在一个字段下面又是一个字典，那么可以使用fields.Nested({...})
'author': fields.Nested({
'id': fields.Integer,
'uname': fields.String,
'age':fields.Integer
}),
#如要在一个字段中放置一个列表，那么可以使用fields.List(fields.Nested({...}))
'tags': fields.List(fields.Nested({
'id': fields.Integer,
'name': fields.String
}))
}
@marshal_with(resource_fields)
def get(self):
news = createData()
return news
api.add_resource(NewsView2,'/news2/')
if __name__ == '__main__':
app.run(debug=True)
Flask_RESTful结合蓝图使用和渲染模版
Flask_RESTful结合蓝图使用和渲染模版：
1.Flask_RESTful结合蓝图使用
在蓝图中，如果使用Flask_RESTful，
那么在创建Api对象的时候，使用蓝图对象，不再是使用`app`对象了
蓝图news.py文件
from flask import url_for,render_template,Blueprint,make_response,Response
from flask_restful import Api,Resource,reqparse,inputs,fields,marshal_with
import json
news_bp = Blueprint('news',__name__,url_prefix='/news')
api = Api(news_bp)
#1.flask-restful结合蓝图使用
#复杂的参数结构
#实体间关系有 1：1 1:n n:n(转为2个1:n)
#新闻系统后台 用户 新闻 新闻标签
class User():
def __init__(self,id,uname,age):
self.id = id
self.uname = uname
self.age = age
def __repr__(self):
return "<User:{id},{uname},{age}>".format(id=self.id, uname=self.uname,age=self.age)
class News():
def __init__(self,id,title,content):
self.id=id
self.title=title
self.content=content
#关系映射
self.author=None
self.tags=[]
def __repr__(self):
return "<News:{id},{title},{content},{author},{tags}>"\
.format(id=self.id, title=self.title,content=self.content,author=self.author,tags=self.tags)
class NewsTag():
def __init__(self,id,name):
self.id=id
self.name=name
def __repr__(self):
return '<NewsTage:{id},{name}>'.format(id =self.id , name=self.name)
def createData():
user = User(110,'莫莫',30)
tag1 = NewsTag(200,"要闻")
tag2 = NewsTag(210,"娱乐")
news =News(300,'吴京征服了世界上海拔最高的派出所','4月23日中午11点，吴京发了一条微博，配文“世界上海拔最高的派出所”，并@了另外一名演员张译。微博中有两张图片，第一张是吴京和张译两人坐在地上的合照，背后几个大字“中国边防”。第二张则是两人与派出所民警们的合照。 ')
news.author = user #绑定新闻作者
news.tags.append(tag1) #绑定新闻标签1
news.tags.append(tag2) #绑定新闻标签2
print(news)
return news
class NewsView2(Resource):
resource_fields={
'id':fields.Integer,
'title': fields.String,
'content': fields.String,
#如在一个字段下面又是一个字典，那么可以使用fields.Nested({...})
'author': fields.Nested({
'id': fields.Integer,
'uname': fields.String,
'age':fields.Integer
}),
#如要在一个字段中放置一个列表，那么可以使用fields.List(fields.Nested({...}))
'tags': fields.List(fields.Nested({
'id': fields.Integer,
'name': fields.String
}))
}
@marshal_with(resource_fields)
def get(self):
news = createData()
return news
api.add_resource(NewsView2,'/news2/')
app.py文件
from flask import Flask,url_for,render_template
from blueprints.news import news_bp
app = Flask(__name__)
app.register_blueprint(news_bp)
@app.route('/')
def hello_world():
return render_template('index.html')
if __name__ == '__main__':
app.run(debug=True)
2.Flask_RESTful渲染模版
如果在Flask_RESTful的类视图中想要返回html片段代码，或者是整个html文件代码，即渲染模版的意思。
那么就应该使用`api.representation`这个装饰器来定义一个函数，
在这个函数中，应该对`html`代码进行一个封装，再返回。
from flask import url_for,render_template,Blueprint,make_response,Response
from flask_restful import Api,Resource,reqparse,inputs,fields,marshal_with
import json
news_bp = Blueprint('news',__name__,url_prefix='/news')
api = Api(news_bp)
#2. 使用flask-restful渲染模版
class ListView(Resource):
def get(self):
return render_template('index.html')
api.add_resource(ListView,'/list/')
# 渲染模版经过修改后，能支持html和json
@api.representation('text/html')
def output_html(data,code,headers):
if isinstance(data,str):
# 在representation装饰的函数中，必须返回一个Response对象
# resp = make_response(data)
resp =Response(data)
return resp
else:
return Response(json.dumps(data),mimetype='application/json')
Flask数据库
安装MySQL以及注意事项
安装MySQL以及注意事项
在Windows下安装MySQL：
1.在MySQL的官网下载MySQL数据库
https://dev.mysql.com/downloads/windows/installer/5.7.html。
2.然后双击安装，如果出现以下错误，
则到https://www.microsoft.com/en-us/download/confirmation.aspx?id=17113下载.net framework。然后安装。之后继续安装mysql。
3.在安装过程中，如果提示没有Microsoft C++ 2013，那么就到以下网址下载安装即可：http://download.microsoft.com/download/9/0/5/905DBD86-D1B8-4D4B-8A50-CB0E922017B9/vcredist_x64.exe
4.然后做好用户名与密码的配置即可。
SQLAlchemy连接数据库
SQLAlchemy连接数据库
1.SQLAlchemy介绍和基本使用
数据库是一个网站的基础。Flask可以使用很多种数据库。比如MySQL，MongoDB,SQLite,PostgreSQL等。这里我们以MySQL为例进行讲解。而在Flask中，如果想要操作数据库，我们可以使用ORM来操作数据库，使用ORM操作数据库将变得非常简单。我们会以 mysql + SQLAlchemy 组合进行讲解。
在讲解Flask中的数据库操作之前，先确保你已经安装了以下软件：
mysql：如果是在windows上，到官网下载。如果是ubuntu，通过命令sudo apt-get install mysql-server libmysqlclient-dev -yq进行下载安装。
MySQLdb：MySQLdb是用Python来操作mysql的包，因此通过pip来安装，命令如下：pip install mysql-python。如果您用的是Python 2.x，请安装MySQLdb。
pymysql：pymysql是用Python来操作mysql的包，因此通过pip来安装，命令如下：pip3 install pymysql。如果您用的是Python 3，请安装pymysql。
SQLAlchemy：SQLAlchemy是一个数据库的ORM框架，我们在后面会用到。安装命令为：pip3 install SQLAlchemy。
2.通过SQLAlchemy连接数据库
首先来看一段代码：
from sqlalchemy import create_engine
# 数据库的配置变量
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'xt_flask'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI = 'mysql+mysqldb://{}:{}@{}:{}/{}'.format(USERNAME,PASSWORD,HOSTNAME,PORT,DATABASE)
# 创建数据库引擎
engine = create_engine(DB_URI)
#创建连接
with engine.connect() as con:
rs = con.execute('SELECT 1')
print rs.fetchone()
首先从sqlalchemy中导入create_engine，用这个函数来创建引擎，然后用engine.connect()来连接数据库。其中一个比较重要的一点是，通过create_engine函数的时候，需要传递一个满足某种格式的字符串，对这个字符串的格式来进行解释：
dialect+driver://username:password@host:port/database?charset=utf8
dialect是数据库的实现，比如MySQL、PostgreSQL、SQLite，并且转换成小写。driver是Python对应的驱动，如果不指定，会选择默认的驱动，比如MySQL的默认驱动是MySQLdb。username是连接数据库的用户名，password是连接数据库的密码，host是连接数据库的域名，port是数据库监听的端口号，database是连接哪个数据库的名字。如果以上输出了1，说明SQLAlchemy能成功连接到数据库。
3.用SQLAlchemy执行原生SQL（扩展）：
我们将上一个例子中的数据库配置选项单独放在一个constants.py的文件中，看以下例子：
from sqlalchemy import create_engine
from constants import DB_URI
#连接数据库
engine = create_engine(DB_URI,echo=True)
# 使用with语句连接数据库，如果发生异常会被捕获
with engine.connect() as con:
# 先删除users表
con.execute('drop table if exists authors')
# 创建一个users表，有自增长的id和name
con.execute('create table authors(id int primary key auto_increment,'name varchar(25))')
# 插入两条数据到表中
con.execute('insert into persons(name) values("abc")')
con.execute('insert into persons(name) values("xiaotuo")')
# 执行查询操作
results = con.execute('select * from persons')
# 从查找的结果中遍历
for result in results:
print(result)
4.必须掌握：
from sqlalchemy import create_engine
#准备连接数据库基本信息
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
#dialect+driver://username:password@host:port/database?charset=utf8
#按照上述的格式来 组织数据库信息
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
#创建数据库引擎
engine = create_engine(DB_URI)
#创建连接
conn = engine.connect()
# 判断是否连接成功
result =conn.execute('select 1')
print(result)
print(result.fetchone())
ORM介绍
ORM介绍
1. ORM：Object Relationship Mapping
2. 大白话：对象模型与数据库表的映射
python代码 和SQL代码角度理解：
class Person(object):
name = 'xx'
age = 18
country ='xx'
# Person类 -> 数据库中的一张表
# Person类中的属性 -> 数据库中一张表字段
# Person类的一个对象 -> 数据库中表的一条数据
# p = Person('xx',xx)
# p.save()
#create table person(name varchar(200),age int,country varchar(100))
SQLAlchemy
随着项目的越来越大，采用写原生SQL的方式在代码中会出现大量重复的SQL语句，那么，问题，就出现了：
1.SQL语句重复利用率不高，越复杂的SQL语句条件越多，代码越长，会出现很多相近的SQL语句。
2.很多SQL语句 是在业务逻辑中拼接出来的，如果数据库需要更改，就要去修改这些逻辑，这会很容易漏掉对某些SQL语句的修改。
3.写SQL时容易忽略web安全问题，造成隐患。
ORM，全称Object Relational Mapping,中文名叫做对象关系映射，通过ORM我们可以通过类的方式去操作数据库而不用再写原生的SQL语句，通过把表映射成类，把行作为实例，把字段作为属性，ORM在执行对象操作的时候最终还是会把对象的操作转换为数据库的原生语句，但使用ORM有许多优点：
1.易用性：使用ORM做数据库开发可以有效减少重复SQL语句的概率，写出来的模型也更加直观、清晰
2.性能损耗小：ORM转换成底层数据库操作指令确实会有一些开销。但是从实际情况来看，这种性能损耗很少（不足5%），只要不是针对性能有严苛的要求，综合考虑开发效率、代码阅读性，带来的好处远大于性能损耗，而且项目越大作用越明显。
3.设计灵活：可以轻松的写出复杂的查询。
4.可移植性：SQLAlchemy封装了底层的数据库实现，支持多个关系数据库引擎，包括流行的Mysql、PostgreSQL和SQLite，可以非常轻松的切换数据库。
定义ORM模型并将其映射到数据库中
定义ORM模型并将其映射到数据库中
1. 用`declarative_base`根据`engine`创建一个ORM基类。
from sqlalchemy.ext.declarative import declarative_base
engine = create_engine(DB_URI)
Base = declarative_base(engine)
2. 用这个`Base`类作为基类来写自己的ORM类。要定义`__tablename__`类属性，来指定这个模型映射到数据库中的表名。
class Person(Base):
__tablename__ ='person'
3. 创建属性来映射到表中的字段，所有需要映射到表中的属性都应该为Column类型：
class Person(Base):
__tablename__ ='person'
#2.在这个ORM模型中创建一些属性，来跟表中的字段进行 一一 映射。这些属性必须是sqlalchemy给我们提供好的数据类型
id = Column(Integer,primary_key=True,autoincrement=True)
name = Column(String(50))
age = Column(Integer)
country = Column(String(50))
4. 使用`Base.metadata.create_all()`来将模型映射到数据库中。
Base.metadata.create_all()
5. 一旦使用`Base.metadata.create_all()`将模型映射到数据库中后，即使改变了模型的字段，也不会重新映射了。
SQLAlchemy对数据的增删改查操作
SQLAlchemy对数据的增删改查操作
用session做数据的增删改查操作：
1. 构建session对象：所有和数据库的ORM操作都必须通过一个叫做`session`的会话对象来实现，通过以下代码来获取会话对象：
from sqlalchemy.orm import sessionmaker
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
2. 添加对象：
* 创建对象，也即创建一条数据：
p1 = Person(name='momo1',age=19,country='china')
* 将这个对象添加到`session`会话对象中：
session.add(p1)
* 将session中的对象做commit操作（提交）：
session.commit()
* 一次性添加多条数据：
p1 = Person(name='momo1',age=19,country='china')
p2 = Person(name='momo2',age=20,country='china')
session.add_all([p1,p2])
session.commit()
3. 查找对象：
# 查找某个模型对应的那个表中所有的数据：
all_person = session.query(Person).all()
# 使用filter_by来做条件查询
all_person = session.query(Person).filter_by(name='momo1').all()
# 使用filter来做条件查询
all_person = session.query(Person).filter(Person.name=='momo1').all()
# 使用get方法查找数据，get方法是根据id来查找的，只会返回一条数据或者None
person = session.query(Person).get(primary_key)
# 使用first方法获取结果集中的第一条数据
person = session.query(Person).first()
4. 修改对象：首先从数据库中查找对象，然后将这条数据修改为你想要的数据，最后做commit操作就可以修改数据了。
person = session.query(Person).first()
person.name = 'lulu'
session.commit()
5. 删除对象：将需要删除的数据从数据库中查找出来，然后使用`session.delete`方法将这条数据从session中删除，最后做commit操作就可以了。
person = session.query(Person).first()
session.delete(person)
session.commit()
SQLAlchemy常用数据类型：
SQLAlchemy常用数据类型：
1. Integer：整形，映射到数据库中是int类型。
2. Float：浮点类型，映射到数据库中是float类型。他占据的32位。
3. Double：双精度浮点类型，映射到数据库中是double类型，占据64位 (SQLALCHEMY中没有)。
4. String：可变字符类型，映射到数据库中是varchar类型.
5. Boolean：布尔类型，映射到数据库中的是tinyint类型。
6. DECIMAL：定点类型。是专门为了解决浮点类型精度丢失的问题的。在存储钱相关的字段的时候建议大家都使用这个数据类型。并且这个类型使用的时候需要传递两个参数，第一个参数是用来标记这个字段总能能存储多少个数字，第二个参数表示小数点后有多少位。
7. Enum：枚举类型。指定某个字段只能是枚举中指定的几个值，不能为其他值。在ORM模型中，使用Enum来作为枚举，示例代码如下：
class News(Base):
__tablename__ = 'news'
tag = Column(Enum("python",'flask','django'))
在Python3中，已经内置了enum这个枚举的模块，我们也可以使用这个模块去定义相关的字段。示例代码如下：
class TagEnum(enum.Enum):
python = "python"
flask = "flask"
django = "django"
class News(Base):
__tablename__ = 'news'
id = Column(Integer,primary_key=True,autoincrement=True)
tag = Column(Enum(TagEnum))
news = News(tag=TagEnum.flask)
8. Date：存储时间，只能存储年月日。映射到数据库中是date类型。在Python代码中，可以使用`datetime.date`来指定。
9. DateTime：存储时间，可以存储年月日时分秒毫秒等。映射到数据库中也是datetime类型。在Python代码中，可以使用`datetime.datetime`来指定。
10. Time：存储时间，可以存储时分秒。映射到数据库中也是time类型。在Python代码中，可以使用`datetime.time`来至此那个。示例代码如下：
class News(Base):
__tablename__ = 'news'
create_time = Column(Time)
news = News(create_time=time(hour=11,minute=11,second=11))
11. Text：存储长字符串。一般可以存储6W多个字符。如果超出了这个范围，可以使用LONGTEXT类型。映射到数据库中就是text类型。
12. LONGTEXT：长文本类型，映射到数据库中是longtext类型。
演示整体代码如下：
from sqlalchemy import create_engine,Column,Integer,String,Float,Enum,Boolean,DECIMAL,Text,Date,DateTime,Time
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.orm import sessionmaker
import enum
from datetime import date
from datetime import datetime
from datetime import time
#准备数据库的一堆信息 ip port user pwd 数据库的名称 按要求组织格式
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
#dialect+driver://username:password@host:port/database?charset=utf8
#按照上述的格式来 组织数据库信息
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".\
format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
#创建数据库引擎
engine = create_engine(DB_URI)
#创建会话对象
session = sessionmaker(engine)()
#定义一个枚举类
class TagEnum(enum.Enum):
python="PYHTON2"
flask="FLASK2"
django ="DJANGO"
#创建一个ORM模型 说明基于sqlalchemy 映射到mysql数据库的常用字段类型有哪些？
Base = declarative_base(engine)
class News(Base):
__tablename__='news'
id = Column(Integer,primary_key=True,autoincrement=True)
price1 = Column(Float) #存储数据时存在精度丢失问题
price2 = Column(DECIMAL(10,4))
title = Column(String(50))
is_delete =Column(Boolean)
tag1 =Column(Enum('PYTHON','FLASK','DJANGO')) #枚举常规写法
tag2 =Column(Enum(TagEnum)) #枚举另一种写法
create_time1=Column(Date)
create_time2=Column(DateTime)
create_time3=Column(Time)
content1 =Column(Text)
content2 =Column(LONGTEXT)
# Base.metadata.drop_all()
# Base.metadata.create_all()
#新增数据到表news中
# a1 = News(price1=1000.0078,price2=1000.0078,title='测试数据',is_delete=True,tag1="PYTHON",tag2=TagEnum.flask,
# create_time1=date(2018,12,12),create_time2=datetime(2019,2,20,12,12,30),create_time3=time(hour=11,minute=12,second=13),
# content1="hello",content2 ="hello hi nihao")
a1 = News(price1=1000.0078,price2=1000.0078,title='测试数据',is_delete=False,tag1="PYTHON",tag2=TagEnum.python,
create_time1=date(2018,12,12),create_time2=datetime(2019,2,20,12,12,30),create_time3=time(hour=11,minute=12,second=13),
content1="hello",content2 ="hello hi nihao")
session.add(a1)
session.commit()
Column常用参数：
Column常用参数：
1. primary_key：True设置某个字段为主键。
2. autoincrement：True设置这个字段为自动增长的。
3. default：设置某个字段的默认值。在发表时间这些字段上面经常用。
4. nullable：指定某个字段是否为空。默认值是True，就是可以为空。
5. unique：指定某个字段的值是否唯一。默认是False。
6. onupdate：在数据更新的时候会调用这个参数指定的值或者函数。在第一次插入这条数据的时候，不会用onupdate的值，只会使用default的值。常用于是`update_time`字段（每次更新数据的时候都要更新该字段值）。
7. name：指定ORM模型中某个属性映射到表中的字段名。如果不指定，那么会使用这个属性的名字来作为字段名。如果指定了，就会使用指定的这个值作为表字段名。这个参数也可以当作位置参数，在第1个参数来指定。
title = Column(String(50),name='title',nullable=False)
title = Column('my_title',String(50),nullable=False)
代码演示如下:
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,Date,DateTime,Time,String,Text
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from datetime import date
from datetime import datetime
from datetime import time
#在Python3中才有enum这个模块，在python2中没有
import enum
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
class News(Base):
__tablename__ = 'news'
id = Column(Integer,primary_key=True,autoincrement=True)
create_time = Column(DateTime,default=datetime.now)
read_count = Column(Integer,default=11)
title = Column(String(50),name='my_title',nullable=False)
telephone = Column(String(11),unique=True)
update_time = Column(DateTime,onupdate=datetime.now,default=datetime.now)
Base.metadata.drop_all()
Base.metadata.create_all()
news= News()
session.add(news)
session.commit()
#下面是测试onupdate参数的
# news= session.query(News).first()
# news.title = '123'
# session.commit()
query函数可传递的参数一共有3种：
query函数可传递的参数一共有3种：
1. 模型名。指定查找这个模型中所有的属性（对应查询表为全表查询）。
2. 模型中的属性。可以指定只查找某个模型的其中几个属性。
3. 聚合函数。
* func.count：统计行的数量。
* func.avg：求平均值。
* func.max：求最大值。
* func.min：求最小值。
* func.sum：求和。
`func`上，其实没有任何聚合函数。但是因为他底层做了一些魔术，只要mysql中有的聚合函数，都可以通过func调用。
代码演示如下：
from sqlalchemy import create_engine,Column,Integer,String,Float,Enum,Boolean,DECIMAL,Text,\
Date,DateTime,Time,func
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.orm import sessionmaker
import random
import enum
from datetime import date
from datetime import datetime
from datetime import time
#准备数据库的一堆信息 ip port user pwd 数据库的名称 按要求组织格式
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
#dialect+driver://username:password@host:port/database?charset=utf8
#按照上述的格式来 组织数据库信息
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".\
format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
#创建数据库引擎
engine = create_engine(DB_URI)
#创建会话对象
session = sessionmaker(engine)()
#创建一个ORM模型
Base = declarative_base(engine)
class News(Base):
__tablename__='news'
id = Column(Integer,primary_key=True,autoincrement=True)
title =Column(String(50),nullable=False)
price = Column(Integer)
def __repr__(self):
return "<title:%s,price:%s>"%(self.title,self.price)
# Base.metadata.drop_all()
# Base.metadata.create_all()
#新增测试数据
# for x in range(1,6):
# a = News(title="标题%s"%x,price =random.randint(1,100))
# session.add(a)
# session.commit()
#query()函数中能写什么参数 3种
#1.模型名
# results = session.query(News).all()
# print(results)
#2.模型名中的属性。 返回的列表中的元素是 元组类型数据
# results = session.query(News.title,News.price).all()
# print(results)
#3.mysql聚合函数
# r = session.query(func.count(News.id)).first()
# print(r)
# r = session.query(func.max(News.price)).first()
# print(r)
# r = session.query(func.min(News.price)).first()
# print(r)
# r = session.query(func.avg(News.price)).first()
# print(r)
r = session.query(func.sum(News.price)).first()
print(r)
filter过滤条件：
filter过滤条件：
过滤是数据提取的一个很重要的功能，以下对一些常用的过滤条件进行解释，并且这些过滤条件都是只能通过filter方法实现的：
1. equals ： ==
news= session.query(News).filter(News.title == "title1").first()
2. not equals : !=
query(User).filter(User.name != 'ed')
3. like & ilike [不区分大小写]：
query(User).filter(User.name.like('%ed%'))
4. in：
query(User).filter(User.name.in_(['ed','wendy','jack']))
5. not in：
query(User).filter(~User.name.in_(['ed','wendy','jack']))
6. is null：
query(User).filter(User.name==None)
# 或者是
query(User).filter(User.name.is_(None))
7. is not null:
query(User).filter(User.name != None)
# 或者是
query(User).filter(User.name.isnot(None))
8. and：
query(User).filter(and_(User.name=='ed',User.fullname=='Ed Jones'))
# 或者是传递多个参数
query(User).filter(User.name=='ed',User.fullname=='Ed Jones')
# 或者是通过多次filter操作
query(User).filter(User.name=='ed').filter(User.fullname=='Ed Jones')
9. or：
query(User).filter(or_(User.name=='ed',User.name=='wendy'))
如果想要查看orm底层转换的sql语句，可以在filter方法后面不要再执行任何方法直接打印就可以看到了。比如：
news = session.query(News).filter(or_(News.title=='abc',News.content=='abc'))
print(news)
代码演示：
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,\
Date,DateTime,Time,String,Text,func,or_,and_
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
import random
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
class Article(Base):
__tablename__ = 'article'
id = Column(Integer,primary_key=True,autoincrement=True)
title = Column(String(50),nullable=False)
price = Column(Float,nullable=False)
content = Column(Text)
def __repr__(self):
return "<Article(title:%s)>" % self.title
#共两种查询 过滤的方法
# r1 = session.query(News).filter(News.id == 1).first()
# print(r1)
# r2 =session.query(News).filter_by(id = 2).first()
# print(r2)
# 1. equal
# news = session.query(News).filter(News.title == "title0").first()
# print(news)
# 2. not equal
# news= session.query(News).filter(News.title != 'title0').all()
# print(news)
# 3. like & ilike（不区分大小写）
# news= session.query(News).filter(News.title.ilike('title%')).all()
# print(news)
# 4. in：
# for xxx in xxx
# def _in()
# news= session.query(News).filter(News.title.in_(['title1','title2'])).all()
# print(news)
#5. not in
# news= session.query(News).filter(~News.title.in_(['title1','title2'])).all()
# print(news)
# news= session.query(News).filter(News.title.notin_(['title1','title2'])).all()
# print(news)
#6. is null
#修改表，添加一个列content,操作数据
# news= session.query(News).filter(News.content==None).all()
# print(news)
#7. is not null
# news= session.query(News).filter(News.content!=None).all()
# print(news)
#8. and
# news= session.query(News).filter(News.title=='title5',News.content=='abc').all()
# print(news)
# 或者
# news= session.query(News).filter(and_(News.title=='title5',News.content=='abc')).all()
# print(news)
#9.or
# news= session.query(News).filter(or_(News.title=='title3',News.content=='abc')).all()
# print(news)
表关系：
表关系：
表之间的关系存在三种：一对一、一对多、多对多。
而SQLAlchemy中的ORM也可以模拟这三种关系。
因为一对一其实在SQLAlchemy中底层是通过一对多的方式模拟的，所以先来看下一对多的关系：
外键：
使用SQLAlchemy创建外键非常简单。在从表中增加一个字段，指定这个字段外键的是哪个表的哪个字段就可以了。从表中外键的字段，必须和主表的主键字段类型保持一致。
示例代码如下：
# 主表 / 从表
# user/news
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
uname = Column(String(50),nullable=False)
def __repr__(self):
return "<User(uname:%s)>" % self.uname
class News(Base):
__tablename__ = 'news'
id = Column(Integer,primary_key=True,autoincrement=True)
title = Column(String(50),nullable=False)
content = Column(Text,nullable=False)
uid = Column(Integer,ForeignKey("user.id"))
def __repr__(self):
return "<News(title:%s,content=%s)>" % (self.title,self.content)
外键约束有以下几项：
1. RESTRICT：若子表中有父表对应的关联数据，删除父表对应数据，会阻止删除。默认项
2. NO ACTION：在MySQL中，同RESTRICT。
3. CASCADE：级联删除。
4. SET NULL：父表对应数据被删除，子表对应数据项会设置为NULL。
演示代码如下：
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,\
Date,DateTime,Time,String,Text,func,or_,and_,ForeignKey
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
import random
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
# 父表/从表
# user/news
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
uname = Column(String(50),nullable=False)
def __repr__(self):
return "<User(uname:%s)>" % self.uname
class News(Base):
__tablename__ = 'news'
id = Column(Integer,primary_key=True,autoincrement=True)
title = Column(String(50),nullable=False)
content = Column(Text,nullable=False)
# uid = Column(Integer,ForeignKey("user.id",ondelete='RESTRICT'))
# uid = Column(Integer,ForeignKey("user.id",ondelete='NO ACTION'))
# uid = Column(Integer,ForeignKey("user.id",ondelete='CASCADE'))
uid = Column(Integer,ForeignKey("user.id",ondelete='SET NULL'))
def __repr__(self):
return "<News(title:%s,content=%s)>" % (self.title,self.content)
Base.metadata.drop_all()
Base.metadata.create_all()
user = User(uname='momo')
session.add(user)
session.commit()
news1= News(title='AAA',content='123',uid=1)
news2= News(title='BBB',content='456',uid=1)
session.add_all([news1,news2])
session.commit()
ORM关系之一对多：
ORM关系之一对多：
mysql级别的外键，还不够爽，必须拿到一个表的外键，然后通过这个外键再去另外一张表中查找，这样太麻烦了。
SQLAlchemy提供了一个`relationship`，这个类可以定义属性，以后在访问相关联的表的时候就直接可以通过属性访问的方式就可以访问得到了。另外，可以通过`backref`来指定反向访问的属性名称。newss是指有多篇新闻。他们之间的关系是一个“一对多”的关系。
演示代码如下：
from sqlalchemy import create_engine,Column,Integer,String,Float,Enum,Boolean,DECIMAL,Text,\
Date,DateTime,Time,func,and_,or_,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.orm import sessionmaker,relationship
import random
import enum
from datetime import date
from datetime import datetime
from datetime import time
#准备数据库的一堆信息 ip port user pwd 数据库的名称 按要求组织格式
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
#dialect+driver://username:password@host:port/database?charset=utf8
#按照上述的格式来 组织数据库信息
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".\
format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
#创建数据库引擎
engine = create_engine(DB_URI)
#创建会话对象
session = sessionmaker(engine)()
#创建ORM模型
Base = declarative_base(engine)
# 主表 / 从表
# user/news
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
uname = Column(String(50),nullable=False)
# newss=relationship("News") #这种写法不是最优的，通常会把它通过反向声明的方式写在“多”的那一方
def __repr__(self):
return "<User(uname:%s)>" % self.uname
class News(Base):
__tablename__ = 'news'
id = Column(Integer,primary_key=True,autoincrement=True)
title = Column(String(50),nullable=False)
content = Column(Text,nullable=False)
#外键
uid = Column(Integer,ForeignKey("user.id"))
#正向author = relationship("User")
#正向 和 反向在一起 表明两个模型之间的关系
author = relationship("User",backref="newss")
def __repr__(self):
return "<News(title:%s,content=%s)>" % (self.title,self.content)
# Base.metadata.drop_all()
# Base.metadata.create_all()
#需求1：查询 第一篇新闻的 作者是谁
# news= session.query(News).first()
# print(news)
# print(news.uid) #1
# user = session.query(User).get(news.uid)
# print(user.uname)
#上述的需求 能够被实现 但是太麻烦，引入relationship进行查询优化
# news = session.query(News).first()
# print(news.author)
# print(news.author.uname)
#需求2：查询xx作者的所有文章
user = session.query(User).first()
print(user.newss)
ORM关系之一对一：
ORM关系之一对一：
在sqlalchemy中，如果想要将两个模型映射成一对一的关系，那么应该在父模型中，指定引用的时候，要传递一个`uselist=False`这个参数进去。就是告诉父模型，以后引用这个从模型的时候，不再是一个列表了，而是一个对象了。示例代码如下：
方式1：
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
uname = Column(String(50),nullable=False)
extend = relationship("UserExtend",uselist=False)
class UserExtend(Base):
__tablename__ = 'user_extend'
id = Column(Integer, primary_key=True, autoincrement=True)
school = Column(String(50))
uid = Column(Integer,ForeignKey("user.id"))
user = relationship("User")
方式2：（用得较多）
当然，也可以借助`sqlalchemy.orm.backref`来简化代码：
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
uname = Column(String(50),nullable=False)
class UserExtend(Base):
__tablename__ = 'user_extend'
id = Column(Integer, primary_key=True, autoincrement=True)
school = Column(String(50))
uid = Column(Integer,ForeignKey("user.id"))
user = relationship("User",backref=backref("extend",uselist=False))
演示代码如下：
from sqlalchemy import create_engine,Column,Integer,String,Float,DECIMAL,Boolean,Enum,Date,DateTime,Time,Text
from sqlalchemy import func,and_,or_,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.orm import sessionmaker,relationship,backref
from datetime import date,datetime,time
#在python 3.x中 有enum模块
import enum
import random
#准备连接数据库基本信息
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
#dialect+driver://username:password@host:port/database?charset=utf8
#按照上述的格式来 组织数据库信息
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
#创建数据库引擎
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
# 主表 / 从表
# user/news 1：n
# user/user_extend 1：1
#表1
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
uname = Column(String(50),nullable=False)
#添加属性 优化2表查询操作
# newss =relationship("News") #这种写法不是最优的，通常会把它通过反向声明的方式写在“多”的那一方
#1:1关系的表示方式1
# extend =relationship("UserExtend",uselist=False)
def __repr__(self):
return "<User(uname:%s)>" % self.uname
#表3
class UserExtend(Base):
__tablename__ = 'user_extend'
id = Column(Integer, primary_key=True, autoincrement=True)
school = Column(String(50))
#外键
uid = Column(Integer,ForeignKey("user.id"))
#1:1关系的表示方式1
# user = relationship("User")
# 1:1关系的表示方式2
user = relationship("User",backref = backref("extend",uselist=False))
#表2
class News(Base):
__tablename__ = 'news'
id = Column(Integer,primary_key=True,autoincrement=True)
title = Column(String(50),nullable=False)
content = Column(Text,nullable=False)
#SQLALchemy实现外键的方法
uid = Column(Integer,ForeignKey("user.id")) #默认删除策略为 ：RESTRICT
#添加属性 优化2表查询操作
#正向
# author = relationship("User")
#最终：会把正向 和反向 关系 写在一起
author = relationship("User",backref="newss")
def __repr__(self):
return "<News(title:%s,content=%s)>" % (self.title,self.content)
#创建表
# Base.metadata.drop_all()
# Base.metadata.create_all()
#需求：ORM层面外键 和一对一关系实现
#好处1：添加数据 User 添加 UserExtend
# user = User(uname="wangwu")
# ux = UserExtend(school="京南大学")
# user.extend = ux
# # print(type(user.extend))
# session.add(user)
# session.commit()
#好处1：添加数据 UserExtend 添加 User
# ux = UserExtend(school="武汉大学")
# user2 = User(uname="李四")
# ux.user = user2
# print(type(ux.user))
# session.add(ux)
# session.commit()
#好处2：查询数据
user3 = session.query(User).first()
print(user3.uname)
print(user3.extend.school)
ORM关系之多对多：
ORM关系之多对多：
1. 多对多的关系需要通过一张中间表来绑定他们之间的关系。
2. 先把两个需要做多对多的模型定义出来
3. 使用Table定义一个中间表，中间表一般就是包含两个模型的外键字段就可以了，并且让他们两个来作为一个“复合主键”。
4. 在两个需要做多对多的模型中随便选择一个模型，定义一个relationship属性，来绑定三者之间的关系，在使用relationship的时候，需要传入一个secondary=中间表对象名
代码演示如下：
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,\
Date,DateTime,Time,String,Text,func,or_,and_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
import random
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
#表3 中间表
news_tag = Table(
"news_tag",
Base.metadata,
Column("news_id",Integer,ForeignKey("news.id"),primary_key=True),
Column("tag_id",Integer,ForeignKey("tag.id"),primary_key=True)
)
#表1
class News(Base):
__tablename__ = 'news'
id = Column(Integer,primary_key=True,autoincrement=True)
title = Column(String(50),nullable=False)
#产生关系 写法1
# tags = relationship("Tag",backref="newss",secondary=news_tag)
def __repr__(self):
return "<News(title:%s)>" % self.title
#表2
class Tag(Base):
__tablename__ = 'tag'
id = Column(Integer, primary_key=True, autoincrement=True)
name = Column(String(50), nullable=False)
# 产生关系 写法2
newss = relationship("News",backref="tags",secondary=news_tag)
def __repr__(self):
return "<Tag(name:%s)>" % self.name
# 1. 先把两个需要做多对多的模型定义出来
# 2. 使用Table定义一个中间表，中间表一般就是包含两个模型的外键字段就可以了，并且让他们两个来作为一个“复合主键”。
# 3. 在两个需要做多对多的模型中随便选择一个模型，定义一个relationship属性，来绑定三者之间的关系，
# 4. 在使用relationship的时候，需要传入一个secondary=中间表对象名。
Base.metadata.drop_all()
Base.metadata.create_all()
#添加数据的好处
news1 = News(title="世界第一")
news2 = News(title="世界第二")
tag1 = Tag(name='要闻')
tag2 = Tag(name='娱乐')
news1.tags.append(tag1)
news1.tags.append(tag2)
news2.tags.append(tag1)
news2.tags.append(tag2)
session.add(news1)
session.add(news2)
session.commit()
#查询数据的好处
news3 = session.query(News).first()
print(news3.tags)
tag = session.query(Tag).first()
print(tag.newss)
ORM层面删除数据注意事项：
ORM层面删除数据注意事项：ORM层面删除数据注意事项：
ORM层面删除数据，会无视mysql级别的外键约束。
直接会将对应的数据删除，然后将从表中的那个外键设置为NULL。
如果想要避免这种行为，应该将从表中的外键的`nullable=False`。
演示代码如下：
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,\
Date,DateTime,Time,String,Text,func,or_,and_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
import random
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
uname = Column(String(50),nullable=False)
class News(Base):
__tablename__ = 'news'
id = Column(Integer, primary_key=True, autoincrement=True)
title = Column(String(50),nullable=False)
uid = Column(Integer,ForeignKey("user.id"),nullable=False)
author = relationship("User",backref='newss')
Base.metadata.drop_all()
Base.metadata.create_all()
user = User(uname='momo')
news= News(title='hello world')
news.author = user
session.add(news)
session.commit()
#若 uid = Column(Integer,ForeignKey("user.id")) 没有声明非空，删除父表能成功，会将子表数据 对应项置为空
#解决 若uid = Column(Integer,ForeignKey("user.id"),nullable=False) 会被阻止删除父表
user = session.query(User).first()
session.delete(user)
session.commit()
ORM层面的relationship方法中cascade1：
ORM层面的relationship方法中cascade1：
在SQLAlchemy，只要将一个数据添加到session中，和他相关联的数据都可以一起存入到数据库中了。
这些是怎么设置的呢？其实是通过relationship的时候，有一个关键字参数cascade可以设置这些属性，
cascade属性值为：
save-update：默认选项。在添加一条数据的时候，会把其他和他相关联的数据都添加到数据库中。这种行为就是save-update属性影响的。
delete：表示当删除某一个模型中的数据的时候，是否也删掉使用relationship和他关联的数据。
delete-orphan：表示当对一个ORM对象解除了父表中的关联对象的时候，自己便会被删除掉。当然如果父表中的数据被删除，自己也会被删除。这个选项只能用在一对多上，并且还需要在子模型中的relationship中，增加一个single_parent=True的参数。
merge：默认选项。当在使用session.merge，合并一个对象的时候，会将使用了relationship相关联的对象也进行merge操作。
expunge：移除操作的时候，会将相关联的对象也进行移除。这个操作只是从session中移除，并不会真正的从数据库中删除。
all：是对save-update, merge, refresh-expire, expunge, delete几种的缩写。
代码演示：
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,\
Date,DateTime,Time,String,Text,func,or_,and_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
import random
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
uname = Column(String(50),nullable=False)
# articles =relationship("Article",cascade="save-update,delete") #放入Article中去优化
# comments = relationship("Comment") #放入Comment中去优化
class Article(Base):
__tablename__ = 'article'
id = Column(Integer, primary_key=True, autoincrement=True)
title = Column(String(50), nullable=False)
uid = Column(Integer,ForeignKey("user.id"),nullable=False)
# author = relationship("User",backref="articles") #cascade默认为save-update
# author = relationship("User",backref="articles",cascade="save-update") #明文指定为save-update
#delete：表示当删除某一个模型中的数据的时候，是否也删掉使用relationship和他关联的数据。默认不删除关联数据
# author = relationship("User",cascade="save-update,delete") #明文指定为save-update 和delete
#优化写法
author = relationship("User",backref=backref("articles",cascade="save-update,delete"),cascade="save-update,delete")
class Comment(Base):
__tablename__ = 'comment'
id = Column(Integer, primary_key=True, autoincrement=True)
content = Column(Text,nullable=False)
uid = Column(Integer,ForeignKey("user.id"))
#author = relationship("User")
# 优化写法
author = relationship("User",backref=backref("comments"))
def add_data():
Base.metadata.drop_all()
Base.metadata.create_all()
user = User(uname="momo")
article = Article(title="华为5G")
article.author = user
session.add(article)
#引入comment表
comment = Comment(content='你少说风凉话')
comment.author = user
session.add(comment)
session.commit()
def oper_data():
#relationship里边的cascade 可通过Article影响User
# article = session.query(Article).first()
# session.delete(article)
# session.commit()
#反过来通过User也能影响Article
user = session.query(User).first()
session.delete(user)
session.commit()
#总结1：relationship里边的cascade 可通过Article影响User，反过来通过User也能影响Article
#总结2：relationship里边的cascade 只会影响当前类User中relationship的模型Article，不会影响模型Comment
if __name__ == '__main__':
# add_data()
oper_data()
#ORM层面的relationship方法中cascade使用1
ORM层面的relationship方法中cascade2：
ORM层面的relationship方法中cascade2：
在SQLAlchemy，只要将一个数据添加到session中，和他相关联的数据都可以一起存入到数据库中了。
这些是怎么设置的呢？其实是通过relationship的时候，有一个关键字参数cascade可以设置这些属性，
cascade属性值为：
save-update：默认选项。在添加一条数据的时候，会把其他和他相关联的数据都添加到数据库中。这种行为就是save-update属性影响的。
delete：表示当删除某一个模型中的数据的时候，是否也删掉使用relationship和他关联的数据。
delete-orphan：表示当对一个ORM对象解除了父表中的关联对象的时候，自己便会被删除掉。当然如果父表中的数据被删除，自己也会被删除。这个选项只能用在一对多上，并且还需要在子模型中的relationship中，增加一个single_parent=True的参数。
merge：默认选项。当在使用session.merge，合并一个对象的时候，会将使用了relationship相关联的对象也进行merge操作。
expunge：了解即可。移除操作的时候，会将相关联的对象也进行移除。这个操作只是从session中移除，并不会真正的从数据库中删除。
all：是对save-update, merge, expunge, delete几种的缩写。
代码演示：
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,\
Date,DateTime,Time,String,Text,func,or_,and_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
import random
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
uname = Column(String(50),nullable=False)
class Article(Base):
__tablename__ = 'article'
id = Column(Integer, primary_key=True, autoincrement=True)
title = Column(String(50), nullable=False)
uid = Column(Integer,ForeignKey("user.id"),nullable=False)
#优化写法
# author = relationship("User",backref=backref("articles",cascade="save-update,delete"),cascade="save-update,delete")
#delete-orphan的使用 ,注意：delete-orphan依赖于delete
# author = relationship("User",backref=backref("articles",cascade="save-update,delete,delete-orphan"),
# cascade="save-update",single_parent=True)
#merge的使用
# author = relationship("User",backref=backref("articles",cascade="save-update,delete,delete-orphan,merge"),
# cascade="save-update",single_parent=True)
#all的使用 ：包含了save-update, merge, expunge, delete几种功能
author = relationship("User",backref=backref("articles",cascade="all"),
cascade="save-update",single_parent=True)
class Comment(Base):
__tablename__ = 'comment'
id = Column(Integer, primary_key=True, autoincrement=True)
content = Column(Text,nullable=False)
uid = Column(Integer,ForeignKey("user.id"))
author = relationship("User")
# 优化写法
author = relationship("User",backref=backref("comments"))
def add_data():
Base.metadata.drop_all()
Base.metadata.create_all()
user = User(uname="momo")
article = Article(title="华为5G")
article.author = user
session.add(article)
#引入comment表
comment = Comment(content='你少说风凉话')
comment.author = user
session.add(comment)
session.commit()
def oper_data():
#relationship里边的cascade 可通过Article影响User
# article = session.query(Article).first()
# session.delete(article)
# session.commit()
#反过来通过User也能影响Article
# user = session.query(User).first()
# session.delete(user)
# session.commit()
#测试delete-orphan的使用
user = session.query(User).first()
user.articles = []
session.commit()
#测试 merge 先查看user中的id数据 执行完该功能函数后 再查看user中的id数据
def oper_data_merge():
user = User(id=1,uname = "莫莫")
#merge：默认选项，合并成功
# session.merge(user)
#merge：当在使用session.merge，合并一个对象的时候，会将使用了relationship相关联的对象也进行merge操作。
article = Article(id=1,title="5G还没普及起来，4G怎么变慢了呢？")
user.articles.append(article)
session.merge(user)
session.commit()
#测试expunge 移除操作的时候，会将相关联的对象也进行移除。这个操作只是从session中移除，并不会真正的从数据库中删除。
def oper_data_expunge():
user = User(uname='花花')
article = Article(title='哈哈哈')
article.author = user
session.add(user)
session.add(article)
session.expunge(user) #总结：add方法 与expunge的作用相反
session.commit()
if __name__ == '__main__':
# add_data()
# oper_data()
# oper_data_merge()
oper_data_expunge()
#ORM层面的relationship方法中cascade使用2
#总结:ondelete的删除策略必须掌握，同时了解orm层面的cascade的操作即可
排序：
排序：
1. order_by方法排序：可以指定根据模型中某个属性进行排序，"模型名.属性名.desc()"代表的是降序排序。
2. 在定义模型的时候指定排序：有些时候，不想每次在查询的时候都用order_by方法，可以在定义模型的时候就指定排序的方式。
有以下两种方式：
在模型定义中，添加以下代码：
__mapper_args__ = {
# "order_by": create_time #正序
"order_by": create_time.desc() #倒序
}
relationship的方法中order_by属性：在指定relationship方法的时候，添加order_by属性来指定排序的字段。
# author = relationship("User", backref=backref("articles",order_by=create_time)) #正序
author = relationship("User", backref=backref("articles",order_by=create_time.desc())) #倒序
方式一代码演示：order_by方法指定
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,\
Date,DateTime,Time,String,Text,func,or_,and_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
import random,time
from datetime import datetime
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
#排序方式1：order_by方法指定
class Article(Base):
__tablename__ = 'article'
id = Column(Integer, primary_key=True, autoincrement=True)
title = Column(String(50), nullable=False)
create_time = Column(DateTime, nullable=False, default=datetime.now)
def __repr__(self):
return "<Article(title:%s,create_time:%s)>" % (self.title,self.create_time)
def add_data():
Base.metadata.drop_all()
Base.metadata.create_all()
article1 = Article(title='title1')
session.add(article1)
session.commit()
time.sleep(3)
article2 = Article(title='title2')
session.add(article2)
session.commit()
def oper():
# 正序排序
articles1 = session.query(Article).order_by(Article.create_time).all()
print(articles1)
# 倒序排序
articles2 = session.query(Article).order_by(Article.create_time.desc()).all()
print(articles2)
if __name__ == '__main__':
# add_data()
oper()
方式二代码演示：定义模型时，指定排序方式
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,\
Date,DateTime,Time,String,Text,func,or_,and_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
import random,time
from datetime import datetime
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
#排序方式2：定义模型时，指定排序方式
class Article(Base):
__tablename__ = 'article'
id = Column(Integer, primary_key=True, autoincrement=True)
title = Column(String(50), nullable=False)
create_time = Column(DateTime, nullable=False, default=datetime.now)
__mapper_args__ = {
# "order_by": create_time #正序
"order_by": create_time.desc() #倒序
}
def __repr__(self):
return "<Article(title:%s,create_time:%s)>" % (self.title,self.create_time)
def add_data():
Base.metadata.drop_all()
Base.metadata.create_all()
article1 = Article(title='title1')
session.add(article1)
session.commit()
time.sleep(3)
article2 = Article(title='title2')
session.add(article2)
session.commit()
def oper():
# 不用再指定排序方式 因为在定义模型的时候 就已指定好排序方式
articles2 = session.query(Article).all()
print(articles2)
if __name__ == '__main__':
# add_data()
oper()
方式三代码演示：涉及两表时，定义模型时，用relationship方法中的order_by属性指定排序方式
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,\
Date,DateTime,Time,String,Text,func,or_,and_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
import random,time
from datetime import datetime
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
#排序方式3：涉及两表时，定义模型时，用relationship方法中的order_by属性指定排序方式
class User(Base):
__tablename__ = 'user'
id = Column(Integer, primary_key=True, autoincrement=True)
uname = Column(String(50),nullable=False)
class Article(Base):
__tablename__ = 'article'
id = Column(Integer, primary_key=True, autoincrement=True)
title = Column(String(50), nullable=False)
create_time = Column(DateTime, nullable=False, default=datetime.now)
uid = Column(Integer,ForeignKey("user.id"))
# author = relationship("User", backref=backref("articles",order_by=create_time)) #正序
author = relationship("User", backref=backref("articles",order_by=create_time.desc())) #倒序
def __repr__(self):
return "<Article(title:%s,create_time:%s)>" % (self.title,self.create_time)
def add_data():
Base.metadata.drop_all()
Base.metadata.create_all()
article1 = Article(title='title1')
user = User(uname='默默')
user.articles = [article1]
session.add(user)
session.commit()
time.sleep(3)
article2 = Article(title='title2')
user.articles.append(article2)
session.commit()
def oper():
# 不用再指定排序方式 因为在定义模型的时候 就已指定好排序方式
user = session.query(User).first()
print(user.articles)
if __name__ == '__main__':
# add_data()
oper()
limit、offset、slice使用：
limit、offset、slice使用：
1. limit：可以限制查询的时候只查询前几条数据。 属top-N查询
2. offset：可以限制查找数据的时候过滤掉前面多少条。可指定开始查询时的偏移量。
3. 切片：可以对Query对象使用切片操作，来获取想要的数据。
可以使用`slice(start,stop)`方法来做切片操作。
也可以使用`[start:stop]`的方式来进行切片操作。
一般在实际开发中，中括号的形式是用得比较多的。
代码演示：
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,\
Date,DateTime,Time,String,Text,func,or_,and_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
import random,time
from datetime import datetime
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
class Article(Base):
__tablename__ = 'article'
id = Column(Integer,primary_key=True,autoincrement=True)
title = Column(String(50),nullable=False)
create_time = Column(DateTime,default=datetime.now)
def __repr__(self):
return "<Article(title: %s)>" % self.title
def add_data():
Base.metadata.drop_all()
Base.metadata.create_all()
for x in range(100):
title = "title %s" % x
article = Article(title=title)
session.add(article)
session.commit()
def oper1():
# articles = session.query(Article).all()
#limit：可以限制每次查询的时候只查询前几条数据。 属top-N查询
articles = session.query(Article).limit(10).all()
print(articles)
def oper2():
#offset：可以限制查找数据的时候过滤掉前面多少条。可指定开始查询时的偏移量。
# articles = session.query(Article).offset(10).limit(10).all()
#场景选型：查看最新的10条新闻
articles = session.query(Article).order_by(Article.id.desc()).limit(10).all()
print(articles)
#实现分页
from sqlalchemy.orm.query import Query
def oper3():
articles = session.query(Article).order_by(Article.id.desc()).slice(0,10).all()
print(articles)
def oper4():
articles = session.query(Article).order_by(Article.id.desc())[0:10]
print(articles)
if __name__ == '__main__':
# add_data()
# oper1()
# oper2()
# oper3()
oper4()
懒加载：
懒加载：
在一对多，或者多对多关系的时候，如果想要获取多的一方这一部分的数据的时候，往往能通过一个属性就可以全部获取了。
如有一个作者，想要这个作者的所有文章，通过user.articles就可以获取所有的。
但有时候我们不想获取所有的数据，如只想获取这个作者今天发表的文章，那么这时候我们可以给relationship方法添加属性lazy='dynamic'，以后通过user.articles获取到的就不是一个列表，而是一个AppenderQuery对象了。这样就可以对这个对象再进行一层过滤和排序等操作。
通过`lazy='dynamic'`，获取出来的多的那一部分的数据，就是一个`AppenderQuery`对象了。这种对象既可以添加新数据，也可以跟`Query`一样，可以再进行一层过滤。
lazy可用的选项：
1. `select`：这个是默认选项。还是拿`user.articles`的例子来讲。如果你没有访问`user.articles`这个属性，那么sqlalchemy就不会从数据库中查找文章。一旦你访问了这个属性，那么sqlalchemy就会立马从数据库中查找所有的文章，并把查找出来的数据组装成一个列表返回。这也是懒加载。
2. `dynamic`：这个也是懒加载。就是在访问`user.articles`的时候返回来的不是一个列表，而是`AppenderQuery`对象。
总结：如果你在获取数据的时候，想要对多的那一边的数据再进行一层过滤，那么这时候就可以使用`lazy='dynamic'`。
代码演示：
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,\
Date,DateTime,Time,String,Text,func,or_,and_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
import random,time
from datetime import datetime
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
class User(Base):
__tablename__ = 'user'
id = Column(Integer, primary_key=True, autoincrement=True)
uname = Column(String(50),nullable=False)
class Article(Base):
__tablename__ = 'article'
id = Column(Integer, primary_key=True, autoincrement=True)
title = Column(String(50), nullable=False)
create_time = Column(DateTime, nullable=False, default=datetime.now)
uid = Column(Integer,ForeignKey("user.id"))
# author = relationship("User", backref=backref("articles"))
#懒加载
author = relationship("User", backref=backref("articles",lazy="dynamic"))
def __repr__(self):
return "<Article(title:%s,create_time:%s)>" % (self.title,self.create_time)
def add_data():
Base.metadata.drop_all()
Base.metadata.create_all()
user = User(uname='莫莫')
for x in range(100):
article = Article(title="title %s" % x)
article.author = user
session.add(article)
session.commit()
from sqlalchemy.orm.collections import InstrumentedList
def oper1():
user = session.query(User).first()
print(type(user.articles)) #<class 'sqlalchemy.orm.collections.InstrumentedList'>
print(user.articles)
#懒加载
from sqlalchemy.orm.dynamic import AppenderQuery
def oper2():
user = session.query(User).first()
print(type(user.articles)) #<class 'sqlalchemy.orm.dynamic.AppenderQuery'>
print(user.articles)
#辨析 AppenderQuery 和 Query
from sqlalchemy.orm.query import Query
def oper3():
user = session.query(User)
print(type(user)) #<class 'sqlalchemy.orm.query.Query'>
print(user) #sql语句
#有2层意思
#1.是一个Query对象。可以调用Query对象的方法
#2.是一个AppenderQuery对象。可以继续追加数据进去
def oper4():
user = session.query(User).first()#可以调用Query对象的方法
print(type(user))
print(user.articles.filter(Article.id>=50).all())
# article = Article(title='title 100')
# user.articles.append(article)#2.是一个AppenderQuery对象。可以继续追加数据进去
# session.commit()
if __name__ == '__main__':
# add_data()
# oper1()
# oper2()
# oper3()
oper4()
分组group_by和过滤分组having:
分组group_by和过滤分组having:
group_by：
根据某个字段进行分组。如想要根据年龄进行分组，来统计每个分组分别有多少人
r = session.query(User.age,func.count(User.id)).group_by(User.age).all()
having：
having是对分组查找结果作进一步过滤。如只想要看未成年人的人数，
那么可以首先对年龄进行分组统计人数，然后再对分组进行having过滤。
r = session.query(User.age,func.count(User.id)).group_by(User.age).having(User.age < 18).all()
代码演示：
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,\
Date,DateTime,Time,String,Text,func,or_,and_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
import random,time
from datetime import datetime
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
uname = Column(String(50),nullable=False)
age = Column(Integer,default=0)
gender = Column(Enum("男","女","秘密"),default="男")
def add_data():
Base.metadata.drop_all()
Base.metadata.create_all()
user1 = User(uname='李一',age=17,gender='男')
user2 = User(uname='李二',age=17,gender='男')
user3 = User(uname="张三",age=18,gender='女')
user4 = User(uname="张四",age=19,gender='女')
user5 = User(uname="莫莫",age=20,gender='男')
session.add_all([user1,user2,user3,user4,user5])
session.commit()
#查询 每个年龄的人数
def oper1():
# user = session.query(User.age,func.count(User.id)).group_by(User.age)
# print(user) #sql语句
user = session.query(User.age, func.count(User.id)).group_by(User.age).all()
print(user) # 列表
#查询 每个年龄的人数，要求排除未成年人
def oper2():
user = session.query(User.age, func.count(User.id)).group_by(User.age).having(User.age>=18).all()
print(user) # 列表
#查询 每个年龄的人数，要求未成年人
def oper3():
user = session.query(User.age, func.count(User.id)).group_by(User.age).having(User.age<18).all()
print(user) # 列表
if __name__ == '__main__':
# add_data()
# oper1()
# oper2()
oper3()
join的使用_高级查询之多表查询：
join的使用_高级查询之多表查询：
1.mysql中的外连接、内连接
表A数据：
aID aNum
1 a20050111
2 a20050112
3 a20050113
4 a20050114
5 a20050115
表B数据:
bID bName
1 2006032401
2 2006032402
3 2006032403
4 2006032404
8 2006032408
1.1 left join(左连接)
SELECT * FROM a
LEFT JOIN b
ON a.aID =b.bID
结果如下:
aID aNum bID bName
1 a20050111 1 2006032401
2 a20050112 2 2006032402
3 a20050113 3 2006032403
4 a20050114 4 2006032404
5 a20050115 NULL NULL
结果说明:
left join是以A表的记录为基础的,A可以看成左表,B可以看成右表,leftjoin是以左表为准的.
换句话说,左表(A)的记录将会全部表示出来,而右表(B)只会显示符合搜索条件的记录(例子中为: A.aID = B.bID).
B表记录不足的地方均为NULL.
1.2 right join(右连接)
SELECT * FROM a
RIGHT JOING b
ON a.aID = b.bID
结果如下:
aID aNum bID bName
1 a20050111 1 2006032401
2 a20050112 2 2006032402
3 a20050113 3 2006032403
4 a20050114 4 2006032404
NULL NULL 8 2006032408
结果说明:
仔细观察一下,就会发现,和left join的结果刚好相反,这次是以右表(B)为基础的,A表不足的地方用NULL填充.
1.3 inner join(相等连接或内连接)
SELECT * FROM a
INNER JOIN b
ON a.aID =b.bID
等同于以下SQL句:
SELECT *
FROM a,b
WHERE a.aID = b.bID
结果如下:
aID aNum bID bName
1 a20050111 1 2006032401
2 a20050112 2 2006032402
3 a20050113 3 2006032403
4 a20050114 4 2006032404
结果说明:
很明显,这里只显示出了 A.aID = B.bID的记录.这说明inner join并不以谁为基础,它只显示符合条件的记录.
2.join的使用_高级查询：
1. join分为left join（左外连接）和right join（右外连接）以及内连接（等值连接）。
2. 在sqlalchemy中，使用join来完成内连接。在写join的时候，如果不写join的条件，那么默认将使用外键来作为条件连接。
3. 查询出来的字段，跟join后面的东西无关，而是取决于query方法中传了什么参数。（模型名=全表；模型名.属性=表名.字段）。
4. 在sqlalchemy中，使用outerjoin来完成外连接（默认是左外连接）。
3.代码演示
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,\
Date,DateTime,Time,String,Text,func,or_,and_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
import random,time
from datetime import datetime
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
uname = Column(String(50),nullable=False)
def __repr__(self):
return "<User(uname: %s)>" % self.uname
class Article(Base):
__tablename__ = 'article'
id = Column(Integer, primary_key=True, autoincrement=True)
title = Column(String(50), nullable=False)
create_time = Column(DateTime, nullable=False, default=datetime.now)
uid = Column(Integer,ForeignKey("user.id"))
author = relationship("User",backref="articles")
def __repr__(self):
return "<Article(title: %s)>" % self.title
def add_data():
Base.metadata.drop_all()
Base.metadata.create_all()
user1 = User(uname='莫莫')
user2 = User(uname='露露')
for x in range(1):
article = Article(title='title %s' % x)
article.author = user1
session.add(article)
session.commit()
for x in range(1,3):
article = Article(title='title %s' % x)
article.author = user2
session.add(article)
session.commit()
#找到所有的用户，按照发表的文章数量进行排序
#注意1：在sqlalchemy中，使用join来完成内连接
def oper1():
#select user.uname,count(article.id) from user join article on user.id=article.uid group by user.id order by count(article.id) desc;
# result = session.query(User.uname, func.count(Article.id)).join(Article,User.id==Article.uid).group_by(User.id).order_by(
# func.count(Article.id).desc())
# print(result) #sql语句
result = session.query(User.uname, func.count(Article.id)).join(Article, User.id == Article.uid).group_by(
User.id).order_by(
func.count(Article.id).desc()).all()
print(result) # 结果:列表
#找到所有的用户，按照发表的文章数量进行排序
#注意2：在写join的时候，如果不写join的条件，那么默认将使用外键来作为条件连接。
def oper2():
result = session.query(User.uname, func.count(Article.id)).join(Article).group_by(
User.id).order_by(
func.count(Article.id).desc()).all()
print(result) # 结果:列表
#找到所有的用户，按照发表的文章数量进行排序
#注意3： 查询出来的字段，跟join后面的东西无关，而是取决于query方法中传了什么参数。（模型名=全表；模型名.属性=表名.字段）
def oper3():
result = session.query(User).join(Article).group_by(
User.id).order_by(
func.count(Article.id).desc()).all()
print(result) # 结果:列表
if __name__ == '__main__':
# add_data()
# oper1()
# oper2()
oper3()
subquery的使用_高级查询之子查询
subquery的使用_高级查询之子查询
subquery方法：
子查询即select语句中还有select。
那么在sqlalchemy中，要实现一个子查询，需以下几个步骤：
1. 将子查询按照传统的方式写好查询代码，然后在`query`对象后面执行`subquery`方法，将这个查询变成一个子查询。
2. 在子查询中，将以后需要用到的字段通过`label`方法，取个别名。
3. 在父查询中，如果想要使用子查询的字段，那么可以通过子查询的返回值上的`c`属性拿到（c=Column）。
代码演示：
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,\
Date,DateTime,Time,String,Text,func,or_,and_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
import random,time
from datetime import datetime
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
uname = Column(String(50),nullable=False)
city = Column(String(50),nullable=False)
age = Column(Integer,default=0)
def __repr__(self):
return "<User(username: %s)>" % self.uname
def add_data():
Base.metadata.drop_all()
Base.metadata.create_all()
user1 = User(uname='一哥',city="贵阳",age=18)
user2 = User(uname='王二',city="贵阳",age=18)
user3 = User(uname='张三',city="北京",age=18)
user4 = User(uname='赵四',city="贵阳",age=20)
session.add_all([user1,user2,user3,user4])
session.commit()
# 相亲类网站：同城交友 之珍爱网
#需求： 寻找和 “一哥” 这个人在同一个城市，并且是同年龄的人
#实现思路1：传统方式
def oper1():
u = session.query(User).filter(User.uname == '一哥').first()
users = session.query(User).filter(User.city==u.city,User.age==u.age).all()
print(users)
#实现思路2：子查询方式
#原生sql：select `user`.id,`user`.uname,`user`.city,`user`.age from user,
# (select `user`.city,`user`.age from user where uname='一哥') as yige
# where `user`.city=yige.city AND `user`.age=yige.age
def oper2():
# stmt = session.query(User.city.label('city'), User.age.label('age')).filter(User.uname == '一哥').subquery()
# result = session.query(User).filter(User.city == stmt.c.city, User.age == stmt.c.age)
# print(result) #查看sql语句
stmt = session.query(User.city.label('city'), User.age.label('age')).filter(User.uname == '一哥').subquery()
result = session.query(User).filter(User.city == stmt.c.city, User.age == stmt.c.age).all()
print(result) # 查看结果
if __name__ == '__main__':
# add_data()
# oper1()
oper2()
aliased的函数_高级查询之别名使用：
aliased的函数_高级查询之别名使用：
当多表关联查询的时候，
有时候同一个表要用到多次，
这时候用别名就可以方便的解决命名冲突的问题了
代码演示：
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,\
Date,DateTime,Time,String,Text,func,or_,and_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
import random,time
from datetime import datetime
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
uname = Column(String(50),nullable=False)
city = Column(String(50),nullable=False)
age = Column(Integer,default=0)
def __repr__(self):
return "<User(username: %s)>" % self.uname
def add_data():
Base.metadata.drop_all()
Base.metadata.create_all()
user1 = User(uname='一哥',city="贵阳",age=18)
user2 = User(uname='王二',city="贵阳",age=18)
user3 = User(uname='张三',city="北京",age=18)
user4 = User(uname='赵四',city="贵阳",age=20)
session.add_all([user1,user2,user3,user4])
session.commit()
from sqlalchemy.orm import aliased
a1 = aliased(User)
a2 = aliased(User)
#别名
def oper1():
for uname, age1, age2 in session.query(User.uname,a1.age, a2.age).join(
a1,User.id==a1.id).join(a2,a1.id==a2.id).all():
print(uname, age1, age2)
if __name__ == '__main__':
# add_data()
oper1()
Flask-SQLAlchemy的使用_对SQLAlchemy进行了封装和优化：
Flask-SQLAlchemy的使用_对SQLAlchemy进行了封装和优化：
Flask-SQLAlchemy是一个插件，
Flask-SQLAlchemy是对SQLAlchemy进行了一个简单的封装的一个插件，
使得我们在flask中使用sqlalchemy更加的简单。
1.安装：
pip install flask-sqlalchemy
2.Flask-SQLAlchemy的使用要点：
2.1 数据库连接
数据库初始化不再是通过create_engine。
1. 跟sqlalchemy一样，定义好数据库连接字符串DB_URI。
2. 将这个定义好的数据库连接字符串DB_URI，通过`SQLALCHEMY_DATABASE_URI`这个key名配置到`app.config`中。
代码：app.config["SQLALCHEMY_DATABASE_URI"] = DB_URI
3. 使用`flask_sqlalchemy.SQLAlchemy`这个类定义一个对象，并将`app`传入进去。
代码：db = SQLAlchemy(app)
2.2 创建ORM模型类
之前都是通过Base = declarative_base()来初始化一个基类，然后再继承，在Flask-SQLAlchemy中更加简单了。
1. 还是跟使用sqlalchemy一样，定义模型。现在不再是需要使用`delarative_base`来创建一个基类。而是使用`db.Model`来作为基类。
2. 在模型类中，`Column`、`String`、`Integer`以及`relationship`等，都不需要导入了，直接使用`db`下面相应的属性名就可以了。
3. 在定义模型的时候，可以不写`__tablename__`，那么`flask_sqlalchemy`会默认使用当前的模型的名字转换成小写来作为表的名字，
并且如果这个模型的名字用到了多个单词并且使用了驼峰命名法，那么会在多个单词之间使用下划线来进行连接，
虽然flask_sqlalchemy给我们提供了这个特性，但是不推荐使用。（增强代码可读性，提高团队合作效率）
2.3 将ORM模型映射到数据库表
写完模型类后，要将模型映射到数据库的表中，使用以下代码即可
1. 删除数据库表：db.drop_all()
2. 创建数据库表：db.create_all()
2.4 session的使用
以后session也不需要使用`sessionmaker`来创建了，
直接使用`db.session`就可以了，
操作这个session的时候就跟之前的`sqlalchemy`的`session`是一样一样的。
2.5 添加数据
这时候就可以在数据库中看到已经生成了对应表了
添加数据和之前的没有区别，只是session成为了一个db的属性
2.6 查询数据：
1.单表查询
查询数据不再是之前的session.query方法了，而是将query属性放在了db.Model上，
所以查询就是通过“模型名.query”的方式进行查询了，`query`就跟之前的sqlalchemy中的query方法是一样用的。
2.多表查询
如果查找数据涉及多个模型，只能使用db.session.query(模型名).all() 这种方式
2.7 修改数据：
修改数据和之前的没有区别，只是session成为了一个db的属性
2.8 删除数据：
删除数据跟添加数据和修改数据类似，只不过session是db的一个属性而已
3.代码演示:
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
app.config['SQLALCHEMY_DATABASE_URI'] = DB_URI
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
#1.连接数据库
db = SQLAlchemy(app)
#2.创建ORM模型
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer,primary_key=True,autoincrement=True)
uname = db.Column(db.String(50),nullable=False)
def __repr__(self):
return "<User(uname: %s)>" % self.uname
class Article(db.Model):
__tablename__ = 'article'
id = db.Column(db.Integer,primary_key=True,autoincrement=True)
title = db.Column(db.String(50),nullable=False)
uid = db.Column(db.Integer,db.ForeignKey("user.id"))
author = db.relationship("User",backref="articles")
#3.删除表
db.drop_all()
#4.创建表
db.create_all()
#5.添加数据
user = User(uname='莫莫')
article = Article(title='华为5G 算法突破了，俄罗斯小伙突破的')
article.author = user
db.session.add(article)
db.session.commit()
#6.查询数据
# users = User.query.all() #等价于 db.session.query(User).all()
# print(users)
#在query属性之后 可以用 order_by 、 filter、filter_by、group_by、having等方法进行更复杂的单表查询
#若要进行更复杂的多表查询，只能使用db.session.query(User).all() 这种方式
#如 order_by
users = User.query.order_by(User.id.desc()).all()
print(users)
#7.修改数据
user = User.query.filter(User.uname=='露露').first()
user.uname = '探探'
db.session.commit()
#8.删除数据
user = User.query.filter(User.uname=='探探').first()
db.session.delete(user)
db.session.commit()
@app.route('/')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
app.run()
数据库迁移工具alembic介绍_alembic使用：
数据库迁移工具alembic介绍_alembic使用：
1.alembic介绍：
alembic是sqlalchemy的作者开发的，用来做OMR模型与数据库的迁移与映射，
alembic使用方式跟git有点了类似，
alembic的所有命令都是以alembic开头，
alembic的迁移文件也是通过版本进行控制的，
2.alembic安装：
pip install alembic
3.alembic使用：
1.使用sqlalchemy创建好模型类：
如创建一个models.py模块，然后在里面定义需要的模型类，代码如下：
from sqlalchemy import Column,String,Integer,create_engine
from sqlalchemy.ext.declarative import declarative_base
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'alembic_demo'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
uname = Column(String(50),nullable=False)
country = Column(String(50))
# ORM -> 迁移文件 -> 映射到数据库中
# import os
# print(os.path.dirname(__file__))
2. 使用alembic创建一个仓库（初始化仓库）：
1.打开dos系统界面
2.cd到当前项目目录中，注意：如果想要使用alembic，则需要先进入到安装了alembic的虚拟环境中，不然就找不到这个命令。
3.然后执行命令 “alembic init [仓库的名字，推荐使用alembic]”
3. 修改配置文件：
在`alembic.ini`中，给`sqlalchemy.url`项设置数据库的连接方式。方式跟sqlalchemy的方式是一样的。
sqlalchemy.url = driver://user:pass@localhost/dbname，
给`sqlalchemy.url`项设置数据库的连接操作为：
sqlalchemy.url = mysql+pymysql://root:root@localhost/alembic_demo?charset=utf8
为了使用模型类更新数据库，需要在`alembic/env.py`文件中设置target_metadata项，默认为target_metadata=None。
需要将`target_metadata`的值设置为模型`Base.metadata`，但是要导入`models`
使用sys模块和os模块把当前项目的路径导入到path中：
导入`models`的操作为：
import sys,os
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
import models
设置target_metadata项操作为：
target_metadata = models.Base.metadata
4.自动生成迁移文件：
使用alembic revision --autogenerate -m "提示信息"将当前模型中的状态生成迁移文件。
5.将生成的迁移文件映射到数据库中：
使用alembic upgrade head将刚刚生成的迁移文件，真正映射到数据库中。
同理，如果要降级，那么使用alembic downgrade head。
6. 以后如果修改了模型，重复4、5步骤。
4.常用alembic命令和参数解释：
1. init：创建一个alembic仓库。
2. revision：创建一个新的版本文件。
3. --autogenerate：自动将当前模型的修改，生成迁移脚本。
4. -m：本次迁移做了哪些修改，用户可以指定这个参数，方便回顾。
5. upgrade：将指定版本的迁移文件映射到数据库中，会执行版本文件中的upgrade函数。
如果有多个迁移脚本没有被映射到数据库中，那么会执行多个迁移脚本。
6. [head]：代表最新的迁移脚本的版本号。
7. downgrade：会执行指定版本的迁移文件中的downgrade函数。
8. heads：展示head指向的脚本文件版本号。
9. history：列出所有的迁移版本及其信息。
10. current：展示当前数据库中的版本号。
另外，在你第一次执行upgrade的时候，就会在数据库中创建一个名叫alembic_version表，这个表只会有一条数据，记录当前数据库映射的是哪个版本的迁移文件。
5.常见错误及解决办法：
1. 创建新版本时报错 FAILED: Target database is not up to date.
原因：主要是heads和current不相同。current落后于heads的版本。
解决办法：将current移动到head上。alembic upgrade head
2. 创建新版本时报错 KeyError: 'bb747b02cda0' 或者 FAILED: Can't locate revision identified by 'a65ff5195bc0'
原因：数据库中存的版本号不在迁移脚本文件中
解决办法：删除versions中所有的迁移文件，删除数据库所有表。
Flask-SQLAlchemy和alembic结合使用：
Flask-SQLAlchemy和alembic结合使用：
操作步骤如下：
1.配置好数据库连接文件 如config.py
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'fs_alembic_demo'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
SQLALCHEMY_DATABASE_URI = DB_URI
2.将config.py文件 结合flask项目主要运行文件 如momo.py
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
import config
app = Flask(__name__)
app.config.from_object(config)
db = SQLAlchemy(app)
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer,primary_key=True,autoincrement=True)
uname = db.Column(db.String(50),nullable=False)
age = db.Column(db.Integer)
gender=db.Column(db.String(2))
@app.route('/')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
app.run()
3.使用alembic创建一个仓库（初始化仓库）：
1.打开dos系统界面
2.cd到当前项目目录中，注意：如果想要使用alembic，则需要先进入到安装了alembic的虚拟环境中，不然就找不到这个命令。
3.然后执行命令 “alembic init [仓库的名字，推荐使用alembic]”
4.修改配置文件：
在`alembic.ini`中，给`sqlalchemy.url`项设置数据库的连接方式。方式跟sqlalchemy的方式是一样的。
sqlalchemy.url = driver://user:pass@localhost/dbname，
给`sqlalchemy.url`项设置数据库的连接操作为：
sqlalchemy.url = mysql+pymysql://root:root@localhost/fs_alembic_demo?charset=utf8
为了使用模型类更新数据库，需要在`alembic/env.py`文件中设置target_metadata项，默认为target_metadata=None。
需要将`target_metadata`的值设置为模型`Base.metadata`，但是要导入`momo`
使用sys模块和os模块把当前项目的路径导入到path中：
导入`momo`的操作为：
import sys,os
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
import momo
设置target_metadata项操作为：
target_metadata = momo.db.Model.metadata
5.自动生成迁移文件：
使用alembic revision --autogenerate -m "提示信息"将当前模型中的状态生成迁移文件。
6.将生成的迁移文件映射到数据库中：
使用alembic upgrade head将刚刚生成的迁移文件，真正映射到数据库中。
同理，如果要降级，那么使用alembic downgrade head。
7. 以后如果修改了模型，重复5、6步骤。
1.Flask-Script介绍：
1.Flask-Script介绍：
Flask-Script的作用是可以通过命令行的形式来操作Flask。
例如通过命令跑一个开发版本的服务器、设置数据库，定时任务等。
2.Flask-Script安装：
pip install flask-script
3.Flask-Script基本使用：
1. 看一个小例子，在flask项目中，建一个manage.py文件，代码如下：
from flask_script import Manager
from momo import app
manager = Manager(app)
#1.通过命令执行
@manager.command
def hello():
print('你好,hello')
if __name__ == '__main__':
manager.run()
其中的hello功能函数我们希望通过命令来运行，
然后在dos系统先进入装好Flask-Script的虚拟环境
运行python manage.py hello命令，就可以看hello函数已经执行了。
2. 再看一个例子，若执行命令脚本时，想传递某些参数过去，如下：
from flask_script import Manager
from momo import app
manager = Manager(app)
#2.通过命令执行 并要求传递参数
@manager.option("-p","--province",dest="province")
@manager.option("-m","--month",dest="month")
def get_pm_data(province,month):
print("您请求的省份是：%s，月份是：%s" % (province,month))
if __name__ == '__main__':
manager.run()
4.Flask-Script实战场景
老板要求给某员工快速建立一个后台账号。
分析：可通过命令执行 并传参的方式 将参数添加到数据库中
数据库连接config.py文件代码为：
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'flask_script_demo'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
SQLALCHEMY_DATABASE_URI = DB_URI
SQLALCHEMY_TRACK_MODIFICATIONS = False
主运行文件momo.py代码为：
from flask import Flask
#实战
from flask_sqlalchemy import SQLAlchemy
import config
app = Flask(__name__)
app.config.from_object(config)
db = SQLAlchemy(app)
class BackendUser(db.Model):
__tablename__ = 'backend_user'
id = db.Column(db.Integer,primary_key=True,autoincrement=True)
uname = db.Column(db.String(50),nullable=False)
email = db.Column(db.String(50),nullable=False)
db.create_all()
@app.route('/')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
app.run()
存放命令的脚本文件manage.py代码为：
from flask_script import Manager
from momo import app,BackendUser,db
manager = Manager(app)
#3.Flask-Script实战场景 ：老板要求给某员工快速建立一个后台账号
@manager.option("-u","--uname",dest="uname")
@manager.option("-e","--email",dest="email")
def add_user(uname,email):
user = BackendUser(uname=uname,email=email)
db.session.add(user)
db.session.commit()
print("添加OK")
if __name__ == '__main__':
manager.run()
5.写命令脚本技巧
如果有一些命令是针对某个功能的。
如有一堆命令是针对ORM与表映射的，那么可以将这些命令单独放在一个文件中方便管理。
然后到主脚本文件manage.py中，通过`Manager`的对象名.add_command`方法来添加。
如创建一个db_script.py文件 管理跟操作数据库表相关的东西，代码如：
from flask_script import Manager
db_manager = Manager()
@db_manager.command
def init():
print('迁移仓库创建OK！')
@db_manager.command
def revision():
print('迁移脚本文件生成OK！')
@db_manager.command
def upgrade():
print('迁移脚本文件映射到数据库OK！')
存放命令的脚本文件manage.py代码为：
from flask_script import Manager
from momo import app,BackendUser,db
manager = Manager(app)
#4.如果有一些命令是针对某个功能的。
# 比如有一堆命令是针对ORM与表映射的，那么可以将这些命令单独放在一个文件中方便管理。
# 也是使用`Manager`的对象来添加。然后到主manage文件中，通过`manager.add_command`来添加。
from db_script import db_manager
manager.add_command("db",db_manager)
if __name__ == '__main__':
manager.run()
Flask项目结构重构：
问题1：看图
config.py代码：
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'flask_migrate_demo'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI ="mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
SQLALCHEMY_DATABASE_URI = DB_URI
SQLALCHEMY_TRACK_MODIFICATIONS = False
app.py代码：
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
import config
app.config.from_object(config)
db = SQLAlchemy(app)
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
uname = db.Column(db.String(50), nullable=False)
@app.route('/')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
app.run()
结论1：
其实模型已经定义好了，也能用了，
但是一个项目会有很多的模型，不可能把所有模型都放 “app.py”文件中
一般会把模型放到一个专门的文件中 如：models.py文件
问题2：看图
按照结论1给出了处理方式
结论2：
项目启动运行报错，导入错误，import User失败
python语言的特点：不能循环双向引用
最终解决：看原理图
1.Flask-Migrate介绍：
在实际的开发环境中，经常会发生数据库修改的行为。一般我们修改数据库不会直接手动的去修改，而是去修改ORM对应的模型，然后再把模型映射到数据库中。这时候如果有一个工具能专门做这种事情，就显得非常有用了。
flask-migrate插件就是做这个事情的。flask-migrate是基于Alembic进行的一个封装，并集成到Flask中，所有的迁移操作其实都是Alembic做的，他能跟踪模型的变化，并将变化映射到数据库中。
2.Flask-Migrate安装：
pip install flask-migrate
3.项目结构图：
4.Flask-Migrate使用之manage.py文件中的代码：
from flask_script import Manager
from app import app
from exts import db
from flask_migrate import Migrate,MigrateCommand
#需要把映射到数据库中的模型导入到manage.py文件中
from models import User
manager = Manager(app)
#用来绑定app和db到flask-migrate的
Migrate(app,db)
#添加Migrate的所有子命令到db下
manager.add_command("db",MigrateCommand)
if __name__ == '__main__':
manager.run()
5.flask_migrate使用之常用命令：
1. 初始化一个环境：python manage.py db init
2. 自动检测模型，生成迁移脚本：python manage.py db migrate
3. 将迁移脚本映射到数据库中：python manage.py db upgrade
4. 更多命令：python manage.py db --help
6.flask_migrate使用之注意事项
#需要把映射到数据库中的模型导入到manage.py文件中，否则映射就不成功
from models import User
Graphql 的使用
注意问题
版本选择
graphql 版本 是2.0.1
graphene 2.0.1
graphql-core 2.3
graphql-relay 0.4.5
graphql-server-core 1.2.0
高版本报错
导包错误
选择低版本运行
什么是Graphql
GraphQL 是Facebook于 2012 年在内部开发的数据查询语言，在 2015 年开源。
其数据由服务器上的一个Scheme提供，其查询返回的数据依赖请求的时候用户需要的精确数据。
为什么使用Graphql
为什么使用Graphql
GraphQL和RESTful一样，都是一种网站架构，一种前后端通信规范，不涉及语言，不同语言有不同的实现方案。
GraphQL目前被认为是革命性的API工具，因为它可以让客户端在请求中指定希望得到的数据，而不像传统的RESTful那样只能呆板地在服务端进行预定义。
这样它就让前、后端团队的协作变得比以往更加的通畅，从而能够让组织更好地运作。
而实际上，GraphQL与RESTful都是基于HTTP进行数据的请求与接收，而且GraphQL也内置了很多RESTful模型的元素在里面。
那么在技术层面上，GraphQL和RESTful这两种API模型到底有什么异同呢？他们归根到底其实没多大区别，只不过GraphQL做了一些小改进，使得开发体验产生了较大的改变。
from graphene import Schema,ObjectType,String
class Query(ObjectType):
say = String()
def resolve_say(self,info):
return 'Hello GraphQL!!'
if __name__ == '__main__':
schema = Schema(query= Query)
query_string='''
{
say
}
'''
rs = schema.execute(query_string)
print(rs.data)
from flask import Flask
from flask_graphql import GraphQLView
import graphene
class Query(graphene.ObjectType):
hello = graphene.String()
def resolve_hello(self, info):
return 'Hello Flask GraphQL!!'
if __name__ == '__main__':
schema = graphene.Schema(query=Query)
app = Flask(__name__)
app.add_url_rule('/graphql', view_func=GraphQLView.as_view('grapql', schema=schema, graphiql=True))
app.run(debug=True)
import graphene
from flask import Flask
from flask_graphql import GraphQLView
class Query(graphene.ObjectType):
# me = graphene.String(name='my_info',sex=graphene.String(),desc=graphene.String(required=True))
me = graphene.String(
name='my_info',
sex=graphene.String(default_value="女"),
desc=graphene.String(required=True))
def resolve_me(self, info,sex,desc):
return f"sex:{sex},desc:{desc}"
if __name__ == '__main__':
schema = graphene.Schema(query=Query)
app = Flask(__name__)
app.add_url_rule('/graphql', view_func=GraphQLView.as_view('grapql', schema=schema, graphiql=True))
app.run(debug=True)
'''
name # 重名名
required
default_value
传递参数:
graphene.String(<参数名：参数类型>)
resolve_me(root,info,<参数名>)
'''
GraphQL VS RESTful
资源
RESTful的核心思想就是资源，每个资源都能用一个URL来表示，你能通过一个GET请求访问该URL从而获取该资源。
根据当今大多数API的定义，你得到一份JSON格式的数据响应，整个过程大概是这样：
GET /books/1
{
"title": "Python课程",
"author": {
"firstName": "尚学堂",
"lastName": "李老师"
}
// ... more fields here
}
注：上面的例子里的"author"也会作为一个单独的资源在其他RESTful API中被用到
需要注意的是，在RESTful中，一个资源的种类与你获取它的方式是耦合的。比如上面这个例子中的API就可以称之为“book端点”（book endpoint)。
在这一点上GraphQL就大为不同，因为在GraphQL里这两个概念是完全分离的。比如在你的schema定义中，你可能会有Book和Author两个类型（type）：
type Book {
id: ID
title: String
published: Date
price: String
author: Author
}
type Author {
id: ID
firstName: String
lastName: String
books: [Book]
}
注意这里我们虽然定义了数据类型，但却不知道该如何获取这些数据。
这是RESTful与GraphQL的一个核心差异：资源的描述信息与其获取方式相分离。
如果要去访问某个特定的book或者author资源，后端需要在schema中创建一个Query类型：
type Query {
book(id: ID!): Book
author(id: ID!): Author
}
然后，前端就可以像RESTful那样发送请求了：
GET /graphql?query={ book(id: "1") { title, author { firstName } } }
{
"title": "Python课程",
"author": {
"firstName": "尚学堂",
}
}
虽然都是通过请求某个URL来得到相同的响应，但这里我们已经看到GraphQL与RESTful的差异之处了。
首先，我们看到GraphQL的URL请求里面指定了我们所需要的资源以及在该资源中我们所关心的字段。
另外，我们是主动请求得到与book相关的author数据的，而不是服务端替我们决定的。
最重要的是，在请求中我们不需要关心资源的主键和资源之间的关系定义，我们可以通过除id以外的其他字段来获取到相同的Book资源。
相同点：
都有资源这个概念，而且都能通过ID去获取资源
都可以通过HTTP GET方式来获取资源
都可以使用JSON作为响应格式
差异点：
在RESTful中，你所访问的路径就是该资源的唯一标识（ID）；在GraphQL中，该标识与访问方式并不相关
在RESTful中，资源的返回结构与返回数量是由服务端决定；在GraphQL，服务端只负责定义哪些资源是可用的，由客户端自己决定需要得到什么资源
路由
一个具有可预见性的API才是好的API。
因为你通常会把一个API当做程序的一部分来使用，所以你必须要知道它需要接收什么参数并预期能够获取到什么样的结果。
这时候，对API的访问描述信息就显得很重要。通常我们会通过阅读API文档来获取信息，但通过GraphQL的Introspection机制、以及Swagger这样的RESTful API工具，这些信息就能可以自动获取到。
如今的RESTful API通常会由一系列的URL端点组成：
GET /books/:id
GET /authors/:id
GET /books/:id/comments
POST /books/:id/comments
你可以把这种API的形态称之为线性结构——因为这就是一个列表嘛。
当你要获取数据时，第一个事情就是搞清楚你要访问的是哪个端点。
而在GraphQL中——其实在上一节里你也看到了——可以通过查看GraphQL schema获得相关信息：
type Query {
book(id: ID!): Book
author(id: ID!): Author
}
type Mutation {
addComment(input: AddCommentInput): Comment
}
type Book { ... }
type Author { ... }
type Comment { ... }
input AddCommentInput { ... }
RESTful会使用类似GET、POST这样的动词去请求相同的URL来表示这到底是一个读操作还是写操作，而GraphQL会使用不同的预定义类型：Mutation和Query。
在GraphQL请求中，你可以通过不同的关键字进行不同的操作：
query { ... }
mutation { ... }
这里的Query类型定义与上面的RESTful路由是完全契合的，同样表示了数据的访问入口，因此这是GraphQL中最能与RESTful的URL端点所对应的概念。
如果是对资源的简单查询，GraphQL与RESTful是类似的，都是通过指定资源的名称以及相关参数来取得，但不同的是，你可以根据资源之间的关联关系来发起一个复杂请求，而在RESTful中你只能定义一些特殊的URL参数来获取到特殊的响应，或者是通过发起多个请求、再自行把响应得到的数据进行组装才行。
RESTful对数据的描述形式是一连串的URL端点，而GraphQL则是由相互之间有所关联的schema组成。 相同点：
RESTful API的URL端点列表与GraphQL的Query/Mutation中的字段类似，都表示数据的访问入口
都能用不同的方式描述一个API请求到底是读操作还是写操作
差异点：
GraphQL让你可以通过一个资源入口访问到关联的其他资源，只要事先在schema中定义好资源之间的关系即可；而RESTful则提供了多个URL端点来获取相关的资源
在GraphQL中，Query类型可以在一个请求的根节点中被访问，除此以外它跟其他类型没有区别，比如你也可以对一个query中的字段添加参数。而在RESTful中，即使响应结果是嵌套关系，但在请求中并没有嵌套的概念
RESTful使用POST这样的HTTP方法名称来定义写操作，GraphQL则是查询结构中的关键字
正因为上述的第一个点，人们通常会把Query类型中的字段称为GraphQL中的“端点”或“查询条件”。
虽然这是一个合理的解释，但同时也会对其他人造成误导，让人以为Query类型是一个非常特殊的类型。
路由处理器（Route Handlers）vs 解析器（Resolvers）
想象一下，当你调用一个API的时候，实际上会发生什么事情？
应该是在服务器上面执行了一些代码来处理这个请求，可能是进行了一些计算，可能从数据库中加载了一些数据，也可能是再次调用了一个别的API。
虽然总的来说，作为调用方你并不需要知道内部发生了什么事情，不过由于RESTful和GraphQL都提供了标准的API实现方法，我们可以通过对比来感受一下两者之间的差异。
为了突出重点，我会忽略掉一些构建服务用的过程代码。
首先实现一个 hello world：
class HelloWorld(Resource):
def get(self):
return {'say': 'hello world'}
api.add_resource(HelloWorld, '/hello')
这里我们得到了一个可以返回“world”这个字符串的/hello端点。从这个例子我们可以看到一个RESTful API请求的的生命周期：
服务器收到请求并提取出HTTP方法名（比如这里就是GET方法）与URL路径
API框架找到提前注册好的、请求路径与请求方法都匹配的代码
该段代码被执行，并得到相应结果
API框架对结果进行序列化，添加上适当的状态码与响应头后，返回给客户端
GraphQL差不多也是这样工作的，我们来看下这个对应的 hello world例子:
class Query(ObjectType):
"""定义一个字符串属性域hello"""
say = String()
def resolve_say(root,info):
return f'Hello World!'
我们看到，这里并没有针对某个URL路径提供函数，而是把Query类型中的hello字段映射到一个函数上了。
在GraphQL中这样的函数我们称之为解析器（Resolver）。
然后我们就可以这样发起一个查询：
query {
say
}
至此，总结一下服务器对一个GraphQL请求的执行过程：
服务器收到HTTP请求，取出其中的GraphQL查询
遍历查询语句，调用里面每个字段所对应的Resolver。在这个例子里，只有Query这个类型中的一个字段hello
Resolver函数被执行并返回相应结果
GraphQL框架把结果根据查询语句的要求进行组装
因此我们将会得到如下响应：
{ "say": "Hello world!" }
这里有个小技巧：我们其实可以多次调用同一个Resolver：
query {
say
secondSay: say
}
在这个例子中的生命周期跟上面的是类似的，但因为我们通过别名来两次请求了同一个字段，所以对应Resolver函数hello也会被执行两次。
虽然这个例子举得不是很好，不过这里主要想表达的是在一个请求中可以解析多个字段，即使是相同的字段也可以在查询的不同地方被多次访问。
再来看下“嵌套”解析器是怎样的：
{
Query: {
author: (root, { id }) => find(authors, { id: id }),
},
Author: {
posts: (author) => filter(posts, { authorId: author.id }),
},
}
这样的解析器可以处理如下查询请求：
query {
author(id: 1) {
firstName
posts {
title
}
}
}
即使解析器的结构是扁平的，但由于它们被不同的类型所引用，所以你还是可以利用它们来实现嵌套查询
上图形象地说明了使用RESTful和GraphQL进行多种资源获取的方式的差异
小结
总的来说，RESTful和GraphQL都提供了很好的API调用方式。如果你对如何构建一个RESTful API足够熟悉，使用GraphQL来实现同样的API功能对你来说并不是一件难事。但GraphQL的一大优势是让你可以在不需要发起多次请求的情况下调用多个函数来获取资源数据。
相同点：
RESTful的端点与GraphQL查询字段都在服务端调起函数执行
RESTful和GraphQL都使用框架和类库来进行一些通用的网络协议处理
差异点：
一个RESTful请求对应一个路由处理器（Route Handler）；而一个GraphQL的请求可以唤起多个解析器（Resolver）在一次响应中访问多种资源
RESTful需要你自己构建整个请求的响应；而GraphQL的请求响应是由查询方指定结构、并由GraphQL进行构建组装的
你可以把GraphQL理解为一个可以在一次请求中进行多个端点调用的系统，差不多算是RESTful的多路复用版。
总的主要的不同点就是：
RESTful一个接口只能返回一个资源，GraphQL一个可以获取多个资源。
RESTful用不同的URL来区分资源，GraphQL用类型区分资源。
02_Python使用GraphQL
Graphene
Graphene是一个提供在Python中实现GraphQL API的工具的库
Graphene具有与最流行的Web框架和ORM集成的全部功能。Graphene生成的方案完全符合GraphQL规范，并提供了用于构建符合中继标准的API的工具和模式。
安装
Python (2.7, 3.4, 3.5, 3.6, pypy)
Graphene (2.0)
第一个程序-HelloWorld
第一个程序-HelloWorld
from graphene import ObjectType, String, Schema
class Query(ObjectType):
"""定义一个字符串属性域hello"""
hello = String()
def resolve_hello(root,info):
return f'Hello World!'
schema = Schema(query=Query)
if __name__ == '__main__':
query_string = '''
{
hello
}
'''
result = schema.execute(query_string)
print(result.data)
属性
name
required
default_value
from graphene import ObjectType, String, Schema
class Query(ObjectType):
"""定义一个字符串属性域hello"""
hello = String(name = 'text',sex=String(default_value="man"),desc = String(required = True))
def resolve_hello(root,resolve,sex,desc = 'python'):
return f'Hello World! sex：{sex} desc: {desc}'
schema = Schema(query=Query)
if __name__ == '__main__':
query_string = '''
{
text(desc:"graphql")
}
'''
result = schema.execute(query_string)
print(result.data)
数据类型
数据类型
graphene.String
graphene.Int
graphene.Float
graphene.Boolean
graphene.ID
import graphene
from flask import Flask
from flask_graphql import GraphQLView
import datetime
import decimal
class Query(graphene.ObjectType):
str_ = graphene.String()
int_ = graphene.Int()
float_ = graphene.Float()
boolean_ = graphene.Float()
id_ = graphene.ID()
data_ = graphene.Date()
time_ = graphene.Time()
dateTime = graphene.DateTime()
decimal_ = graphene.Decimal()
def resolve_str(self, info):
return 'hello'
def resolve_int_(self, info):
return 1
def resolve_float_(self, info):
return 1.1
def resolve_boolean_(self, info):
return True
def resolve_id(self, info):
return 2
def resolve_data_(self, info):
return datetime.date(2022,1,2)
def resolve_time_(self, info):
return datetime.time(hour=13,minute=24,second=30)
def resolve_dateTime(self, info):
return datetime.datetime(2022,1,1,13,14,20)
def resolve_decimal_(self, info):
return decimal.Decimal("13.14")
json_ = graphene.JSONString()
def resolve_json_(self,info):
return {'name':"zhangsan"}
if __name__ == '__main__':
schema = graphene.Schema(query=Query)
app = Flask(__name__)
app.add_url_rule('/graphql', view_func=GraphQLView.as_view('grapql', schema=schema, graphiql=True))
app.run(debug=True)
graphene.Date
import datetime
from graphene import Schema, ObjectType, Date
class Query(ObjectType):
one_week_from = Date(required=True, date_input=Date(required=True))
def resolve_one_week_from(root, info, date_input):
assert date_input == datetime.date(2050, 1, 2)
return date_input + datetime.timedelta(weeks=1)
schema = Schema(query=Query)
results = schema.execute("""
query {
oneWeekFrom(dateInput: "2050-01-02")
}
""")
assert results.data == {"oneWeekFrom": "2050-01-09"}
graphene.DateTime
import datetime
from graphene import Schema, ObjectType, DateTime
class Query(ObjectType):
one_hour_from = DateTime(required=True, datetime_input=DateTime(required=True))
def resolve_one_hour_from(root, info, datetime_input):
assert datetime_input == datetime.datetime(2050, 1, 2, 3, 4, 5)
return datetime_input + datetime.timedelta(hours=1)
schema = Schema(query=Query)
results = schema.execute("""
query {
oneHourFrom(datetimeInput: "2050-01-02T15:04:05")
}
""")
assert results.data == {"oneHourFrom": "2050-01-02T16:04:05"}
graphene.Time
import datetime
from graphene import Schema, ObjectType, Time
class Query(ObjectType):
one_hour_from = Time(required=True, time_input=Time(required=True))
def resolve_one_hour_from(root, info, time_input):
assert time_input == datetime.time(15, 4, 5)
tmp_time_input = datetime.datetime.combine(datetime.date(1, 1, 1), time_input)
return (tmp_time_input + datetime.timedelta(hours=1)).time()
schema = Schema(query=Query)
results = schema.execute("""
query {
oneHourFrom(timeInput: "15:04:05")
}
""")
assert results.data == {"oneHourFrom": "16:04:05"}
graphene.Decimal
import decimal
from graphene import Schema, ObjectType, Decimal
class Query(ObjectType):
add_one_to = Decimal(required=True, decimal_input=Decimal(required=True))
def resolve_add_one_to(root, info, decimal_input):
assert decimal_input == decimal.Decimal("10.50")
return decimal_input + decimal.Decimal("1")
schema = Schema(query=Query)
results = schema.execute("""
query {
addOneTo(decimalInput: "10.50")
}
""")
assert results.data == {"addOneTo": "11.50"}
graphene.JSONString
from graphene import Schema, ObjectType, JSONString, String
class Query(ObjectType):
update_json_key = JSONString(
required=True,
json_input=JSONString(required=True),
key=String(required=True),
value=String(required=True)
)
def resolve_update_json_key(root, info, json_input, key, value):
assert json_input == {"name": "Jane"}
json_input[key] = value
return json_input
schema = Schema(query=Query)
results = schema.execute("""
query {
updateJsonKey(jsonInput: "{\\"name\\": \\"Jane\\"}", key: "name", value: "Beth")
}
""")
assert results.data == {"updateJsonKey": "{\"name\": \"Beth\"}"}
数据返回不可能为空
import graphene
from flask_graphql import GraphQLView
from flask import Flask
class Query(graphene.ObjectType):
uname = graphene.NonNull(graphene.String) #
user_name = graphene.String(required = True)
score = graphene.List(graphene.Int) #
score_list = graphene.List(graphene.NonNull(graphene.String))
score_list2 = graphene.NonNull(graphene.List(graphene.Int))
person = graphene.Field(Person)
def resolve_uname(root,resolve):
return 'test1'
def resolve_user_name(root,resolve):
return 'test'
def resolve_score(root,resolve):
return [90,95]
def resolve_score_list(root,resolve):
return [1,2]
def resolve_score_list2(root,resolve):
return [1]
if __name__ == '__main__':
schema = graphene.Schema(query=Query)
app = Flask(__name__)
app.add_url_rule('/graphql', view_func=GraphQLView.as_view('graphql',
schema=schema, graphiql=True))
app.run(debug=True)
自定义数据类型
import graphene
from flask_graphql import GraphQLView
from flask import Flask
class Person(graphene.ObjectType):
first_name = graphene.String()
last_name = graphene.String()
class Query(graphene.ObjectType):
person = graphene.Field(Person)
person2 = graphene.Field(Person)
persons = graphene.List(Person)
def resolve_person(self,info):
return {"first_name": "R2", "last_name": "D2"}
def resolve_person2(self,info):
return Person(first_name="Luke", last_name="Skywalker")
def resolve_persons(self,info):
return [
Person(first_name='Sxt',last_name = 'Mr.li'),
Person(first_name='Sxt',last_name = 'Mr.Gao'),
]
if __name__ == '__main__':
schema = graphene.Schema(query=Query)
app = Flask(__name__)
app.add_url_rule('/graphql', view_func=GraphQLView.as_view('graphql',
schema=schema, graphiql=True))
app.run(debug=True)
接口的使用
import graphene
from flask_graphql import GraphQLView
from flask import Flask
class Animal(graphene.Interface):
id = graphene.ID(required=True)
name = graphene.String(required=True)
class Mouse(graphene.ObjectType):
class Meta:
interfaces = (Animal, )
run = graphene.String()
class Bird(graphene.ObjectType):
class Meta:
interfaces = (Animal, )
fly = graphene.String()
class Query(graphene.ObjectType):
mouse = graphene.Field(Mouse)
bird = graphene.Field(Bird)
animal = graphene.Field(Animal,type_ = graphene.Int(required= True))
def resolve_mouse(root, info):
return {'id':1,'name':'杰瑞','run':'跑呀~汤姆来啦！'}
def resolve_bird(root,info):
return {'id':1,'name':'鹦鹉','run':'飞呀~杰瑞来啦！'}
def resolve_animal(root,info,type_):
if type_ == 1:
return Mouse(id=1,name='杰瑞',run='跑呀~汤姆来啦！')
elif type_ == 2:
return Bird(id=1,name='鹦鹉',fly='飞呀~汤姆来啦！')
else:
return Mouse(id=1,name='杰瑞',run='跑呀~斯派克来啦！')
if __name__ == '__main__':
schema = graphene.Schema(query=Query)
app = Flask(__name__)
app.add_url_rule('/graphql', view_func=GraphQLView.as_view('graphql',
schema=schema, graphiql=True))
app.run(debug=True)
枚举
import graphene
from flask_graphql import GraphQLView
from flask import Flask
class Role(graphene.Enum):
JR = 1
TM = 2
SPK = 3
class Animal(graphene.Interface):
id = graphene.ID(required=True)
name = graphene.String(required=True)
class Mouse(graphene.ObjectType):
class Meta:
interfaces = (Animal, )
run = graphene.String()
class Bird(graphene.ObjectType):
class Meta:
interfaces = (Animal, )
fly = graphene.String()
class Query(graphene.ObjectType):
mouse = graphene.Field(Mouse)
bird = graphene.Field(Bird)
animal = graphene.Field(Animal,role = Role())
def resolve_mouse(root, info):
return {'id':1,'name':'杰瑞','run':'跑呀~汤姆来啦！'}
def resolve_bird(root,info):
return {'id':1,'name':'鹦鹉','run':'飞呀~杰瑞来啦！'}
def resolve_animal(root,info,role):
if role == Role.JR:
return Mouse(id=1,name='杰瑞',run='跑呀~汤姆来啦！')
elif role == Role.TM:
return Bird(id=2,name='鹦鹉',fly='飞呀~汤姆来啦！')
else:
return Mouse(id=3,name='杰瑞',run='跑呀~斯派克来啦！')
if __name__ == '__main__':
schema = graphene.Schema(query=Query)
app = Flask(__name__)
app.add_url_rule('/graphql', view_func=GraphQLView.as_view('graphql',
schema=schema, graphiql=True))
app.run(debug=True)
GraphQL查询
服务端
human_data = {}
droid_data = {}
'''
===================== data =========================
'''
def setup():
global human_data, droid_data
luke = Human(
id="1000",
name="Luke Skywalker",
friends=["1002", "1003", "2000", "2001"],
appears_in=[4, 5, 6],
home_planet="Tatooine",
)
vader = Human(
id="1001",
name="Darth Vader",
friends=["1004"],
appears_in=[4, 5, 6],
home_planet="Tatooine",
)
han = Human(
id="1002",
name="Han Solo",
friends=["1000", "1003", "2001"],
appears_in=[4, 5, 6],
home_planet=None,
)
leia = Human(
id="1003",
name="Leia Organa",
friends=["1000", "1002", "2000", "2001"],
appears_in=[4, 5, 6],
home_planet="Alderaan",
)
tarkin = Human(
id="1004",
name="Wilhuff Tarkin",
friends=["1001"],
appears_in=[4],
home_planet=None,
)
human_data = {
"1000": luke,
"1001": vader,
"1002": han,
"1003": leia,
"1004": tarkin,
}
c3po = Droid(
id="2000",
name="C-3PO",
friends=["1000", "1002", "1003", "2001"],
appears_in=[4, 5, 6],
primary_function="Protocol",
)
r2d2 = Droid(
id="2001",
name="R2-D2",
friends=["1000", "1002", "1003"],
appears_in=[4, 5, 6],
primary_function="Astromech",
)
droid_data = {"2000": c3po, "2001": r2d2}
def get_character(id):
return human_data.get(id) or droid_data.get(id)
def get_friends(character):
return map(get_character, character.friends)
def get_hero(episode):
if episode == 5:
return human_data["1000"]
return droid_data["2001"]
def get_human(id):
return human_data.get(id)
def get_droid(id):
return droid_data.get(id)
'''
===================== schema =========================
'''
import graphene
from flask_graphql import GraphQLView
from flask import Flask
class Episode(graphene.Enum): # 剧集
NEWHOPE = 4 # 星球大战4 新希望
EMPIRE = 5 # 黑金帝国
JEDI = 6 # 星球大战 绝地
class Character(graphene.Interface): # 角色
id = graphene.ID()
name = graphene.String()
friends = graphene.List(lambda: Character)
appears_in = graphene.List(Episode) # 出演
def resolve_friends(self, info):
# The character friends is a list of strings
return [get_character(f) for f in self.friends]
class Human(graphene.ObjectType): # 人类
class Meta:
interfaces = (Character,)
home_planet = graphene.String() # 地球家园
class Droid(graphene.ObjectType): # 机器人
class Meta:
interfaces = (Character,)
primary_function = graphene.String() # 主要功能
class Query(graphene.ObjectType):
hero = graphene.Field(Character, episode=Episode())
human = graphene.Field(Human, id=graphene.String())
droid = graphene.Field(Droid, id=graphene.String())
def resolve_hero(root, info, episode=None):
return get_hero(episode)
def resolve_human(root, info, id):
return get_human(id)
def resolve_droid(root, info, id):
return get_droid(id)
if __name__ == '__main__':
setup()
schema = graphene.Schema(query=Query)
app = Flask(__name__)
app.add_url_rule('/graphql',
view_func=GraphQLView.as_view('graphql',schema=schema, graphiql=True))
app.run(debug=True)
查询
# select name from table1 t1 left join table2 t2 on t1.id == t2.id ;
{
hero {
name
friends {
name
}
}
}
# select name from table1 where id = '??';
{
human(id:"1002"){
name
appearsIn
}
}
# select name as n1 name as n2 from table1
{
h1: human(id:"1002"){
name
}
h2: human(id:"1003"){
name
}
}
# 字段复用
{
h1: human(id:"1002"){
...heroFields
}
h2: human(id:"1003"){
...heroFields
}
}
fragment heroFields on Character{
id
name
friends {
id
name
}
}
# 设置查询名称
query queryHero{
h1: human(id:"1002"){
...heroFields
}
h2: human(id:"1003"){
...heroFields
}
}
# 接口子类专属属性查询
{animal(type_:1) {
id,
name,
... on Mouse{
run
}
... on Bird{
fly
}
}}
# 参数输入
query queryHero($id:String!){
h1: human(id:$id){
name
id
}
}
{
"id": "1002"
}
数据的增删改操作
增加
import graphene
from flask_graphql import GraphQLView
from flask import Flask
users = []
class Person(graphene.ObjectType):
name = graphene.String()
age = graphene.Int()
# 1
class CreatePerson(graphene.Mutation):
person = graphene.Field(Person)
# 2
class Arguments:
name = graphene.String()
age = graphene.Int()
# 3
def mutate(self, info, name, age):
person = Person(name=name, age=age)
users.append(person)
return CreatePerson(person = person)
# 4
class Mutation(graphene.ObjectType):
create_person = CreatePerson.Field()
class Query(graphene.ObjectType):
persons = graphene.List(Person)
def resolve_persons(self,info):
return users
if __name__ == '__main__':
schema = graphene.Schema(query=Query, mutation=Mutation)
app = Flask(__name__)
app.add_url_rule('/graphql',
view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=True))
app.run(debug=True)
修改与删除
import graphene
from flask_graphql import GraphQLView
from flask import Flask
class Person(graphene.ObjectType):
name = graphene.String(required = True)
age = graphene.Int()
users = [
Person(name='zs',age=18),
Person(name='ls',age=20),
]
# 1
class UpdatePerson(graphene.Mutation):
person = graphene.Field(Person)
msg = graphene.String()
# 2
class Arguments:
name = graphene.String()
age = graphene.Int()
# 3
def mutate(self, info, name, age):
for p in users:
if p.name == name:
p.age = age
return UpdatePerson(person = p,msg ="success")
return UpdatePerson(msg = 'fail')
# 4
class DeletePerson(graphene.Mutation):
person = graphene.Field(Person)
msg = graphene.String()
# 2
class Arguments:
name = graphene.String()
age = graphene.Int()
# 3
def mutate(self, info, name):
for p in users:
if p.name == name:
users.remove(p)
return UpdatePerson(person = p,msg ="success")
return UpdatePerson(msg = 'fail')
class Mutation(graphene.ObjectType):
update_person = UpdatePerson.Field()
delete_person = DeletePerson.Field()
class Query(graphene.ObjectType):
persons = graphene.List(Person)
def resolve_persons(self,info):
return users
'''
mutation update{
updatePerson(name:"zs",age:16){
person{
name
age
}
msg
}
}
mutation delete{
deletePerson(name:"ls"){
person {
name
age
}
msg
}
}
query select{
persons{
name
age
}
}
'''
if __name__ == '__main__':
schema = graphene.Schema(query=Query, mutation=Mutation)
app = Flask(__name__)
app.add_url_rule('/graphql',
view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=True))
app.run(debug=True)
原生SQL执行
import pymysql
import graphene
from flask_graphql import GraphQLView
from flask import Flask
def get_conn():
client = pymysql.connect(host='192.168.30.151',port=3306,user='root',passwd='123',db='graphql',charset='utf8')
cursor = client.cursor()
return client,cursor
class Person(graphene.ObjectType):
id = graphene.ID()
name = graphene.String()
age = graphene.Int()
class DataInput(graphene.InputObjectType):
name = graphene.String()
age = graphene.Int()
class CreatePerson(graphene.Mutation):
person = graphene.Field(Person)
class Arguments:
name = graphene.String()
age = graphene.Int()
def mutate(self, info, name, age):
sql = 'insert into t_user values (%s,%s)'
c1,c2 = get_conn()
c2.execute(sql,[name,age])
c1.commit()
c2.close()
c1.close()
return CreatePerson(person = Person(name=name,age=age))
class UpdatePerson(graphene.Mutation):
person = graphene.Field(Person)
msg = graphene.String()
class Arguments:
p1 = DataInput(required=True)
def mutate(self, info, name, age):
try:
sql = 'update t_user set age = %s where name = %s'
c1,c2 = get_conn()
c2.execute(sql,[name,age])
c1.commit()
c2.close()
c1.close()
return UpdatePerson(person = p,msg ="success")
except Exception as e:
return UpdatePerson(msg = 'fail')
class DeletePerson(graphene.Mutation):
person = graphene.Field(Person)
msg = graphene.String()
class Arguments:
p1 = DataInput(required=True)
def mutate(self, info, name):
try:
sql = 'delete from t_user where name = %s'
c1,c2 = get_conn()
c2.execute(sql,[name,age])
c1.commit()
c2.close()
c1.close()
return UpdatePerson(person = p,msg ="success")
except Exception as e:
return UpdatePerson(msg = 'fail')
class Mutation(graphene.ObjectType):
create_person = CreatePerson.Field()
update_person = UpdatePerson.Field()
delete_person = DeletePerson.Field()
class Query(graphene.ObjectType):
persons = graphene.List(Person)
def resolve_persons(self,info):
return users
if __name__ == '__main__':
schema = graphene.Schema(query=Query, mutation=Mutation)
app = Flask(__name__)
app.add_url_rule('/graphql',
view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=True))
app.run(debug=True)
SqlAchemy的使用
安装
pip install "graphene-sqlalchemy>=2.0"
官网：
https://github.com/graphql-python/graphene-sqlalchemy
Tip 传递的数据需要 base64 加密
berfore after id:model:id
import graphene
from flask_graphql import GraphQLView
from flask import Flask
from sqlalchemy import create_engine,Column,Integer,String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import scoped_session, sessionmaker
from graphene_sqlalchemy import SQLAlchemyConnectionField, SQLAlchemyObjectType
from uuid import uuid4
engine = create_engine('sqlite:///graphql.sqlite3')
db_session = scoped_session(sessionmaker(autocommit=False,
autoflush=False,
bind=engine))
Base = declarative_base()
Base.query = db_session.query_property()
class EmployeeModel(Base):
__tablename__ = 't_employee'
# id = Column(Integer, primary_key=True)
id = Column(String(128),primary_key=True)
name = Column(String)
class Employee(SQLAlchemyObjectType):
class Meta:
model = EmployeeModel
interfaces = (graphene.relay.Node, )
class Query(graphene.ObjectType):
emps = graphene.List(Employee)
emp = graphene.Field(Employee,id = graphene.String())
node = graphene.relay.Node.Field()
employees = SQLAlchemyConnectionField(Employee.connection)
def resolve_emps(self, info):
query = Employee.get_query(info) # SQLAlchemy query
return query.all()
def resolve_emp(self,info,id):
return Employee.get_node(info =info ,id = id)
class CreateEmp(graphene.Mutation):
emp = graphene.Field(Employee)
msg = graphene.Field(graphene.String)
class Arguments:
ida = graphene.String()
names = graphene.String()
def mutate(self, info, ida, names):
e = EmployeeModel(id = ida,name = names)
db_session.add(e)
db_session.commit()
return CreateEmp(emp = e,msg ="success")
class Mutation(graphene.ObjectType):
create_emp = CreateEmp.Field()
# 2
if __name__ == '__main__':
schema = graphene.Schema(query=Query,mutation= Mutation)
app = Flask(__name__)
app.add_url_rule('/graphql',
view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=True))
app.run(debug=True)
'''
query q1{
emps {
id
name
}
emp(id:"425e0096c2814826a562d13c65132c58") {
id
name
}
}
mutation ca {
createEmp(ida:"aaa",names:"c1") {
msg
emp{
id,
name
}
}
}
'''
'''
query{
node(id:"RW1wbG95ZWU6YWFh") { mode:id
id
...on Employee{
id
name
}
}
}
'''
