Flask(二)

钩子函数

from flask  import Flask

app = Flask(__name__)

# 第一次请求之前会来调用

# 初始化操作

@app.before_first_request

def demo1():

      print("第一次请求会调用"")

# 每次请求之前都会调用,应用场景:封装ip处理

@app.before_request

def demo2():

　　print("每次请求之前会被调用")

#每次请求之后都会调用这个钩子函数,应用场景:对response进行统一处理

@app.after_request

def demo3(response):

　　# response.headers["Content-Type"] = "application/json"

　　print("每次请求之后才会调用")

　　return response

# 每次都会执行,都会带入一个服务器的错误过来

@app.teardown_request

def demo4(err):

　　print(err)

　　print("每次请求之后都会调用一个服务器错误过来)

if  __name__ == "_main__":

　　app.run(debug=True)

对cookie进行操作:

from flask import Flask, make_response, request

app = Flask(__name__)

@app.route("/login")

def login():

　　"""登录成功之后借助cookie保存用户登录信息"""

　　# 创建响应对象

　　response = make_response("login_success")

　　# 借助响应对象的set_cookie方法设置键值对

　　# 参数1:ke, 参数2:value, 参数3:max_age表示过期时长(以秒为单位)

　　# set_cookie("key",值) Cookie是存储在浏览器中的一段纯文本

　　response.set_cookie("user_name", "kangkang", max_age=3600)

　　response.set_cookie("age", "18", max_age= 3600)

　　return response

# 获取cookie

@app.route("/index")

def index():

"""再次请求首页的时候,提起cookie中的用户信息"""

　　user_name = request.cookies.get("user_name", "")

　　age = request.cookies.get("age", "")

　　return "index %s --- %s" %(user_name, age)

# 删除cookie

@app.route("/login_out")

def login_out():

　　response = make_response("login_out success")

　　response.delete_cookie("user_name")

　　response.delete_cookie("age")

　　#将响应对象返回

　　return response

if __name__== "__main__":

　　app.run(debug=True)

对session进行操作,session依赖于cookie,服务器会返回一个session_id即为cookie,session里面包含用户信息

from flask import Flask, session

app = Flask(__name__)

# session需要设置秘钥,可以写一个任意的字符串,两种写法,app.config是个字典

app.config="2323242423"

app.config["SECREY_KEY"] = "3213232"

@app.route("/login")

def login():

　　# session将用户数据存储在服务器的内存中--redis数据库

　　session["user_name"]= "kangkang"

　　session["user_id"] = "12"

　　return "login success"

@app.route("/index")

def index():

　　user_name = session.get("user_name", "")

　　user_id = session.get("user_id", "")

　　return "index:%s ---%s" %(user_name, user_id)

@app.route("/login_out")

def login_out():

　　session.pop("user_name", "")

　　session.pop("age", "")

　　return "login_out success"

if __name__ == "__main__":

　　app.run(debug=True)

捕获异常:

from flask import Flask, redirect, abort

app = Flask(__name__)

@app.route("/")

def hello():

　　a = 1/0

　　abort(404)  # 主动产生一个404异常,abort需要先导入该库,abort传入的必须是http存在的错误状态码

　　return "hello world"

# 通过errorhandler捕获错误状态码

@app.errorhandler(404)

def handler(e):

　　print(e)

　　# 重定向到百度的错误页面链接

　　return redirect("https://www.baidu.com/search/error.html")

# 通过errorhandler捕获异常

@app.errorhandler(ZeroDivisionError)

def err(err):

　　return "不能除以0"

if __name__ == "__main__":

　　app.run(debug=True)

上下文:

请求上下文: request和session

应用上下文:current_app, g变量(flask程序全局的一个临时变量)

from flask import Flask, request, session, current_app, g

app =Flask(__name__)

app.config["SECRECT_KEY"] = "avdvdvd"

# print(request.method)  Working outside of request context.请求上下文超出范围

# print(g.user) Working outside of request context.应用上下文超出范围

# 只能在视图函数里面进行操作,在外部进行操作就会超出范围

@app.route("/")

def hello():

# 请求上下文

　　print(request.method)

　　print(request.url)

　　session["user_name"] = "curry"

　　print(session.get("user_name", ""))

　　# 应用上下文(current_app, g)

　　print(current_app.config.get("DEBUG"))

　　g.user = "james"

　　print(g.user)

　　return "hello world"

if __name__ == "__main__":

　　app.run(debug=True)

• 请求上下文：保存了客户端和服务器交互的数据
• 应用上下文：flask 应用程序运行过程中，保存的一些配置信息，比如程序名、数据库连接、应用信息等

Flask-Script拓展

需要安装Flask-Script拓展

pip install flask-script

from flask import Flask

from flask_script import Manager

app = Flask(__name__)

manager= Manager(app)

@app.route("/")

def hello():

　　return "hello world"

if __name__ == "__main__":

　　manager.run()

通过终端命令: python XX.py runserver  -h ip地址 -p 端口号  -d

同样也可以配置该文件的环境变量进行右键运行.

Jinja2模板引擎简介

视图函数的主要作用是生成请求的响应，这是最简单的请求。实际上，视图函数有两个作用：处理业务逻辑和返回响应内容。在大型应用中，把业务逻辑和表现内容放在一起，会增加代码的复杂度和维护成本。本节学到的模板，它的作用即是承担视图函数的另一个作用，即返回响应内容。

• 模板其实是一个包含响应文本的文件，其中用占位符(变量)表示动态部分，告诉模板引擎其具体的值需要从使用的数据中获取
• 使用真实值替换变量，再返回最终得到的字符串，这个过程称为“渲染”
• Flask是使用 Jinja2 这个模板引擎来渲染模板

使用模板的好处：

视图函数只负责业务逻辑和数据处理(业务逻辑方面)

而模板则取到视图函数的数据结果进行展示(视图展示方面)

代码结构清晰，耦合度低

Jinja2：是 Python 下一个被广泛应用的模板引擎，是由Python实现的模板语言，他的设计思想来源于 Django 的模板引擎，并扩展了其语法和一系列强大的功能，其是Flask内置的模板语言。

模板语言：是一种被设计来自动生成文档的简单文本格式，在模板语言中，一般都会把一些变量传给模板，替换模板的特定位置上预先定义好的占位变量名

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

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

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

Jinja2模板中的变量代码块可以是任意Python类型或者对象,只要它能够Python的Str()方法转换为一个字符串就可以,

{{your_dict['key']}}

{{your_list[0]}}

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

{% if user %}

　　{{user}}

{% else %}

　　hello!

<ul>

　　{% for index in indexs %}

　　　　<li>{{index}}</li>

　　　　{% endfor %}

</ul>

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

模板的基本使用:

在项目下创建templates文件夹,用于存放所有的模板文件,并在目录下创建一个模板html文件

from flask import Flask, render_template

app = Flask(__name__)

@app.route("/")

def index():

　　myint = 18

　　mystr = "curry"

　　my_list =[1, 23,4,6,5]

　　my_dict = {

　　"name":"duan",

　　"age":28

　　}

　　return render_template("dem01.html",

　　　　　　　　　　　　　myint = myint, mystr = mystr, my_dict=my_dict, my_list = my_liust)

if __name == "__main__":

　　app.run()

对应的demo01.html:

<!DOCTYPE html>

<html lang="en">

<head>

   <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
我的模板html内容
<br/>{{ my_str }}
<br/>{{ my_int }}
<br/>{{ my_array }}
<br/>{{ my_dict }}

</body>
</html>

链式调用: {{"hello world" | reverse | upper}}

常见内建过滤器:

字符串操作

safe:禁止转义 {{"<em>hello</em>"| safe}}

capitalize:把变量的首字母转成大写,其余字母小写 {{'hello" | capitalize}}

lower:把值转成小写, {{"HELLO" | lower}}

upper:把值转成大写,{{"hello" | upper}}

title:把每个单词的首字母都转成大写, {{'he is girl" | title}}

reverse:字符串反转,

format:格式化输出 {{'%s is %d' | format('name', 7)}}

striptags:把html中的tag去掉, {{'<h1>hello</h1>" | striptags}}

truncate:字符串截断 {{'hello every one" | truncate(9) }}

列表操作

list=[1,2,3,1,2,3,6,8,4]

first :取第一个元素 {{list | first}}

last:取最后一个元素{{list | last}}

length:获取列表长度{{list | length}}

sum:求列表的和{{list | sum}}

sort:列表排序 {{list | sort}}

语句块过滤:

{% filter upper %}

　# 一大堆文字#

{% endfilter %}

自定义过滤函器

from flask import render_template, Flask

app = Flask(__name__)

# 方法一:自定义列表反函数

@app.template_filter("list_reverse")

def list_rever(list):

　　list.reverse()

　　return list

# 方式二:将自定义的函数添加到flask过滤器中,add_template_filter(函数名, "创建过滤器名称") 函数名不需要打引号

app.add_template_filter(list_rever, "list_reverse")

@app.route("/")

def index():

　　list = [1,2,3,4,6,5]

　　return render_template("demo02.html", list = list)

if __name__ == "__main__":

　　　app.run(debug=True)

demo02.html内容:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
自定义过滤器<hr>
<body>
{{ list }}
<br>
{{ list | list_reverse }}
</body>
</html>

 控制代码:

from flask import Flask, render_template

app = Flask(__name__)

@app.route("/")

def index():

　　# 只显示四行数据, 并设置颜色

　　my_list = [

　　　　

{
    "id":1,
    "value":"我爱代码"
},
{
    "id": 2,
    "value": "代码使人快乐"
},
{
    "id": 3,
    "value": "沉迷于代码无法自拔"
},
{
    "id": 4,
    "value": "日渐消瘦"
},
{
    "id": 5,
    "value": "以梦为马，越骑越傻"
}

]

return render_template("demo03.html", my_list = my_list)

if __name__ == "__main__":

　　app.run(debug=True)

demo03.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
控制代码块<hr>
{% for item in my_list%}
{#    {% if item.id != 5 %}#}
        {% if loop.index == 1 %}
            <li style="background-color: yellow">{{ item.value }}</li>
        {% elif loop.index == 2%}
            <li style="background-color: #2aabd2">{{ item.value }}</li>
        {% elif loop.index == 3 %}
            <li style="background-color: #2b542c">{{ item.value }}</li>
         {% elif loop.index == 4 %}
            <li style="background-color: #8a6d3b">{{ item.value }}</li>
         {% elif loop.index == 5 %}
            <li style="background-color: darkgrey">{{ item.value }}</li>

        {% endif %}

{#    {% endif %}#}


{% endfor %}

loop.index: 当前循环迭次的次数(从1开始)

loop.index0:当前循环迭代的次数(从0开始)

loop.revindex: 到循环结束需要迭的次数(从1开始)

loop.revindex0:到循环结束需要迭代的次数(从0开始)

loop.first 第一迭代,为True

loop.last 最后一次迭代,为True

loop.length  序列中的项目数

loop.cycle:在一串序列期间取值的辅助函数.

模板继承:

在模板中，可能会遇到以下情况：

• 多个模板具有完全相同的顶部和底部内容
• 多个模板中具有相同的模板代码内容，但是内容中部分值不一样
• 多个模板中具有完全相同的 html 代码块内容

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

from flask import Flask, render_template

app = Flask(__name__)

@app.route("/parent")

def parent():

　　return render_template("base.html")

@app.route("/child")

def child():

　　return render_template("child.html")

if __name__ == "__main__":

　　app.run(debug=True)

base.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
{# 把要重写的父类的内容用{% block 名称x %} XXX {% endblock %}#}
{% block testA %}
<h2>父类模板<h2>
{% endblock %}
<h2>父类内容</h2>
<h2>父类底部</h2>

<body>

</body>
</html>

child.html内容:

{# 子类继承父类使用extends关键字 {% extends  '父类.html'  %}#}

{% extends "base.html'' %}

{# 重写父类中的部分内容#}

{# 不丢失父类原有的内容使用super()#}

{% block testA % }

{{super()}}

<h2>我是子类模板</h2>

{% endblock %}

怎样设置templates的html文件在使用render_template方法时自动弹出里面的html文件进行选择

选择Jinja2,apply之后点击ok即可

可以设置自己设置状态码及状态码解释

from flask import Flask

app = Flask(__name__)

@app.route("/")

def index():

　　# 666代表状态码, 解释为状态码的解释信息

　　return "hello world", "666 解释"

if __name__ == "__main__":

　　app.run(debug=True)