自定义路由正则匹配：# 添加到flask中# 我们要用自定义的路由，用正则的话# 1导入from werkzeug.routing import BaseConverter# 2我先要写一个类，然后继承BaseConverter，然后实现进行初始化,to_python(self, value)，to_url(self, value)# 3 app.url_map.converters['regex1'] = RegexConverter# 4 我们在路由里面@app.route('/index/<regex1("\d+"):nid>')，regex1='谁便，regex1("正则表达式")# 5 regex1("正则表达式")匹配出来的结果，返回to_python，一定要return# 6 当我们做反向解析的解析的时候，我们的参数，会传递给to_url，return的结果才是我们拼接到我们路由上
from flask import Flask, views, url_for
from werkzeug.routing import BaseConverter
app = Flask(import_name=__name__)
class RegexConverter(BaseConverter):
"""
自定义URL匹配正则表达式
"""
def __init__(self, map, regex):
super(RegexConverter, self).__init__(map)
self.regex = regex
def to_python(self, value):
"""
路由匹配时，匹配成功后传递给视图函数中参数的值
"""
# value就正则匹配出来的结果
print('value：', value, type(value))
return "asdasdasd"
def to_url(self, value):
"""
使用url_for反向生成URL时，传递的参数经过该方法处理，返回的值用于生成URL中的参数
"""
val = super(RegexConverter, self).to_url(value)
print(val) #666
return val
app.url_map.converters['regex1'] = RegexConverter
@app.route('/index/<regex1("\d+"):nid>', endpoint="sb")
def index(nid):
print("nid", nid, type(nid))
print(url_for('sb', nid='666')) # /index/666
return 'Index'
if __name__ == '__main__':
app.run()
模板语法：
'''jinjia2模板语言 -前端：支持函数加括号并且传参 {{ func（1,2,3） | safe}} -其他的用法完全同DTL -后台：视图函数用 aa=Markup(a) -jinjia2有没有处理xss攻击？ - html中的特殊符号'''
from flask import Flask, url_for, render_template, Markup
app = Flask(__name__)
@app.route('/')
def index():
# def func(a, b, c):
# return 'sb', a + b + c
a = "<input type='text' value='sb'>"
a = Markup(a) # 后台转义标签
return render_template('index.html', func=a) # 函数作为值传参,前端函数还可以携带参数
if __name__ == '__main__':
app.run(port=8000)
# 这里run本质上就是run_simple
请求响应：
from flask import Flask, render_template, request, make_response
app = Flask(__name__)
app.debug = True
@app.route('/', methods=['GET', 'POST'])
def index():
# print(request.args.get('id')) # get请求取值
# print(request.form.get('name')) # post请求取值
# request.values post和get提交的数据总和
# request.cookies 客户端所带的cookie
# request.headers 请求头
# request.script_root
# request.url 带域名带参数的请求路径
# request.base_url 带域名请求路径
# request.url_root 域名
# request.host_url 域名
# request.host 127.0.0.1:500
# request.files
# request.files 文件
# obj = request.files['the_file_name']
# obj.save('/var/www/uploads/' + secure_filename(f.filename)) # 存入文件
print(request.method) # 请求方法
print(request.path) # 请求路径（根路径）
print(request.full_path) # 请求路径携带参数路径（全路径）
obj = make_response('你大爷的！') # 只是把值进行封装
obj.set_cookie('key', '1456sxxxxxxxsss') # 往前端传送设置cookie键值对
obj.delete_cookie('key') # 删除掉cookie
obj.headers['xxxx'] = 'yyyyyyyy' # 响应头
return obj
if __name__ == '__main__':
app.run(port=8000)
# 这里run本质上就是run_simple
路由的其他参数和使用：
# app.add_url_rule("/", view_func=UserView.as_view(name="user"))
# rule, URL规则
# view_func, 视图函数名称
# 为函数提供参数
# endpoint = None, 名称，用于反向生成URL，即： url_for('名称')
# methods = None, 允许的请求方式，如：["GET", "POST"]
# defaults = None, 默认值, 当URL中无参数，函数需要参数时，使用defaults = {'k': 'v'}
# #对URL最后的 / 符号是否严格要求
# strict_slashes = None
# '''
# @app.route('/index', strict_slashes=False)
# #访问http://www.xx.com/index/ 或http://www.xx.com/index均可
# @app.route('/index', strict_slashes=True)
# #仅访问http://www.xx.com/index
# '''
# #重定向到指定地址
# redirect_to = None,
from flask import Flask, redirect, render_template, jsonify, views
app = Flask(__name__)
# strict_slashes,该参数是用来设置，我们的路由是否为严格模式，False是非严格模式，True严格，默认是严格
@app.route("/index", strict_slashes=True, redirect_to="/login")
def index():
return "ok"
@app.route("/login")
def login():
return "sb"
@app.route("/detail/<int:nid>")
def detail(nid):
print(nid)
return "ok"
if __name__ == '__main__':
app.run()
session的使用
"""session: -使用必须先设置一下秘钥：app.secret_key = 'nimaipaffsf' -session['name']='kevin'存值放前端，取值 session['name']) # 取值的时候，把前端cookie通过解密，获取得到 -源码流程： -save_session -响应的时候，把session中的值解密序列化放到了cookie中，返回浏览器 -open_session -请求来了，从cookie中取出来，反解，生成session对象，以后在视图函数中直接用session就可以"""
from flask import Flask, session
app = Flask(__name__)
app.secret_key = '你打卖批'
app.debug = True
# app.config['SESSION_COOKIE_NAME'] = 'dsb'
@app.route('/', methods=['GET', 'POST'])
def index():
session['name'] = 'kevin'
return 'index'
@app.route('/test', methods=['GET', 'POST'])
def test():
print(session['name']) # 取值的时候，把前端cookie通过解密，获取得到
return 'test'
if __name__ == '__main__':
app.run()
闪现
"""
什么是闪现：
a产生信息，传给c页面
但是用户访问a页面以后，不是直接跳转到c，而是到b，或者是其它页面，但是用户访问c页面的时候，a给我的信息能拿到
"""
from flask import Flask, flash, get_flashed_messages, request
app = Flask(__name__)
app.secret_key = 'adsfsfsdgfsg'
# 1.如果要用flash就必须设置app.secret_key = 'adsfsfsdgfsg'
# 2.闪现设置好的值，只能去一次，如果再次刷新页面就取不到
# 3.我们可以通过 flash('普通信息',category="info")，对信息做分类
# 4.我们设置闪现，category_filter=("error",)进行分类信息的过滤，筛选
# 5.with_categories=True,是将显示信息把分类显示
@app.route('/index')
def index():
flash('超时信息', category='error')
flash('普通信息', category='info')
return 'sffsfsfffsffsdfds'
@app.route('/error1')
def error1():
return '错误1'
@app.route('/error2')
def error2():
data = get_flashed_messages(with_categories=True,category_filter=('error', 'info'))
data1 = get_flashed_messages(with_categories=True, category_filter=('error', 'info'))
print(data, data1)
print(data, data1)
return '错误2'
if __name__ == '__main__':
app.run()
before_request和after_request
from flask import Flask, request, render_template
app = Flask(__name__)
'''@app.before_request在请求进入视图函数之前执行'''
# @app.before_request
# def befor1():
# print(request)
# print("我是请求之前1")
# return "123"
#
#
# @app.before_request
# def befor2():
# print("我是请求之前2")
'''@app.after_request:在视图函数响应之后执行，但是必须接受参数response，并返回它'''
# @app.after_request
# def after1(response):
# print("我是请求之后1")
# return response
#
# @app.after_request
# def after2(response):
# print("我是请求之后2")
# return response
"""before_first_request:只执行一次，第一次请求之前，第二次请求不执行"""
@app.before_first_request
def before_first():
print("123")
# 如论有没有异常都会执行，如果没有异常这个参数就是None，有就记录这个异常
# @app.teardown_request
# def tear(e):
# print('teardown_request')
# print(e)
# 捕获异常，如果出现异常，而且状态就是@app.errorhandler(404),
# @app.errorhandler(404)
# def error_404(arg):
# print(arg)
# return "404错误了"
# @app.errorhandler(500)
# def error(arg):
# print(arg)
# return "500错误了"
"""@app.template_global()：设置全局函数,可以传进前端{{ sb(1,2)}}"""
# @app.template_global()
# def sb(a1, a2):
# return a1 + a2
# 也是一种函数传参方式{{1|db(2,3)}}
# @app.template_filter()
# def db(a1, a2, a3):
# print(a1, a2, a3)
# return a1 + a2 + a3
@app.route('/index')
def index():
print("我是真的视图")
return render_template("index.html")
if __name__ == '__main__':
# app.__call__
app.run()
中间件：
from flask import Flask
app = Flask(__name__)
app.secret_key = 'jhfksfhsdfsd'
app.debug = True
"""
中间件：跟django中的中间件不一样
-flask中一旦请求到来，要执行app()---->执行的是app.__call__,整个flask的入口（call在实例化对象中会走，对象的属性存在call方法里）
"""
class MyMiddleware:
def __init__(self, my_wsgi_app):
self.wsgi_app = my_wsgi_app # 进行初始化
def __call__(self, environ, start_response):
print("之前")
obj = self.wsgi_app(environ, start_response)
print("之后")
return obj
@app.route('/index')
def index():
return "ok"
if __name__ == '__main__':
# app.__call__
app.wsgi_app = MyMiddleware(app.wsgi_app)
app.run()
# 请求来了，执行__call__本质是执行self.wsgi_app(environ, start_response)，
# MyMiddleware(app.wsgi_app)app.wsgi_app本质就是flask最终执行的方法，然后传参进去，走call方法，把执行后的结果返回出来