一 请求勾子

在客户端和服务器交互的过程中,有些准备工作或扫尾工作需要处理,比如:

  • 在请求开始时,建立数据库连接;

  • 在请求开始时,根据需求进行权限校验;

  • 在请求结束时,指定数据的交互格式;

为了让每个视图函数避免编写重复功能的代码,Flask提供了通用设施的功能,即请求钩子。

请求钩子是通过装饰器的形式实现,Flask支持如下四种请求钩子:

  • before_first_request

    • 在处理第一个请求前执行

  • before_request

    • 在每次请求前执行

    • 如果在某修饰的函数中返回了一个响应,视图函数将不再被调用

  • after_request

    • 如果没有抛出错误,在每次请求后执行

    • 接受一个参数:视图函数作出的响应

    • 在此函数中可以对响应值在返回之前做最后一步修改处理

    • 需要将参数中的响应在此参数中进行返回

  • teardown_request

    • 在每次请求后执行

    • 接受一个参数:错误信息,如果有相关错误抛出

  1. from flask import Flask
  2. from settings.dev import DevConfig
  3.  
  4. app = Flask(__name__)
  5. # 项目配置
  6. app.config.from_object(DevConfig)
  7.  
  8. @app.before_first_request
  9. def before_first_request():
  10. print("----before_first_request----")
  11. print("系统初始化的时候,执行这个钩子方法")
  12. print("会在接收到第一个客户端请求时,执行这里的代码")
  13.  
  14. @app.before_request
  15. def before_request():
  16. print("----before_request----")
  17. print("每一次接收到客户端请求时,执行这个钩子方法")
  18. print("一般可以用来判断权限,或者转换路由参数或者预处理客户端请求的数据")
  19.  
  20. @app.after_request
  21. def after_request(response):
  22. print("----after_request----")
  23. print("在处理请求以后,执行这个钩子方法")
  24. print("一般可以用于记录会员/管理员的操作历史,浏览历史,清理收尾的工作")
  25. response.headers["Content-Type"] = "application/json"
  26. # 必须返回response参数
  27. return response
  28.  
  29. @app.teardown_request
  30. def teardown_request(exc):
  31. print("----teardown_request----")
  32. print("在每一次请求以后,执行这个钩子方法,如果有异常错误,则会传递错误异常对象到当前方法的参数中")
  33. print(exc)
  34.  
  35. @app.route("/")
  36. def index():
  37. print("----视图函数----")
  38. print("视图函数被运行了")
  39. return "视图函数被运行了<br>"
  40.  
  41. if __name__ == '__main__':
  42. app.run(host="0.0.0.0", port=80)

请求钩子

在第1次请求时的打印:

  1. ----before_first_request----
  2. 系统初始化的时候,执行这个钩子方法
  3. 会在接收到第一个客户端请求时,执行这里的代码
  4. ----before_request----
  5. 每一次接收到客户端请求时,执行这个钩子方法
  6. 一般可以用来判断权限,或者转换路由参数或者预处理客户端请求的数据
  7. ----视图函数----
  8. 视图函数被运行了
  9. ----after_request----
  10. 在处理请求以后,执行这个钩子方法
  11. 一般可以用于记录会员/管理员的操作历史,浏览历史,清理收尾的工作
  12. ----teardown_request----
  13. 在每一次请求以后,执行这个钩子方法,如果有异常错误,则会传递错误异常对象到当前方法的参数中
  14. None

在第2次请求时的打印:

  1. ----before_request----
  2. 127.0.0.1 - - [08/Apr/2019 09:23:53] "GET / HTTP/1.1" 200 -
  3. 每一次接收到客户端请求时,执行这个钩子方法
  4. 一般可以用来判断权限,或者转换路由参数或者预处理客户端请求的数据
  5. ----视图函数----
  6. 视图函数被运行了
  7. ----after_request----
  8. 在处理请求以后,执行这个钩子方法
  9. 一般可以用于记录会员/管理员的操作历史,浏览历史,清理收尾的工作
  10. ----teardown_request----
  11. 在每一次请求以后,执行这个钩子方法,如果有异常错误,则会传递错误异常对象到当前方法的参数中
  12. None

二 异常捕获

1.主动抛出HTTP异常

  • abort 方法

    • 抛出一个给定状态代码的 HTTPException 或者 指定响应,例如想要用一个页面未找到异常来终止请求,你可以调用 abort(404)。

  • 参数:

    • code – HTTP的错误状态码

2.捕获错误

  • errorhandler 装饰器

    • 注册一个错误处理程序,当程序抛出指定错误状态码的时候,就会调用该装饰器所装饰的方法

  • 参数:

    • code_or_exception – HTTP的错误状态码或指定异常

  1. from flask import Flask,abort
  2.  
  3. from settings.dev import DevConfig
  4.  
  5. app = Flask(__name__)
  6.  
  7. app.config.from_object(DevConfig)
  8.  
  9. # 异常处理
  10.  
  11. @app.errorhandler(505)
  12. def internal_server_error(e):
  13.  
  14. return '<h1>服务器搬家了</h1>'
  15.  
  16. @app.route('/',methods=['get'])
  17. def home():
  18. abort(505)# internal_server_error 顶用是上面自定义的异常处理函数,未定义是默认抛出该数字代表的异常
  19. # abort(404)
  20. return '这是首页'
  21.  
  22. @app.errorhandler(Exception)
  23. def zero_division_error(e):
  24. return '除数不能为0'
  25.  
  26. @app.route('/index')
  27. def index():
  28.  
  29. raise Exception() # 调用了自定义方法 zero_division_error
  30.  
  31. if __name__ == '__main__':
  32.  
  33. app.run(host='127.0.0.1',port=80)

三 上下文

上下文:即语境,语意,在程序中可以理解为在代码执行到某一时刻时,根据之前代码所做的操作以及下文即将要执行的逻辑,可以决定在当前时刻下可以使用到的变量,或者可以完成的事情。

Flask中有两种上下文,请求上下文(request context)和应用上下文(application context)。

Flask中上下文对象:相当于一个容器,保存了 Flask 程序运行过程中的一些信息。

  1. application 指的就是当你调用app = Flask(__name__)创建的这个对象app

  2. request 指的是每次http请求发生时,WSGI server(比如gunicorn)调用Flask.__call__()之后,在Flask对象内部创建的Request对象;

  3. application 表示用于响应WSGI请求的应用本身,request 表示每次http请求;

  4. application的生命周期大于request,一个application存活期间,可能发生多次http请求,所以,也就会有多个request

1.请求上下文(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')获取用户信息。

2.应用上下文(application context)

它的字面意思是 应用上下文,但它不是一直存在的,它只是request context 中的一个对 app 的代理(人),所谓local proxy。它的作用主要是帮助 request 获取当前的应用,它是伴 request 而生,随 request 而灭的。

应用上下文对象有:current_app,g

1.current_app

应用程序上下文,用于存储应用程序中的变量,可以通过current_app.name打印当前app的名称,也可以在current_app中存储一些变量,例如:

  • 应用的启动脚本是哪个文件,启动时指定了哪些参数

  • 加载了哪些配置文件,导入了哪些配置

  • 连接了哪个数据库

  • 有哪些可以调用的工具类、常量

  • 当前flask应用在哪个机器上,哪个IP上运行,内存多大

  1. current_app.name
  2. current_app.test_value='value'

2.g变量

g 作为 flask 程序全局的一个临时变量,充当者中间媒介的作用,我们可以通过它传递一些数据,g 保存的是当前请求的全局变量,不同的请求会有不同的全局变量,通过不同的thread id区别

  1. g.name='abc'

注意:不同的请求,会有不同的全局变量

两者区别:

  • 请求上下文:保存了客户端和服务器交互的数据

  • 应用上下文:flask 应用程序运行过程中,保存的一些配置信息,比如程序名、数据库连接、应用信息等

  1. from flask import Flask,g,current_app,request
  2. from settings.dev import DevConfig
  3.  
  4. application = Flask(__name__)
  5.  
  6. application.config.from_object(DevConfig)
  7.  
  8. # @application.after_request
  9. # def after_request(response):
  10. # print('%s访问了home页面'%g.name)
  11. #
  12. # return response
  13.  
  14. @application.route('/index')
  15.  
  16. def index():
  17.  
  18. current_app.test_value =200
  19.  
  20. return 'this is index'
  21.  
  22. @application.route('/home')
  23. def home():
  24. g.name = 'xiaoming' # 只能在当前本次请求中获取定义的数据
  25.  
  26. print(current_app) #<Flask '03 上下文'>
  27.  
  28. print(application) #<Flask '03 上下文'>
  29. # print(current_app.test_value)
  30. print(request.args.get('user'))
  31.  
  32. return "这是request.args.get('user'):%s"%request.args.get('user')
  33. if __name__ == '__main__':
  34.  
  35. application.run(host='127.0.0.1',port=80)

四 Flask-Script 扩展

1.安装

  1. pip install flask-script

2. 用法

  1. from flask import Flask
  2. from flask_script import Manager,Command
  3.  
  4. from settings.dev import DevConfig
  5.  
  6. app = Flask(__name__)
  7.  
  8. app.config.from_object(DevConfig)
  9.  
  10. # 把 manage 类和应用程序实例进行关联
  11. manager = Manager(app)
  12.  
  13. # 自定义命令行的命令
  14. class Hello(Command):
  15. '''打印一个hello 的自定义命令'''
  16. def run(self):
  17. print('hello 命令的执行')
  18.  
  19. manager.add_command('test',Hello())
  20.  
  21. @app.route('/')
  22. def index():
  23.  
  24. return 'this is index'
  25.  
  26. if __name__ == '__main__':
  27.  
  28. manager.run()

五 Jinja2模板引擎

Flask内置的模板语言,它的设计思想来源于 Django 的模板引擎,并扩展了其语法和一系列强大的功能。

渲染模版函数

  • Flask提供的 render_template 函数封装了该模板引擎

  • render_template 函数的第一个参数是模板的文件名,后面的参数都是键值对,表示模板中变量对应的真实值。

  1. 在视图函数中设置渲染模板

  1. @app.route('/')
  2. def index():
  3. return render_template('index.html')
  1. 在项目下创建 templates 文件夹,用于存放所有的模板文件,并在目录下创建一个模板html文件 index.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4. <meta charset="UTF-8">
  5. <title>Title</title>
  6. </head>
  7. <body>
  8. 我的模板html内容
  9. </body>
  10. </html>

{{}} 来表示变量名,这种 {{}} 语法叫做变量代码块

  1. <h1>{{ post.title }}</h1>

Jinja2 模版中的变量代码块可以是任意 Python 类型或者对象,只要它能够被 Python 的 str() 方法转换为一个字符串就可以,比如,可以通过下面的方式显示一个字典或者列表中的某个元素:

  1. {{your_dict['key']}}
  2. {{your_list[0]}}

用 {%%} 定义的控制代码块,可以实现一些语言层次的功能,比如循环或者if语句

  1. {% if user %}
  2. {{ user }}
  3. {% else %}
  4. hello!
  5. <ul>
  6. {% for index in indexs %}
  7. <li> {{ index }} </li>
  8. {% endfor %}
  9. </ul>

使用 {# #} 进行注释,注释的内容不会在html中被渲染出来

  1. {# {{ name }} #}

1.模板中特有的变量和函数

可以在模板中访问一些 Flask 默认内置的函数和对象

config

你可以从模板中直接访问Flask当前的config对象:

  1. {{config.SQLALCHEMY_DATABASE_URI}}
  2. sqlite:///database.db

request

就是flask中代表当前请求的request对象:

  1. {{request.url}}
  2. http://127.0.0.1

session

为Flask的session对象

  1. {{session.new}}
  2. True

g变量

在视图函数中设置g变量的 name 属性的值,然后在模板中直接可以取出

  1. {{ g.name }}

url_for()

url_for会根据传入的路由器函数名,返回该路由对应的URL,在模板中始终使用url_for()就可以安全的修改路由绑定的URL,则不比担心模板中渲染出错的链接:

  1. {{url_for('home')}}

如果我们定义的路由URL是带有参数的,则可以把它们作为关键字参数传入url_for(),Flask会把他们填充进最终生成的URL中:

  1. {{ url_for('post', post_id=1)}}
  2. /post/1

2流程控制

主要包含两个:

  1. - if/else if /else / endif
  2. - for / endfor

if语句

Jinja2 语法中的if语句跟 Python 中的 if 语句相似,后面的布尔值或返回布尔值的表达式将决定代码中的哪个流程会被执行:

  1. {%if user.is_logged_in() %}
  2. <a href='/logout'>Logout</a>
  3. {% else %}
  4. <a href='/login'>Login</a>
  5. {% endif %}

过滤器可以被用在 if 语句中:

  1. {% if comments | length > 0 %}
  2. There are {{ comments | length }} comments
  3. {% else %}
  4. There are no comments
  5. {% endif %}

循环语句

  • 我们可以在 Jinja2 中使用循环来迭代任何列表或者生成器函数

  1. {% for post in posts %}
  2. <div>
  3. <h1>{{ post.title }}</h1>
  4. <p>{{ post.text | safe }}</p>
  5. </div>
  6. {% endfor %}
  • 循环和if语句可以组合使用,以模拟 Python 循环中的 continue 功能,下面这个循环将只会渲染post.text不为None的那些post:

  1. {% for post in posts if post.text %}
  2. <div>
  3. <h1>{{ post.title }}</h1>
  4. <p>{{ post.text | safe }}</p>
  5. </div>
  6. {% endfor %}
  • 在一个 for 循环块中你可以访问这些特殊的变量:

变量 描述
loop.index 当前循环迭代的次数(从 1 开始)
loop.index0 当前循环迭代的次数(从 0 开始)
loop.revindex 到循环结束需要迭代的次数(从 1 开始)
loop.revindex0 到循环结束需要迭代的次数(从 0 开始)
loop.first 如果是第一次迭代,为 True 。
loop.last 如果是最后一次迭代,为 True 。
loop.length 序列中的项目数。
loop.cycle 在一串序列间期取值的辅助函数。见下面示例程序。
  • 在循环内部,你可以使用一个叫做loop的特殊变量来获得关于for循环的一些信息

    • 比如:要是我们想知道当前被迭代的元素序号,并模拟Python中的enumerate函数做的事情,则可以使用loop变量的index属性,例如:

  1. {% for post in posts%}
  2. {{loop.index}}, {{post.title}}
  3. {% endfor %}
  • 会输出这样的结果

  1. 1, Post title
    2, Second Post
  • cycle函数会在每次循环的时候,返回其参数中的下一个元素,可以拿上面的例子来说明:

  1. {% for post in posts%}
  2. {{loop.cycle('odd','even')}} {{post.title}}
  3. {% endfor %}
  • 会输出这样的结果:

  1. odd Post Title
    even Second Post
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4. <meta charset="UTF-8">
  5. <title>flask页面</title>
  6. </head>
  7. <body>
  8. <h1>这是标题:{{title}}</h1>
  9. <ul>
  10. {% for item in list1 %}
  11.  
  12. <li>{{ item }}</li>
  13. {% endfor %}
  14. </ul>
  15.  
  16. {% if dict1.sex==2 %}
  17. <p>性别:男</p>
  18. {% else %}
  19. <p>性别:女</p>
  20. {% endif %}
  21.  
  22. </body>
  23. </html>

模板语法 html

  1. from flask import Flask,g,render_template
  2.  
  3. from settings.dev import DevConfig
  4.  
  5. app = Flask(__name__)
  6.  
  7. app.config.from_object(DevConfig)
  8.  
  9. @app.route('/')
  10. def index():
  11.  
  12. g.name = '首页'
  13.  
  14. dict1 ={
  15. 'username':'deng',
  16. 'age':28,
  17. 'sex':2
  18. }
  19. list1 =['张珊','李四','王伟']
  20.  
  21. return render_template('index.html',title ='我是flask首页',dict1=dict1,list1=list1)
  22. if __name__ == '__main__':
  23.  
  24. app.run(host='127.0.0.1',port=80)

后端代码

六 过滤器

过滤器的本质就是函数。有时候我们不仅仅只是需要输出变量的值,我们还需要修改变量的显示,甚至格式化、运算等等,而在模板中是不能直接调用 Python 中的某些方法,那么这就用到了过滤器。

使用方式:

  • 过滤器的使用方式为:变量名 | 过滤器。

  1. {{variable | filter_name(*args)}}
  • 如果没有任何参数传给过滤器,则可以把括号省略掉

  1. {{variable | filter_name }}
  • 如:``,这个过滤器的作用:把变量variable 的值的首字母转换为大写,其他字母转换为小写

在 jinja2 中,过滤器是可以支持链式调用的,示例如下:

  1. {{ "hello world" | reverse | upper }}

1.常见的内建过滤器

1.字符串操作

  • safe:禁用转义

  1. <p>{{ '<em>hello</em>' | safe }}</p>
  • capitalize:把变量值的首字母转成大写,其余字母转小写

  1. <p>{{ 'hello' | capitalize }}</p>
  • lower:把值转成小写

  1. <p>{{ 'HELLO' | lower }}</p>
  • upper:把值转成大写

  1. <p>{{ 'hello' | upper }}</p>
  • title:把值中的每个单词的首字母都转成大写

  1. <p>{{ 'hello' | title }}</p>
  • reverse:字符串反转

  1. <p>{{ 'olleh' | reverse }}</p>
  • format:格式化输出

  1. <p>{{ '%s is %d' | format('name',17) }}</p>
  • striptags:渲染之前把值中所有的HTML标签都删掉

  1. <p>{{ '<em>hello</em>' | striptags }}</p>
  • truncate: 字符串截断

  1. <p>{{ 'hello every one' | truncate(9)}}</p>

2 列表操作

  • first:取第一个元素

  1. <p>{{ [1,2,3,4,5,6] | first }}</p>
  • last:取最后一个元素

  1. <p>{{ [1,2,3,4,5,6] | last }}</p>
  • length:获取列表长度

  1. <p>{{ [1,2,3,4,5,6] | length }}</p>
  • sum:列表求和

  1. <p>{{ [1,2,3,4,5,6] | sum }}</p>
  • sort:列表排序

  1. <p>{{ [6,2,3,1,5,4] | sort }}</p>

3 语句块过滤

  1. {% filter upper %}
  2. #一大堆文字#
  3. {% endfilter %}

2.自定义过滤器

过滤器的本质是函数。当模板内置的过滤器不能满足需求,可以自定义过滤器。自定义过滤器有两种实现方式:

  • 一种是通过Flask应用对象的 add_template_filter 方法

  • 通过装饰器来实现自定义过滤器

重要:自定义的过滤器名称如果和内置的过滤器重名,会覆盖内置的过滤器。

1. 视图中:

  1. from flask import Flask,render_template
  2.  
  3. from settings.dev import DevConfig
  4.  
  5. app = Flask(__name__)
  6.  
  7. app.config.from_object(DevConfig)
  8.  
  9. # 自定义过滤器
  10. def ftow(num):
  11.  
  12. return '%.2f'%num
  13.  
  14. app.add_template_filter(ftow,'ft') #函数名,自定义过滤器名
  15.  
  16. @app.route('/')
  17. def home():
  18. avatar ="<img src='http://www.luffycity.com/static/img/head-logo.a7cedf3.svg'>"
  19. lst =['dn','wang','daa']
  20. num =123.3454
  21.  
  22. return render_template('home.html',avatar=avatar,lst=lst,num=num)
  23.  
  24. if __name__ == '__main__':
  25.  
  26. app.run(host='127.0.0.1',port=80)

2. 模板中

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4. <meta charset="UTF-8">
  5. <title>Title</title>
  6. </head>
  7. <body>
  8. {{ avatar|safe }}
  9. <p>{{ lst.0 }}</p>
  10. <p>{{ lst.2 }}</p>
  11. <p>{{ num|ft }}</p>
  12. </body>
  13. </html>

七 模板继承

在模板中,可能会遇到以下情况:

  • 多个模板具有完全相同的顶部和底部内容

  • 多个模板中具有相同的模板代码内容,但是内容中部分值不一样

  • 多个模板中具有完全相同的 html 代码块内容

像遇到这种情况,可以使用 JinJa2 模板中的 继承 来进行实现

例子:

1. 共同的模板  base.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4. <meta charset="UTF-8">
  5. <title>Title</title>
  6. </head>
  7. <body>
  8. <h3>网站头部</h3>
  9. {% block content %}
  10. {% endblock %}
  11. <h3>网站脚部</h3>
  12.  
  13. </body>
  14. </html>

2. frist.html

  1. {% extends 'base.html' %}
  2.  
  3. {% block content %}
  4. <p>第一个页面</p>
  5. {% endblock %}

3. tow.html

  1. {% extends 'base.html' %}
  2.  
  3. {% block content %}
  4. <p>2个页面</p>
  5. {% endblock %}

4. 视图

  1. from flask import Flask,render_template
  2.  
  3. from settings.dev import DevConfig
  4.  
  5. app = Flask(__name__)
  6.  
  7. app.config.from_object(DevConfig)
  8.  
  9. @app.route('/')
  10. def index():
  11.  
  12. return render_template('first.html')
  13.  
  14. @app.route('/home')
  15.  
  16. def home():
  17.  
  18. return render_template('two.html')
  19.  
  20. if __name__ == '__main__':
  21.  
  22. app.run(host='127.0.0.1',port=80)

模板继承使用时注意点:

  1. 不支持多继承

  2. 为了便于阅读,在子模板中使用extends时,尽量写在模板的第一行。

  3. 不能在一个模板文件中定义多个相同名字的block标签。

  4. 当在页面中使用多个block标签时,建议给结束标签起个名字,当多个block嵌套时,阅读性更好。

八 在 Flask 项目中解决 CSRF 攻击

在 Flask 中, Flask-wtf 扩展有一套完善的 csrf 防护体系,对于我们开发者来说,使用起来非常简单

安装:

  1. pip install flask_wtf
  1. 设置应用程序的 secret_key,用于加密生成的 csrf_token 的值

  1. # session加密的时候已经配置过了.如果没有在配置项中设置,则如下:
  2. app.secret_key = "#此处可以写随机字符串#"
  1. 导入 flask_wtf.csrf 中的 CSRFProtect 类,进行初始化,并在初始化的时候关联 app

  1. from flask.ext.wtf import CSRFProtect
  2. CSRFProtect(app)
  1. 在表单中使用 CSRF 令牌:

  1. <form method="post" action="/">
  2. <input type="hidden" name="csrf_token" value="{{ csrf_token() }}" />
  3. </form>

案例:

1. 后端代码

  1. from flask import Flask,render_template,request
  2. from flask.ext.wtf import CSRFProtect
  3.  
  4. from settings.dev import DevConfig
  5.  
  6. app = Flask(__name__)
  7.  
  8. app.config.from_object(DevConfig)
  9.  
  10. CSRFProtect(app)
  11.  
  12. @app.route('/login',methods=['GET','POST'])
  13.  
  14. def login():
  15.  
  16. if request.method=='GET':# 需要大写
  17.  
  18. return render_template('form.html')
  19. else:
  20.  
  21. print(request.form)
  22. return 'ok'
  23.  
  24. if __name__ == '__main__':
  25.  
  26. app.run(host='127.0.0.1',port=80)

2. 前端模板

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4. <meta charset="UTF-8">
  5. <title>Title</title>
  6. </head>
  7. <body>
  8. <form action="" method="post">
  9. <input type="hidden" name="csrf_token" value="{{ csrf_token() }}"/>
  10. 用户名:<input type="text">
  11. 密码:<input type="password">
  12. <input type="submit" value="提交">
  13. </form>
  14. </body>
  15. </html>

1. get 请求login.html 页面时:

2.post 提交数据未带 csrf_token 时 :

02 flask 请求钩子、异常捕获、上下文、Flask-Script 扩展、jinja2 模板引擎、csrf防范的更多相关文章

  1. Flask从入门到精通之Jinja2模板引擎

    我们使用一个简单的例子切入到Jinja2模板引擎,形式最简单的Jinja2模板引擎就是一个包含响应文本的文件,实例如下: <h1>Hello World!</h1> 最简单的包 ...

  2. flask请求钩子、HTTP响应、响应报文、重定向、手动返回错误码、修改MIME类型、jsonify()方法

    请求钩子: 当我们需要对请求进行预处理和后处理时,就可以用Flask提供的回调函数(钩子),他们可用来注册在请求处理的不同阶段执行的处理函数.这些请求钩子使用装饰器实现,通过程序实例app调用,以 b ...

  3. flask框架下的jinja2模板引擎(3)(模板继承与可以在模板使用的变量、方法)

    flask 框架下的jinja2模块引擎(1):https://www.cnblogs.com/chichung/p/9774556.html flask 框架下的jinja2模块引擎(2):http ...

  4. Python Flask Jinja2模板引擎

    模板 简介 模板是一个包含响应文本的文件,其中包含用占位变量表示的动态部分,其具体值只在请 求的上下文中才能知道. 渲染 使用真实值替换变量,再返回最终得到的响应字符串,这一过程 称为渲染.为了渲染模 ...

  5. flask框架下的jinja2模板引擎(2)(过滤器与自定义过滤器)

    flask框架下的jinja2模块引擎(1):https://www.cnblogs.com/chichung/p/9774556.html 这篇论文主要用来记录下 jinja2 的过滤器. 什么是过 ...

  6. flask框架下的jinja2模板引擎(1)(模板渲染)

    #转载请留言联系 模板是什么? 在 flask 框架中,视图函数有两个作用:处理业务逻辑和返回响应内容.在大型应用中,把业务逻辑和表现内容放在一起,会增加代码的复杂度和维护成本.模板作用即是承担视图函 ...

  7. Flask 框架下 Jinja2 模板引擎高层 API 类——Environment

    Environment 类版本: 本文所描述的 Environment 类对应于 Jinja2-2.7 版本.   Environment 类功能: Environment 是 Jinja2 中的一个 ...

  8. flask之--钩子,异常,上下文,flask-script,模板,过滤器,csrf_token

    一.请求钩子 在客户端和服务器交互的过程中,有些准备工作或扫尾工作需要处理,比如: - 在请求开始时,建立数据库连接: - 在请求开始时,根据需求进行权限校验: - 在请求结束时,指定数据的交互格式: ...

  9. Flask基础(08)-->错误捕获(异常捕获)

    错误捕获(异常捕获) from flask import Flask from flask import abort app = Flask(__name__) @app.route('/demo1' ...

随机推荐

  1. C# 基于任务的异步模式的创建与使用的简单示例

    对于窗体程序,使用基于任务的异步模式需要用到Task类,下面示例下非常简单的用法. 1.创建一个拥有异步方法的类 该类拥有一个异步方法DoSomthingAsync,根据微软建议的命名规则该方法要带A ...

  2. [mybatis错误] - sql出错 org.apache.ibatis.ognl.ParseException: Encountered "!" at line 1, column 15. Was expecting one of:

    完整异常:Caused by: org.apache.ibatis.builder.BuilderException: Error evaluating expression 'developerTy ...

  3. Shell中的IFS

    一.IFS 介绍 Shell 脚本中有个变量叫 IFS(Internal Field Seprator) ,内部域分隔符.完整定义是The shell uses the value stored in ...

  4. React Native 炫酷的动画库 实现任何AE动画 lottie-react-native

    lottie-react-native 传送门 1.npm i --save lottie-react-native 2.react-native link lottie-ios 3.react-na ...

  5. P4574 [CQOI2013]二进制A+B

    传送门 思路: 本题可用数位DP来做,设 f [ i ][ a ][ b ][ c ][ j ] 表示当前枚举到(二进制下的)第i位,a' b' c'各用a,b,c了几个1,j表示最后一位是否有进位. ...

  6. js,jq获取父,兄弟,子节点整理

    js获取节点 父: parentNode 获取已知节点的父节点. 子: childNodes; 得到全部子节点 children 得到全部子节点 firstChild 获得第一个子节点 lastChi ...

  7. Centos7 linux下通过源码安装redis以及使用

    下载redis安装包 wget http://download.redis.io/releases/redis-5.0.3.tar.gz 解压压缩包 tar -zxvf redis-.tar.gz y ...

  8. python中网络编程基础

    一:什么是c\s架构 1.c\s即client\server 客户端\服务端架构. 客户端因特定的请求而联系服务器并发送必要的数据等待服务器的回应最后完成请求 服务端:存在的意义就是等待客户端的请求, ...

  9. Java 中常见的各种排序算法汇总

    首先,Java中自已是有排序的 说明:(1)Arrays类中的sort()使用的是“经过调优的快速排序法”;(2)比如int[],double[],char[]等基数据类型的数组,Arrays类之只是 ...

  10. Java中有多个异常, 如何确定捕获顺序(多个catch),先从上到下执行,判断异常的大小,如果包含捕到异常,就进入这个catch,后面的就不再执行

    Java中异常的捕获顺序(多个catch)( Java代码 import java.io.IOException; public class ExceptionTryCatchTest { publi ...