Flask学习
Flask
Flask诞生于2010年，是Armin ronacher（人名）用 Python 语言基于 Werkzeug 工具箱编写的轻量级Web开发框架。
Flask 本身相当于一个内核，其他几乎所有的功能都要用到扩展（邮件扩展Flask-Mail，用户认证Flask-Login，数据库Flask-SQLAlchemy），都需要用第三方的扩展来实现。比如可以用 Flask 扩展加入ORM、窗体验证工具，文件上传、身份验证等。Flask 没有默认使用的数据库，你可以选择 MySQL，也可以用 NoSQL。
其 WSGI 工具箱采用 Werkzeug（路由模块），模板引擎则使用 Jinja2。这两个也是 Flask 框架的核心。
官网: https://flask.palletsprojects.com/en/1.1.x/
官方文档: http://docs.jinkan.org/docs/flask/
Flask常用第三方扩展包：
- Flask-SQLalchemy：操作数据库,ORM；
- Flask-script：终端脚本工具，脚手架；
- Flask-migrate：管理迁移数据库；
- Flask-Session：Session存储方式指定；
- Flask-WTF：表单；
- Flask-Mail：邮件；
- Flask-Bable：提供国际化和本地化支持，翻译；
- Flask-Login：认证用户状态；
- Flask-OpenID：认证, OAuth；
- Flask-RESTful：开发REST API的工具；
- Flask JSON-RPC: 开发rpc远程服务[过程]调用
- Flask-Bootstrap：集成前端Twitter Bootstrap框架
- Flask-Moment：本地化日期和时间
- Flask-Admin：简单而可扩展的管理接口的框架
可以通过 https://pypi.org/search/?c=Framework+%3A%3A+Flask 查看更多flask官方推荐的扩展
准备安装
mkvirtualenv flask -p python3
pip install flask==0.12.5
创建flask项目
与django不同,flask不会提供任何的自动操作,所以需要手动创建项目目录,需要手动创建启动项目的管理文件
例如,创建项目目录 flaskdemo,在目录中创建manage.py.在pycharm中打开项目并指定上面创建的虚拟环境
创建一个flask框架的主程序。名字可以是app.py/run.py/main.py/index.py
from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
return 'Hello World'
if __name__ == '__main__':
app.run()
代码分析:
# 导入Flask类
from flask import Flask
"""
import_name Flask程序所在的包(模块)，传 __name__ 就可以
其可以决定 Flask 在访问静态文件时查找的路径
static_path 静态文件访问路径(不推荐使用，使用 static_url_path 代替)
static_url_path 静态文件访问路径，可以不传，默认为：/ + static_folder
static_folder 静态文件存储的文件夹，可以不传，默认为 static
template_folder 模板文件存储的文件夹，可以不传，默认为 templates
"""
app = Flask(import_name=__name__)
# 编写路由视图
# flask的路由是通过给视图添加装饰器的方式进行编写的。当然也可以分离到另一个文件中。
# flask的视图函数，flask中默认允许通过return返回html格式数据给客户端。
@app.route('/')
def index():
return "<h1>hello world</h1>"
# 加载项目配置
class Config(object):
# 开启调试模式
DEBUG = True
# flask中支持多种配置方式，通过app.config来进行加载，我们会这里常用的是配置类
app.config.from_object( Config )
# 指定服务器IP和端口
if __name__ == '__main__':
# 运行flask
app.run(host="0.0.0.0", port=5000)
路由的基本定义
路由和视图的名称必须全局唯一，不能出现重复，否则报错。
# 指定访问路径为 demo1
@app.route('/demo1')
def demo1():
return 'demo1'
url中可以传递路由参数, 2种方式
路由参数就是url路径的一部分。
任意路由参数接收
# 路由传递参数[没有限定类型]
@app.route('/user/<user_id>')
def user_info(user_id):
return 'hello %s' % user_id
限定路由参数接收
通过路由转换器限定路由参数的类型，flask系统自带转换器编写在werkzeug.routing.py文件中。底部可以看到以下字典：
DEFAULT_CONVERTERS = {
"default": UnicodeConverter,
"string": UnicodeConverter,
"any": AnyConverter,
"path": PathConverter,
"int": IntegerConverter,
"float": FloatConverter,
"uuid": UUIDConverter,
}
系统自带的转换器具体使用方式在每种转换器的注释代码中有写，请留意每种转换器初始化的参数。
转换器名称 描述
string 默认类型，接受不带斜杠的任何文本
int 接受正整数
float 接受正浮点值
path 接收string但也接受斜线
uuid 接受UUID（通用唯一识别码）字符串 xxxx-xxxx-xxxxx-xxxxx
代码：
# flask提供了路由转换器可以让我们对路由参数进行限定
# 路由传递参数[限定数据类型]
@app.route('/user/<int:user_id>')
def user_info(user_id):
return 'hello %d' % user_id
自定义路由参数转换器
也叫正则匹配路由参数.
在 web 开发中，可能会出现限制用户访问规则的场景，那么这个时候就需要用到正则匹配，根据自己的规则去限定请求参数再进行访问
具体实现步骤为：
- 导入转换器基类：在 Flask 中，所有的路由的匹配规则都是使用转换器对象进行记录
- 自定义转换器：自定义类继承于转换器基类
- 添加转换器到默认的转换器字典中
- 使用自定义转换器实现自定义匹配规则
代码实现
-
导入转换器基类
from werkzeug.routing import BaseConverter
-
自定义转换器
自定义正则转换器
from werkzeug.routing import BaseConverter
class RegexConverter(BaseConverter):
def init(self,map,*args):
super().init(map)
正则参数
self.regex = args[0] -
添加转换器到默认的转换器字典中，并指定转换器使用时名字为: re
将自定义转换器添加到转换器字典中，并指定转换器使用时名字为: re
app.url_map.converters['re'] = RegexConverter -
使用转换器去实现自定义匹配规则
-
当前此处定义的规则是：手机号码
正则匹配路由
@app.route("/login/<re('1\d{10}'):mobile>")
def login(mobile):
return mobile
-
运行测试：http://127.0.0.1:5000/login/1311111111 ，如果访问的url不符合规则，会提示找不到页面课堂代码：
from flask import Flask,request
初始化
app = Flask(import_name=__name__)
编写路由视图
@app.route(rule='/')
def index():
return "<h1>hello world!</h1>"
# 关于路由参数的限制，flask内置的类型不够具体，在开发中，我们经常接受参数，需要更加精确的限制
# 这时候，可以使用正则匹配路由参数
# 正则匹配路由参数，其实就是扩展flask内置的路由限定类型，需要完成4个步骤
# 1. 引入flask的路由转换器
from werkzeug.routing import BaseConverter
# 2. 创建自定义路由转换器
class MobileConverter(BaseConverter):
"""手机号码类型限制"""
def __init__(self,map,*args):
super().__init__(map)
self.regex = "1[3-9]\d{9}"
# 3. 把自定义转换器添加到flask默认的转换器字典中，也就是和原来的int,float等放在一块
app.url_map.converters['mob'] = MobileConverter
# 4. 类似原来的路由参数限制一样，调用自定义转换器名称即可
@app.route(rule='/user/<mob:mobile>')
def user(mobile):
return mobile
# 1. 引入flask的路由转换器
from werkzeug.routing import BaseConverter
# 2. 创建自定义路由转换器
class RegexConverter(BaseConverter):
"""根据正则进行参数限制"""
def __init__(self,map,*args):
super().__init__(map)
self.regex = args[0]
# 3. 把自定义转换器添加到flask默认的转换器字典中，也就是和原来的int,float等放在一块
app.url_map.converters['re'] = RegexConverter
# 4. 类似原来的路由参数限制一样，调用自定义转换器名称即可
@app.route(rule='/user/<re("\w+@\w+\.\w+"):email>')
def user2(email):
print(app.url_map) # 获取所有的路由列表
return email
# 声明和加载配置
class Config():
DEBUG = True
app.config.from_object(Config)
if __name__ == '__main__':
# 运行flask
app.run(host="0.0.0.0")
路由限定请求方式
from flask import Flask,request
# 限制客户端的http请求方法，注意这里与django不一样，flask并没有默认没有内置csrf攻击防范
@app.route(rule="/user", methods=["post","put","get","delete","patch"])
def user():
# 例如:地址栏中通过 http://127.0.0.1:5000/user?user=1 返回本视图
print(request.method) # 获取本次客户端的http请求方法 GET
print(request.query_string) # 获取本次客户端的查询字符串 b'user=1'
print(request.path) # 获取本次客户端请求的路由路径部分[去掉域名端口] /user
print(request.url) # 获取本次客户端请求的http url地址 http://127.0.0.1:5000/user?user=1
# 直接从请求中取到请求方式并返回
return request.method
http的请求与响应
请求
文档: http://docs.jinkan.org/docs/flask/api.html#flask.request
- request：flask中代表当前请求的 request 对象
- 作用：在视图函数中取出本次请求数据
- 导入：from flask import request
- 代码位置：from flask.app import Request
常用的属性如下：
属性 说明 类型
data 记录请求体的数据，并转换为字符串
只要是通过其他属性无法识别转换的请求体数据
最终都是保留到data属性中 bytes类型
form 记录请求中的html表单数据 MultiDict
args 记录请求中的查询字符串,也可以是query_string MultiDict
cookies 记录请求中的cookie信息 Dict
headers 记录请求中的请求头 EnvironHeaders
method 记录请求使用的HTTP方法 GET/POST
url 记录请求的URL地址 string
files 记录请求上传的文件列表 *
json 记录ajax请求的json数据 json
获取请求中各项数据
from flask import Flask,request
# 初始化
app = Flask(import_name=__name__)
# 编写路由视图
@app.route(rule='/')
def index():
return "<h1>hello world!</h1>"
"""== 获取查询字符串 =="""
@app.route(rule="/args",methods=["post","get"])
def args():
print(request.args) # 获取查询字符串
"""
请求地址：
http://127.0.0.1:5000/args?name=xiaoming&password=123&lve=swimming&lve=shopping
打印效果：
ImmutableMultiDict([('name', 'xiaoming'), ('password', '123')])
ImmutableMultiDict是一个由flask封装的字典类，在字典的基础上，提供了一些其他的方法而已。
格式：
ImmutableMultiDict([('键', '值'), ('键', '值')])
字典本身不支持同名键的，ImmutableMultiDict类解决了键同名问题
操作ImmutableMultiDict，完全可以操作字典操作，同时还提供了get，getlist方法，获取指定键的1个值或多个值
to_dict()
ti_list()
"""
print(request.args["name"]) # xiaoming
print(request.args.get("name")) # xiaoming
print(request.args.getlist("lve")) # ['swimming', 'shopping']
# 把ImmutableMultiDict转换成普通字典
print(request.args.to_dict(flat=False)) # {'name': ['xiaoming'], 'password': ['123'], 'lve': ['swimming', 'shopping']}
print(request.args.to_dict(flat=True)) # {'name': 'xiaoming', 'password': '123', 'lve': 'swimming'}
return "ok"
"""== 获取请求体数据 =="""
@app.route(rule="/data",methods=["post","put","patch"])
def data():
"""接受客户端发送过来的请求体数据，是request.json,request.form,request.files等无法接受的数据，全部会保留到这里"""
print(request.data) #
# 接受表单提交的数据
print(request.form) # ImmutableMultiDict([('username', 'root'), ('password', '123456')])
# 接受ajax或其他客户端提交过来的json数据
print(request.json) # {'username': 'root', 'password': '123456'}
# 接受上传文件
avatar = request.files["avatar"] # ImmutableMultiDict([('avatar', <FileStorage: '123.jpg' ('image/jpeg')>)])
print(avatar) # <FileStorage: '123.jpg' ('image/jpeg')>
# 获取请求头信息
print( request.headers ) # 获取全部的而请求头信息
print( request.headers.get("Host") )
# 获取自定义请求头
print( request.headers.get("company") ) # oldboy
print( request.headers["company"] ) # oldboy
# 本次请求的url地址
print( request.url) # http://127.0.0.1:5000/data
print( request.path ) # /data
return "ok"
# 声明和加载配置
class Config():
DEBUG = True
app.config.from_object(Config)
if __name__ == '__main__':
# 运行flask
app.run(host="0.0.0.0")
响应
flask默认支持2种响应方式:
数据响应: 默认响应html文本,也可以返回 JSON格式,或其他格式
页面响应: 重定向
url_for 视图之间的跳转
响应的时候,flask也支持自定义http响应状态码
响应html文本
from flask import make_response
@app.route("/")
def index():
# [默认支持]响应html文本
return "<img src='http://flask.pocoo.org/static/logo.png'>"
return make_response("<h1>hello user</h1>") # 等同于上面的一段
返回JSON数据
在 Flask 中可以直接使用 jsonify 生成一个 JSON 的响应
from flask import Flask, request, jsonify
# jsonify 就是json里面的jsonify
@app.route("/")
def index():
# 也可以响应json格式代码
data = [
{"id":1,"username":"liulaoshi","age":18},
{"id":2,"username":"liulaoshi","age":17},
{"id":3,"username":"liulaoshi","age":16},
{"id":4,"username":"liulaoshi","age":15},
]
return jsonify(data)
flask中返回json 数据,都是flask的jsonify方法返回就可以了.
重定向
重定向到百度页面
from flask import redirect
# 页面跳转响应
@app.route("/user")
def user():
# 页面跳转 redirect函数就是response对象的页面跳转的封装
# Location: http://www.baidu.com
return redirect("http://www.baidu.com")
重定向到自己写的视图函数
可以直接填写自己 url 路径
也可以使用 url_for 生成指定视图函数所对应的 url
from flask import url_for
# 内容响应
@app.route("/")
def index():
# [默认支持]响应html文本
# return "<img src='http://flask.pocoo.org/static/logo.png'>"
# 也可以响应json格式代码
data = [
{"id":1,"username":"liulaoshi","age":18},
{"id":2,"username":"liulaoshi","age":17},
{"id":3,"username":"liulaoshi","age":16},
{"id":4,"username":"liulaoshi","age":15},
]
return jsonify(data)
#使用url_for可以实现视图方法之间的内部跳转
# url_for("视图方法名")
@app.route("/login")
def login():
return redirect( url_for("index") )
重定向到带有参数的视图函数
在 url_for 函数中传入参数
# 路由传递参数
@app.route('/user/<user_id>')
def user_info(user_id):
return 'hello %d' % user_id
# 重定向
@app.route('/demo4')
def demo4():
# 使用 url_for 生成指定视图函数所对应的 url
return redirect( url_for(endpoint="user",user_id=100) )
自定义状态码和响应头
在 Flask 中，可以很方便的返回自定义状态码，以实现不符合 http 协议的状态码，例如：status code: 666
@app.route('/demo4')
def demo4():
return '状态码为 666', 400
"""还可以使用make_response创建Response对象，然后通过response对象返回数据"""
from flask import make_response
@app.route("/rep")
def index7():
response = make_response("ok")
print(response)
response.headers["Company"] = "oldboy" # 自定义响应头
response.status_code = 201 # 自定义响应状态码
return response
http的会话控制
所谓的会话,就是客户端浏览器和服务端网站之间一次完整的交互过程.
会话的开始是在用户通过浏览器第一次访问服务端网站开始.
会话的结束时在用户通过关闭浏览器以后，与服务端断开.
所谓的会话控制，就是在客户端浏览器和服务端网站之间，进行多次http请求响应之间，记录、跟踪和识别用户的信息而已。
因为 http 是一种无状态协议，浏览器请求服务器是无状态的。
无状态：指一次用户请求时，浏览器、服务器无法知道之前这个用户做过什么，每次请求都是一次新的请求。
无状态原因：浏览器与服务器是使用 socket 套接字进行通信的，服务器将请求结果返回给浏览器之后，会关闭当前的 socket 连接，而且服务器也会在处理页面完毕之后销毁页面对象。
有时需要保持下来用户浏览的状态，比如用户是否登录过，浏览过哪些商品等
实现状态保持主要有两种类型：
- 在客户端存储信息使用url,Cookie，token令牌[jwt.csrf,oauth]
- 在服务器端存储信息使用Session
Cookie
Cookie是由服务器端生成，发送给客户端浏览器，浏览器会将Cookie的key/value保存，下次请求同一网站时就发送该Cookie给服务器（前提是浏览器设置为启用cookie）。Cookie的key/value可以由服务器端自己定义。
使用场景: 登录状态, 浏览历史, 网站足迹,购物车 [不登录也可以使用购物车]
Cookie是存储在浏览器中的一段纯文本信息，建议不要存储敏感信息如密码，因为电脑上的浏览器可能被其它人使用
Cookie基于域名安全，不同域名的Cookie是不能互相访问的
如访问luffy.com时向浏览器中写了Cookie信息，使用同一浏览器访问baidu.com时，无法访问到luffy.com写的Cookie信息
浏览器的同源策略针对cookie也有限制作用.
当浏览器请求某网站时，会将本网站下所有Cookie信息提交给服务器，所以在request中可以读取Cookie信息
设置cookie
设置cookie需要通过flask的Response响应对象来进行设置,由响应对象会提供了方法set_cookie给我们可以快速设置cookie信息。
@app.route("/set_cookie")
def set_cookie():
"""设置cookie"""
response = make_response("ok")
# response.set_cookie(key="变量名",value="变量值",max_age="有效时间/秒")
response.set_cookie("username","xiaoming",100)
"""如果cookie没有设置过期时间，则默认过期为会话结束过期"""
"""cookie在客户端中保存时，用一个站点下同变量名的cookie会覆盖"""
response.set_cookie("age","100")
return response
获取cookie
@app.route("/get_cookie")
def get_cookie():
"""获取cookie"""
print(request.cookies)
print(request.cookies.get("username"))
print(request.cookies.get("age"))
"""打印效果：
{'username': 'xiaoming'}
"""
return ""
删除cookie
@app.route("/del_cookie")
def del_cookie():
"""删除cookie"""
response = make_response("ok")
#把对应名称的cookie设置为过期时间，则可以达到删除cookie
response.set_cookie("username","",0)
return response
Session
session相关配置项文档:https://dormousehole.readthedocs.io/en/latest/config.html?highlight=session_cookie_path
对于敏感、重要的信息，建议要存储在服务器端，不能存储在浏览器中，如用户名、余额、等级、验证码等信息
在服务器端进行状态保持的方案就是Session
Session依赖于Cookie,session的ID一般默认通过cookie来保存到客户端。
flask中的session需要加密,所以使用session之前必须配置SECRET_KEY选项,否则报错.
session的有效期默认是会话期，会话结束了，session就废弃了。
如果将来希望session的生命周期延长，可以通过修改cookie中的sessionID来完成配置。
设置session
from flask import Flask, make_response, request,session
app = Flask(__name__)
class Config():
SECRET_KEY = "123456asdadad"
DEBUG = True
app.config.from_object(Config)
# 查看当前flask默认支持的所有配置项
# print(app.config)
"""
<Config {
'DEBUG': False,
'TESTING': False,
'PROPAGATE_EXCEPTIONS': None,
'PRESERVE_CONTEXT_ON_EXCEPTION': None,
'SECRET_KEY': None,
'PERMANENT_SESSION_LIFETIME': datetime.timedelta(31),
'USE_X_SENDFILE': False,
'LOGGER_NAME': '__main__',
'LOGGER_HANDLER_POLICY': 'always',
'SERVER_NAME': None,
'APPLICATION_ROOT': None,
'SESSION_COOKIE_NAME': 'session',
'SESSION_COOKIE_DOMAIN': None,
'SESSION_COOKIE_PATH': None,
'SESSION_COOKIE_HTTPONLY': True,
'SESSION_COOKIE_SECURE': False,
'SESSION_REFRESH_EACH_REQUEST': True,
'MAX_CONTENT_LENGTH': None,
'SEND_FILE_MAX_AGE_DEFAULT': datetime.timedelta(0, 43200),
'TRAP_BAD_REQUEST_ERRORS': False,
'TRAP_HTTP_EXCEPTIONS': False,
'EXPLAIN_TEMPLATE_LOADING': False,
'PREFERRED_URL_SCHEME': 'http',
'JSON_AS_ASCII': True,
'JSON_SORT_KEYS': True,
'JSONIFY_PRETTYPRINT_REGULAR': True,
'JSONIFY_MIMETYPE': 'application/json',
'TEMPLATES_AUTO_RELOAD': None
"""
@app.route("/set_session")
def set_session():
"""设置session"""
"""与cookie不同，session支持python基本数据类型作为值"""
session["username"] = "xiaohuihui"
session["info"] = {
"age":11,
"sex":True,
}
return "ok"
if __name__ == '__main__':
app.run(debug=True)
获取session
@app.route("/get_session")
def get_session():
"""获取session"""
print( session.get("username") )
print( session.get("info") )
return "ok"
删除session
@app.route("/del_session")
def del_session():
"""删除session"""
try:
del session["username"]
# session.clear() # 删除所有
except:
pass
return "ok"
请求钩子
在客户端和服务器交互的过程中，有些准备工作或扫尾工作需要处理，比如：
- 在请求开始时，建立数据库连接；
- 在请求开始时，根据需求进行权限校验；
- 在请求结束时，指定数据的交互格式；
为了让每个视图函数避免编写重复功能的代码，Flask提供了通用设置的功能，即请求钩子。
请求钩子是通过装饰器的形式实现，Flask支持如下四种请求钩子：
- before_first_request
- 在处理第一个请求前执行[项目初始化时的钩子] 第一个执行
- before_request
- 在每次请求前执行
- 如果在某修饰的函数中返回了一个响应，视图函数将不再被调用
- after_request
- 如果没有抛出错误，在每次请求后执行
- 接受一个参数：视图函数作出的响应
- 在此函数中可以对响应值在返回之前做最后一步修改处理
- 需要将参数中的响应在此参数中进行返回
- teardown_request： 最后一个执行
- 在每次请求后执行
- 接受一个参数：错误信息，如果有相关错误抛出
- 需要设置flask的配置DEBUG=False，teardown_request才会接受到异常对象。
代码
from flask import Flask,request
# 初始化
app = Flask(import_name=__name__)
# 声明和加载配置
class Config():
DEBUG = True
app.config.from_object(Config)
@app.before_first_request
def before_first_request():
"""
这个钩子会在项目启动后第一次被用户访问时执行
可以编写一些初始化项目的代码，例如，数据库初始化，加载一些可以延后引入的全局配置
"""
print("----before_first_request----")
print("系统初始化的时候,执行这个钩子方法")
print("会在接收到第一个客户端请求时,执行这里的代码")
@app.before_request
def before_request():
"""
这个钩子会在每次客户端访问视图的时候执行
# 可以在请求之前进行用户的身份识别，以及对于本次访问的用户权限等进行判断。..
"""
print("----before_request----")
print("每一次接收到客户端请求时,执行这个钩子方法")
print("一般可以用来判断权限,或者转换路由参数或者预处理客户端请求的数据")
@app.after_request
def after_request(response):
print("----after_request----")
print("在处理请求以后,执行这个钩子方法")
print("一般可以用于记录会员/管理员的操作历史,浏览历史,清理收尾的工作")
response.headers["Content-Type"] = "application/json"
response.headers["Company"] = "python oldboy..."
# 必须返回response参数
return response
@app.teardown_request
def teardown_request(exc):
print("----teardown_request----")
print("在每一次请求以后,执行这个钩子方法")
print("如果有异常错误,则会传递错误异常对象到当前方法的参数中")
# 在项目关闭了DEBUG模式以后，则异常信息就会被传递到exc中，我们可以记录异常信息到日志文件中
print(exc)
# 编写路由视图
@app.route(rule='/')
def index():
print("-----------视图函数执行了---------------")
return "<h1>hello world!</h1>"
if __name__ == '__main__':
# 运行flask
app.run(host="0.0.0.0")
-
在第1次请求时的打印：
----before_first_request----
系统初始化的时候,执行这个钩子方法
会在接收到第一个客户端请求时,执行这里的代码
----before_request----
127.0.0.1 - - [04/Aug/2020 14:40:22] "GET / HTTP/1.1" 200 -
每一次接收到客户端请求时,执行这个钩子方法
一般可以用来判断权限,或者转换路由参数或者预处理客户端请求的数据
-----------视图函数执行了---------------
----after_request----
在处理请求以后,执行这个钩子方法
一般可以用于记录会员/管理员的操作历史,浏览历史,清理收尾的工作
----teardown_request----
在每一次请求以后,执行这个钩子方法
如果有异常错误,则会传递错误异常对象到当前方法的参数中
None -
在第2次请求时的打印：
----before_request----
每一次接收到客户端请求时,执行这个钩子方法
一般可以用来判断权限,或者转换路由参数或者预处理客户端请求的数据
127.0.0.1 - - [04/Aug/2020 14:40:49] "GET / HTTP/1.1" 200 -
-----------视图函数执行了---------------
----after_request----
在处理请求以后,执行这个钩子方法
一般可以用于记录会员/管理员的操作历史,浏览历史,清理收尾的工作
----teardown_request----
在每一次请求以后,执行这个钩子方法
如果有异常错误,则会传递错误异常对象到当前方法的参数中
None
异常捕获
主动抛出HTTP异常
- abort 方法
- 抛出一个给定状态代码的 HTTPException 或者 指定响应，例如想要用一个页面未找到异常来终止请求，你可以调用 abort(404)
- 参数：
-
code – HTTP的错误状态码
abort(404)
abort(500)
-
abort一般在工作zhong, 也可以基于raise进行替代食用. 如果在flask中一般常用于权限等页面上错误的展示提示.
捕获错误
-
errorhandler 装饰器
- 注册一个错误处理程序，当程序抛出指定错误状态码的时候，就会调用该装饰器所装饰的方法
-
参数：
- code_or_exception – HTTP的错误状态码或指定异常
-
例如统一处理状态码为500的错误给用户友好的提示：
@app.errorhandler(500)
def internal_server_error(e):
return '服务器搬家了' -
捕获指定异常类型
@app.errorhandler(ZeroDivisionError)
def zero_division_error(e):
return '除数不能为0'
代码:
from flask import Flask
# 创建flask应用
app = Flask(__name__)
"""加载配置"""
class Config():
DEBUG = True
app.config.from_object(Config)
"""
flask中内置了app.errorhander提供给我们捕获异常，实现一些在业务发生错误时的自定义处理。
1. 通过http状态码捕获异常信息
2. 通过异常类进行异常捕获
"""
"""1. 捕获http异常[在装饰器中写上要捕获的异常状态码也可以是异常类]"""
@app.errorhandler(404)
def error_404(exc):
return '<h1 style="color:red">滚犊子</h1>'
@app.errorhandler(500)
def error_11(e):
return '<h1 style="color:red">滚犊子ba</h1>'
@app.route('/')
def set_session():
if request.args.get('password')=='123':
abort(404)
elif request.args.get('password') == 'abd':
abort(500)
else:
print('欢迎来到个人中心')
return 'ok'
"""2. 捕获系统异常或者自定义异常"""
class APIError(Exception):
pass
@app.route("/")
def index():
raise APIError("api接口调用参数有误！")
return "个人中心，视图执行了！！"
@app.errorhandler(APIError)
def error_apierror(e):
return "错误: %s" % e
if __name__ == '__main__':
app.run(host="localhost",port=8080)
context
执行上下文：即语境，语意，在程序中可以理解为在代码执行到某一行时，根据之前代码所做的操作以及下文即将要执行的逻辑，可以决定在当前时刻下可以使用到的变量，或者可以完成的事情。
Flask中上下文对象：相当于一个容器，保存了 Flask 程序运行过程中的一些信息[变量、函数、类与对象等信息]。
Flask中有两种上下文，请求上下文(request context)和应用上下文(application context)。
- application 指的就是当你调用app = Flask(name)创建的这个对象app；
- request 指的是每次http请求发生时，WSGI server(比如gunicorn)调用Flask.call()之后，在Flask对象内部创建的Request对象；
- application 表示用于响应WSGI请求的应用本身，request 表示每次http请求；
- application的生命周期大于request，一个application存活期间，可能发生多次http请求，所以，也就会有多个request
请求上下文(request context)
思考：在视图函数中，如何取到当前请求的相关数据？比如：请求地址，请求方式，cookie等等
在 flask 中，可以直接在视图函数中使用 request 这个对象进行获取相关数据，而 request 就是请求上下文的对象，保存了当前本次请求的相关数据，请求上下文对象有：request、session
- request
- 封装了HTTP请求的内容，针对的是http请求。举例：user = request.args.get('user')，获取的是get请求的参数。
- session
- 用来记录请求会话中的信息，针对的是用户信息。举例：session['name'] = user.id，可以记录用户信息。还可以通过session.get('name')获取用户信息。
请求上下文提供的变量/属性/方法/函数/类与对象，只能在视图中或者被视图调用的地方使用
应用上下文(application context)
它的字面意思是 应用上下文，但它不是一直存在的，它只是request context 中操作当前falsk应用对象 app 的代理(人)，所谓local proxy。它的作用主要是帮助 request 获取当前的flask应用相关的信息，它是伴 request 而生，随 request 而灭的。
应用上下文对象有：current_app，g
current_app
应用程序上下文,用于存储应用程序中的变量，可以通过current_app.name打印当前app的名称，也可以在current_app中存储一些变量，例如：
-
应用的启动脚本是哪个文件，启动时指定了哪些参数
-
加载了哪些配置文件，导入了哪些配置
-
连接了哪个数据库
-
有哪些可以调用的工具类、常量
-
当前flask应用在哪个机器上，哪个IP上运行，内存多大
from flask import Flask,request,session,current_app,g
初始化
app = Flask(import_name=name)
声明和加载配置
class Config():
DEBUG = True
app.config.from_object(Config)编写路由视图
@app.route(rule='/')
def index():
# 应用上下文提供给我们使用的变量，也是只能在视图或者被视图调用的地方进行使用，
# 但是应用上下文的所有数据来源于于app，每个视图中的应用上下文基本一样
print(current_app.config) # 获取当前项目的所有配置信息
print(current_app.url_map) # 获取当前项目的所有路由信息return "<h1>hello world!</h1>"if name == 'main':
# 运行flask
app.run(host="0.0.0.0")
g变量
g 作为 flask 程序全局的一个临时变量,充当者中间媒介的作用,我们可以通过它传递一些数据，g 保存的是当前请求的全局变量，不同的请求会有不同的全局变量，通过不同的thread id区别
g.name='abc' # name是举例，实际要保存什么数据到g变量中，可以根据业务而定，你可以任意的数据进去
注意：不同的请求，会有不同的全局变量g
from flask import Flask,request,session,current_app,g
# 初始化
app = Flask(import_name=__name__)
# 声明和加载配置
class Config():
DEBUG = True
app.config.from_object(Config)
@app.before_request
def before_request():
g.name = "root"
def get_two_func():
name = g.name
print("g.name=%s" % name)
def get_one_func():
get_two_func()
# 编写路由视图
@app.route(rule='/')
def index():
# 请求上下文提供的变量/属性/方法/函数/类与对象，只能在视图中或者被视图调用的地方使用
# 请求上下文里面信息来源于每次客户端的请求，所以每个视图中请求上下文的信息都不一样
# print(session)
# 应用上下文提供给我们使用的变量，也是只能在视图或者被视图调用的地方进行使用，
# 但是应用上下文的所有数据来源于于app，每个视图中的应用上下文基本一样
print(current_app.config) # 获取当前项目的所有配置信息
print(current_app.url_map) # 获取当前项目的所有路由信息
get_one_func()
return "<h1>hello world!</h1>"
if __name__ == '__main__':
# 运行flask
app.run(host="0.0.0.0")
两者区别和共同点：
- 请求上下文：保存了客户端和服务器交互的数据，一般来自于客户端。request，session
- 应用上下文：flask 应用程序运行过程中，保存的一些配置信息，比如路由列表，程序名、数据库连接、应用信息等 current_app ,g
不管是请求或者应用上下文都只能使用在视图范围内或者能被视图调用的地方
如果是视图以外地方使用，则会报错:
RuntimeError: Working outside of application context
解决方案：
with app.app_context( )
Flask-Script 扩展
文档: https://flask-script.readthedocs.io/en/latest/
这个模块的作用可以让我们通过终端来控制flask项目的运行，类似于django的manage.py
安装命令:
pip install flask-script
集成 Flask-Script到flask应用中，创建一个主应用程序，一般我们叫manage.py/run.py/main.py都行。
from flask import Flas
app = Flask(__name__)
"""使用flask_script启动项目"""
from flask_script import Manager
manage = Manager(app)
@app.route('/')
def index():
return 'hello world'
if __name__ == "__main__":
manager.run()
启动终端脚本运行项目的命令：
# 端口和域名不写，默认为127.0.0.1:5000
python run.py runserver
# 通过-h设置启动域名，-p设置启动端口
python run.py runserver -h127.0.0.1 -p8888
Flask-Script 还可以为当前应用程序添加脚本命令
1. 引入Command命令基类
2. 创建命令类必须直接或间接继承Command，并在内部实现run方法，同时如果有自定义的其他参数，则必须实现__init__
3. 使用flask_script应用对象manage.add_command对命令类进行注册，并设置调用终端别名。
from flask import Flask
from flask_script import Manager, Command, Option
app = Flask(__name__)
class Config():
DEBUG = True
app.config.from_object(Config)
manager = Manager(app)
import os
class BluePrintCommand(Command):
option_list = [
Option("--name","-n",help="蓝图名称")
]
def run(self,name=None):
if name is None:
print("蓝图名称不能为空！")
return
if not os.path.isdir(name):
os.mkdir(name)
open("%s/views.py" % name,"w")
open("%s/models.py" % name,"w")
with open("%s/urls.py" % name,"w") as f:
f.write("""from . import views
urlpatterns = [
]
""")
manager.add_command("blue", BluePrintCommand)
@app.route("/")
def index():
return "ok"
if __name__ == '__main__':
manager.run()
作业: 给你的路飞项目, 增加一个自定义终端命令:
1. 通过 python manage.py createuser num=100
自动由程序自动生成100个用户信息
2. django自定义终端命令
https://docs.djangoproject.com/zh-hans/3.1/howto/custom-management-commands/
3. Faker模块
安装: pip install Faker
基本使用:
from flask import Flask
from flask_script import Manager, Command, Option
app = Flask(__name__)
class Config():
DEBUG = True
app.config.from_object(Config)
manager = Manager(app)
"""Faker基本使用
生成仿真的测试数据
"""
from faker import Faker
class DataCommand(Command):
# 创建faker对象
option_list = [
Option("--number","-n",help="数量")
]
def run(self,number=None):
if number is None:
number = 10
faker = Faker(locale="zh_CN")
for _ in range(int(number)):
print("俺叫%s，我的手机是%s" % (faker.name_male(),faker.phone_number()))
manager.add_command("data",DataCommand)
if __name__ == '__main__':
manager.run()
浙公网安备 33010602011771号