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 框架的核心。

Flask常用扩展包:

  • Flask-SQLalchemy:操作数据库;
  • Flask-script:插入脚本;
  • Flask-migrate:管理迁移数据库;
  • Flask-Session:Session存储方式指定;
  • Flask-WTF:表单;
  • Flask-Mail:邮件;
  • Flask-Bable:提供国际化和本地化支持,翻译;
  • Flask-Login:认证用户状态;
  • Flask-OpenID:认证;
  • Flask-RESTful:开发REST API的工具;
  • Flask-Bootstrap:集成前端Twitter Bootstrap框架;
  • Flask-Moment:本地化日期和时间;
  • Flask-Admin:简单而可扩展的管理接口的框架

扩展列表:http://flask.pocoo.org/extensions/

  1. 中文文档(http://docs.jinkan.org/docs/flask/)
  2. 英文文档(http://flask.pocoo.org/docs/0.11/)

安装虚拟环境:

pip install virtualenv

pip install virtualenvwrapper
创建虚拟环境:

python2: mkvirtualenv  环境名称   python3: mkvirtualenv -p python3 环境名称   需要联网

查看虚拟环境:workon  使用虚拟逆境:workon 环境名称
退出虚拟环境: deactivate    删除虚拟环境: rmvirtualenv 环境名称

查看包: pip list   pip freeze 后者比前者少自带的包, pip list > ***.txt  迁移 pip install -r ***.txt   pip freeze -all 和pip list 一样

HELLO WORLD!:

from flask import Flask

app = Flask(__name__)

@app.route('/')

def index():

    return "hello world"

if __name__ = "__main__":

    app.run()

初始化参数

Flask 程序实例在创建的时候,需要默认传入当前 Flask 程序所指定的包(模块),接下来就来详细查看一下 Flask 应用程序在创建的时候一些需要我们关注的参数:

app = Flask(__name__)

  • import_name
    • Flask程序所在的包(模块),传 __name__ 就可以
    • 其可以决定 Flask 在访问静态文件时查找的路径
  • static_path
    • 静态文件访问路径(不推荐使用,使用 static_url_path 代替)
  • static_url_path
    • 静态文件访问路径,可以不传,默认为:/ + static_folder
  • static_folder
    • 静态文件存储的文件夹,可以不传,默认为 static
  • template_folder
    • 模板文件存储的文件夹,可以不传,默认为 templates

程序加载配置

在 Flask 程序运行的时候,可以给 Flask 设置相关配置,比如:配置 Debug 模式,配置数据库连接地址等等,设置 Flask 配置有以下二种方式:

  • 从配置对象中加载(常用)
    • app.config.from_object()
  • 从配置文件中加载
    • app.config.from_pyfile()

路由传参数 :的使用

指定请求方式

在 Flask 中,定义一个路由,默认的请求方式为:

  • GET
  • OPTIONS(自带)
  • HEAD(自带)

如果想添加请求方试,那么可以如下指定:

@app.route('/demo2', methods=['GET', 'POST'])
def demo2():
    # 直接从请求中取到请求方式并返回
    return request.method

返回JSON

在使用 Flask 写一个接口时候需要给客户端返回 JSON 数据,在 Flask 中可以直接使用 jsonify 生成一个 JSON 的响应

# 返回JSON
@app.route('/demo4')
def demo4():
    json_dict = {
        "user_id": 10,
        "user_name": "laowang"
    }
    return jsonify(json_dict)

不推荐使用 json.dumps 转成 JSON 字符串直接返回,因为返回的数据要符合 HTTP 协议规范,如果是 JSON 需要指定 content-type:application/json

重定向:redirect

重定向到自己写的视图函数

  • 可以直接填写自己 url 路径
  • 也可以使用 url_for 生成指定视图函数所对应的 url

重定向到带有参数的视图函数

  • 在 url_for 函数中传入参数

自定义状态码

  • 在 Flask 中,可以很方便的返回自定义状态码,以实现不符合 http 协议的状态码,例如:status code: 666
@app.route('/demo6')
def demo6():
    return '状态码为 666', 666

正则匹配路由

在 web 开发中,可能会出现限制用户访问规则的场景,那么这个时候就需要用到正则匹配,根据自己的规则去限定请求参数再进行访问

具体实现步骤为:

  • 导入转换器基类:在 Flask 中,所有的路由的匹配规则都是使用转换器对象进行记录
  • 自定义转换器:自定义类继承于转换器基类
  • 添加转换器到默认的转换器字典中
  • 使用自定义转换器实现自定义匹配规则

代码实现

  • 导入转换器基类
from werkzeug.routing import BaseConverter
  • 自定义转换器
# 自定义正则转换器
class RegexConverter(BaseConverter):
    def __init__(self, url_map, *args):
        super(RegexConverter, self).__init__(url_map)
        # 将接受的第1个参数当作匹配规则进行保存
        self.regex = args[0]
  • 添加转换器到默认的转换器字典中,并指定转换器使用时名字为: re
app = Flask(__name__)

# 将自定义转换器添加到转换器字典中,并指定转换器使用时名字为: re
app.url_map.converters['re'] = RegexConverter
  • 使用转换器去实现自定义匹配规则
    • 当前此处定义的规则是:3位数字
@app.route('/user/')
def user_info(user_id):
    return "user_id 为 %s" % user_id

运行测试:http://127.0.0.1:5000/user/123 ,如果访问的url不符合规则,会提示找不到页面

自定义转换器其他两个函数实现

继承于自定义转换器之后,还可以实现 to_python 和 to_url 这两个函数去对匹配参数做进一步处理:

  • to_python:
    • 该函数参数中的 value 值代表匹配到的值,可输出进行查看
    • 匹配完成之后,对匹配到的参数作最后一步处理再返回,比如:转成 int 类型的值再返回:
class RegexConverter(BaseConverter):
    def __init__(self, url_map, *args):
        super(RegexConverter, self).__init__(url_map)
        # 将接受的第1个参数当作匹配规则进行保存
        self.regex = args[0]

    def to_python(self, value):
        return int(value)

运行测试,在视图函数中可以查看参数的类型,由之前默认的 str 已变成 int 类型的值

  • to_url:
    • 在使用 url_for 去获取视图函数所对应的 url 的时候,会调用此方法对 url_for 后面传入的视图函数参数做进一步处理
    • 具体可参见 Flask 的 app.py 中写的示例代码:ListConverter

系统自带转换器

DEFAULT_CONVERTERS = {
    'default':          UnicodeConverter,
    'string':           UnicodeConverter,
    'any':              AnyConverter,
    'path':             PathConverter,
    'int':              IntegerConverter,
    'float':            FloatConverter,
    'uuid':             UUIDConverter,
}

HTTP 异常主动抛出

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

捕获错误

  • 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'

 

获取请求参数

request

request 就是flask中代表当前请求的 request 对象,其中一个请求上下文变量(理解成全局变量,在视图函数中直接使用可以取到当前本次请求)

常用的属性如下:

属性 说明 类型
data 记录请求的数据,并转换为字符串 *
form 记录请求中的表单数据 MultiDict
args 记录请求中的查询参数 MultiDict
cookies 记录请求中的cookie信息 Dict
headers 记录请求中的报文头 EnvironHeaders
method 记录请求使用的HTTP方法 GET/POST
url 记录请求的URL地址 string
files 记录请求上传的文件 *

  

示例

  • 获取上传的图片并保存到本地
@app.route('/', methods=['POST'])
def index():
    pic = request.files.get('pic')
    pic.save('./static/aaa.png')
    return 'index

Flask-Script

 

模板

Jinja2

两个概念:

  • Jinja2:是 Python 下一个被广泛应用的模板引擎,是由Python实现的模板语言,他的设计思想来源于 Django 的模板引擎,并扩展了其语法和一系列强大的功能,其是Flask内置的模板语言。
  • 模板语言:是一种被设计来自动生成文档的简单文本格式,在模板语言中,一般都会把一些变量传给模板,替换模板的特定位置上预先定义好的占位变量名。

渲染模版函数

  • Flask提供的 render_template 函数封装了该模板引擎
  • render_template 函数的第一个参数是模板的文件名,后面的参数都是键值对,表示模板中变量对应的真实值。

使用

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

{{ post.title }}

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

{{your_dict['key']}}
{{your_list[0]}}
  • 用 {%%} 定义的控制代码块,可以实现一些语言层次的功能,比如循环或者if语句
{% if user %}
    {{ user }}
{% else %}
    hello!
    {% for index in indexs %}
  • {{ index }}
  • {% endfor %}

注释

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

过滤器

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

使用方式:

  • 过滤器的使用方式为:变量名 | 过滤器。
{{variable | filter_name(*args)}}
  • 如果没有任何参数传给过滤器,则可以把括号省略掉
{{variable | filter_name}}
  • 如:``,这个过滤器的作用:把变量variable 的值的首字母转换为大写,其他字母转换为小写

链式调用

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

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

常见内建过滤器

字符串操作

  • safe:禁用转义

{{ 'hello' | safe }}

  • capitalize:把变量值的首字母转成大写,其余字母转小写

{{ 'hello' | capitalize }}

  • lower:把值转成小写

{{ 'HELLO' | lower }}

  • upper:把值转成大写

{{ 'hello' | upper }}

  • title:把值中的每个单词的首字母都转成大写

{{ 'hello' | title }}

  • reverse:字符串反转

{{ 'olleh' | reverse }}

  • format:格式化输出

{{ '%s is %d' | format('name',17) }}

  • striptags:渲染之前把值中所有的HTML标签都删掉

{{ 'hello' | striptags }}

  • truncate: 字符串截断

{{ 'hello every one' | truncate(9)}}

列表操作

  • first:取第一个元素

{{ [1,2,3,4,5,6] | first }}

  • last:取最后一个元素

{{ [1,2,3,4,5,6] | last }}

  • length:获取列表长度

{{ [1,2,3,4,5,6] | length }}

  • sum:列表求和

{{ [1,2,3,4,5,6] | sum }}

  • sort:列表排序

{{ [6,2,3,1,5,4] | sort }}

语句块过滤

{% filter upper %}
    #一大堆文字#
{% endfilter %}

自定义过滤器

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

  • 一种是通过Flask应用对象的 add_template_filter 方法
  • 通过装饰器来实现自定义过滤器

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

控制代码块

控制代码块主要包含两个:

- if/else if /else / endif
- for / endfor

if语句

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

{%if user.is_logged_in() %}
    Logout
{% else %}
    Login
{% endif %}

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

{% if comments | length > 0 %}
    There are {{ comments | length }} comments
{% else %}
    There are no comments
{% endif %}

循环

  • 我们可以在 Jinja2 中使用循环来迭代任何列表或者生成器函数
{% for post in posts %}
    

{{ post.title }}

{{ post.text | safe }}

{% endfor %}
  • 循环和if语句可以组合使用,以模拟 Python 循环中的 continue 功能,下面这个循环将只会渲染post.text不为None的那些post:
{% for post in posts if post.text %}
    

{{ post.title }}

{{ post.text | safe }}

{% 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属性,例如:
{% for post in posts%}
{{loop.index}}, {{post.title}}
{% endfor %}
  • 会输出这样的结果
1, Post title
2, Second Post
  • cycle函数会在每次循环的时候,返回其参数中的下一个元素,可以拿上面的例子来说明:
{% for post in posts%}
{{loop.cycle('odd','even')}} {{post.title}}
{% endfor %}
  • 会输出这样的结果:
odd Post Title
even Second Post

示例程序

  • 实现的效果

  • 准备数据
# 只显示4行数据,背景颜色依次为:黄,绿,红,紫
my_list = [
    {
        "id": 1,
        "value": "我爱工作"
    },
    {
        "id": 2,
        "value": "工作使人快乐"
    },
    {
        "id": 3,
        "value": "沉迷于工作无法自拔"
    },
    {
        "id": 4,
        "value": "日渐消瘦"
    },
    {
        "id": 5,
        "value": "以梦为马,越骑越傻"
    }
]
  • 模板代码
{% for item in my_list if item.id != 5 %}
    {% if loop.index == 1 %}
        
  • {{ item.value }}
  • {% elif loop.index == 2 %}
  • {{ item.value }}
  • {% elif loop.index == 3 %}
  • {{ item.value }}
  • {% else %}
  • {{ item.value }}
  • {% endif %} {% endfor %}

    模板继承

    模板继承是为了重用模板中的公共内容。一般Web开发中,继承主要使用在网站的顶部菜单、底部。这些内容可以定义在父模板中,子模板直接继承,而不需要重复书写。

    • 标签定义的内容
    {% block top %} {% endblock %}
    
    • 相当于在父模板中挖个坑,当子模板继承父模板时,可以进行填充。
    • 子模板使用 extends 指令声明这个模板继承自哪个模板
    • 父模板中定义的块在子模板中被重新定义,在子模板中调用父模板的内容可以使用super()

    父模板

    • base.html
    {% block top %}
      顶部菜单
    {% endblock top %}
    
    {% block content %}
    {% endblock content %}
    
    {% block bottom %}
      底部
    {% endblock bottom %}
    

    子模板

    • extends指令声明这个模板继承自哪
    {% extends 'base.html' %}
    {% block content %}
     需要填充的内容
    {% endblock content %}
    
    • 模板继承使用时注意点:
      • 不支持多继承
      • 为了便于阅读,在子模板中使用extends时,尽量写在模板的第一行。
      • 不能在一个模板文件中定义多个相同名字的block标签。
      • 当在页面中使用多个block标签时,建议给结束标签起个名字,当多个block嵌套时,阅读性更好

    模板中特有的变量和函数

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

    config

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

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

    request

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

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

    g变量

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

    {{ g.name }}
    

    get_flashed_messages()

    这个函数会返回之前在flask中通过flask()传入的消息的列表,flash函数的作用很简单,可以把由Python字符串表示的消息加入一个消息队列中,再使用get_flashed_message()函数取出它们并消费掉:

    {%for message in get_flashed_messages()%}
        {{message}}
    {%endfor%}

    Web表单

    Web 表单是 Web 应用程序的基本功能。

    它是HTML页面中负责数据采集的部件。表单有三个部分组成:表单标签、表单域、表单按钮。表单允许用户输入数据,负责HTML页面数据采集,通过表单将用户输入的数据提交给服务器。

    在Flask中,为了处理web表单,我们可以使用 Flask-WTF 扩展,它封装了 WTForms,并且它有验证表单数据的功能

    WTForms支持的HTML标准字段

    字段对象 说明
    StringField 文本字段
    TextAreaField 多行文本字段
    PasswordField 密码文本字段
    HiddenField 隐藏文件字段
    DateField 文本字段,值为 datetime.date 文本格式
    DateTimeField 文本字段,值为 datetime.datetime 文本格式
    IntegerField 文本字段,值为整数
    DecimalField 文本字段,值为decimal.Decimal
    FloatField 文本字段,值为浮点数
    BooleanField 复选框,值为True 和 False
    RadioField 一组单选框
    SelectField 下拉列表
    SelectMutipleField 下拉列表,可选择多个值
    FileField 文件上传字段
    SubmitField 表单提交按钮
    FormField 把表单作为字段嵌入另一个表单
    FieldList 一组指定类型的字段

    WTForms常用验证函数

    验证函数 说明
    DataRequired 确保字段中有数据
    EqualTo 比较两个字段的值,常用于比较两次密码输入
    Length 验证输入的字符串长度
    NumberRange 验证输入的值在数字范围内
    URL 验证URL
    AnyOf 验证输入值在可选列表中
    NoneOf 验证输入值不在可选列表中

    使用 Flask-WTF 需要配置参数 SECRET_KEY。

    CSRF_ENABLED是为了CSRF(跨站请求伪造)保护。 SECRET_KEY用来生成加密令牌,当CSRF激活的时候,该设置会根据设置的密匙生成加密令牌。

    代码验证

    使用 html 自带的表单

    • 创建模板文件 login.html,在其中直接写form表单:



    {% for message in get_flashed_messages() %} {{ message }} {% endfor %}
    • 视图函数中获取表单数据验证登录逻辑:
    @app.route('/demo1', methods=["get", "post"])
    def demo1():
        if request.method == "POST":
            # 取到表单中提交上来的三个参数
            username = request.form.get("username")
            password = request.form.get("password")
            password2 = request.form.get("password2")
    
            if not all([username, password, password2]):
                # 向前端界面弹出一条提示(闪现消息)
                flash("参数不足")
            elif password != password2:
                flash("两次密码不一致")
            else:
                # 假装做注册操作
                print(username, password, password2)
                return "success"
    
        return render_template('temp_register.html')
    

    使用 Flask-WTF 实现表单

    • 配置参数,关闭 CSRF 校验
     app.config['WTF_CSRF_ENABLED'] = False
    

    CSRF:跨站请求伪造,后续会讲到

    模板页面:

    {{ form.username.label }} {{ form.username }}
    {{ form.password.label }} {{ form.password }}
    {{ form.password2.label }} {{ form.password2 }}
    {{ form.submit }}

    视图函数:

    
    from flask import Flask,render_template, flash
    #导入wtf扩展的表单类
    from flask_wtf import FlaskForm
    #导入自定义表单需要的字段
    from wtforms import SubmitField,StringField,PasswordField
    #导入wtf扩展提供的表单验证器
    from wtforms.validators import DataRequired,EqualTo
    
    
    app = Flask(__name__)
    app.config['SECRET_KEY']='SECRET_KEY'
    
    #自定义表单类,文本字段、密码字段、提交按钮
    class RegisterForm(FlaskForm):
        username = StringField("用户名:", validators=[DataRequired("请输入用户名")], render_kw={"placeholder": "请输入用户名"})
        password = PasswordField("密码:", validators=[DataRequired("请输入密码")])
        password2 = PasswordField("确认密码:", validators=[DataRequired("请输入确认密码"), EqualTo("password", "两次密码不一致")])
        submit = SubmitField("注册")
    
    #定义根路由视图函数,生成表单对象,获取表单数据,进行表单数据验证
    @app.route('/demo2', methods=["get", "post"])
    def demo2():
        register_form = RegisterForm()
        # 验证表单
        if register_form.validate_on_submit():
            # 如果代码能走到这个地方,那么就代码表单中所有的数据都能验证成功
            username = request.form.get("username")
            password = request.form.get("password")
            password2 = request.form.get("password2")
            # 假装做注册操作
            print(username, password, password2)
            return "success"
        else:
            if request.method == "POST":
                flash("参数有误或者不完整")
    
        return render_template('temp_register.html', form=register_form)
    
    if __name__ == '__main__':
        app.run(debug=True)

    Flask-SQLAlchemy安装及设置

    • SQLALchemy 实际上是对数据库的抽象,让开发者不用直接和 SQL 语句打交道,而是通过 Python 对象来操作数据库,在舍弃一些性能开销的同时,换来的是开发效率的较大提升
    • SQLAlchemy是一个关系型数据库框架,它提供了高层的 ORM 和底层的原生数据库的操作。flask-sqlalchemy 是一个简化了 SQLAlchemy 操作的flask扩展。
    • 文档地址:http://docs.jinkan.org/docs/flask-sqlalchemy

    安装

    • 安装 flask-sqlalchemy
    pip install flask-sqlalchemy
    
    • 如果连接的是 mysql 数据库,需要安装 mysqldb
    pip install flask-mysqldb
    

    数据库连接设置

    • 在 Flask-SQLAlchemy 中,数据库使用URL指定,而且程序使用的数据库必须保存到Flask配置对象的SQLALCHEMY_DATABASE_URI 键中
    app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:[email protected]:3306/test'
    
    • 其他设置:
    # 动态追踪修改设置,如未设置只会提示警告
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
    #查询时会显示原始SQL语句
    app.config['SQLALCHEMY_ECHO'] = True
    
    • 配置完成需要去 MySQL 中创建项目所使用的数据库
    $ mysql -uroot -pmysql
    $ create database test charset utf8;
    
    • 其他配置
    名字 备注
    SQLALCHEMY_DATABASE_URI 用于连接的数据库 URI 。例如:sqlite:////tmp/test.dbmysql://username:password@server/db
    SQLALCHEMY_BINDS 一个映射 binds 到连接 URI 的字典。更多 binds 的信息见用 Binds 操作多个数据库
    SQLALCHEMY_ECHO 如果设置为Ture, SQLAlchemy 会记录所有 发给 stderr 的语句,这对调试有用。(打印sql语句)
    SQLALCHEMY_RECORD_QUERIES 可以用于显式地禁用或启用查询记录。查询记录 在调试或测试模式自动启用。更多信息见get_debug_queries()。
    SQLALCHEMY_NATIVE_UNICODE 可以用于显式禁用原生 unicode 支持。当使用 不合适的指定无编码的数据库默认值时,这对于 一些数据库适配器是必须的(比如 Ubuntu 上 某些版本的 PostgreSQL )。
    SQLALCHEMY_POOL_SIZE 数据库连接池的大小。默认是引擎默认值(通常 是 5 )
    SQLALCHEMY_POOL_TIMEOUT 设定连接池的连接超时时间。默认是 10 。
    SQLALCHEMY_POOL_RECYCLE 多少秒后自动回收连接。这对 MySQL 是必要的, 它默认移除闲置多于 8 小时的连接。注意如果 使用了 MySQL , Flask-SQLALchemy 自动设定 这个值为 2 小时。

    连接其他数据库

    完整连接 URI 列表请跳转到 SQLAlchemy 下面的文档 (Supported Databases) 。这里给出一些 常见的连接字符串。

    • Postgres:
    postgresql://scott:tiger@localhost/mydatabase
    
    • MySQL:
    mysql://scott:tiger@localhost/mydatabase
    
    • Oracle:
    - oracle://scott:[email protected]:1521/sidname
    
    • SQLite (注意开头的四个斜线):
    sqlite:////absolute/path/to/foo.db
    

    常用的SQLAlchemy字段类型

    类型名 python中类型 说明
    Integer int 普通整数,一般是32位
    SmallInteger int 取值范围小的整数,一般是16位
    BigInteger int或long 不限制精度的整数
    Float float 浮点数
    Numeric decimal.Decimal 普通整数,一般是32位
    String str 变长字符串
    Text str 变长字符串,对较长或不限长度的字符串做了优化
    Unicode unicode 变长Unicode字符串
    UnicodeText unicode 变长Unicode字符串,对较长或不限长度的字符串做了优化
    Boolean bool 布尔值
    Date datetime.date 时间
    Time datetime.datetime 日期和时间
    LargeBinary str 二进制文件

    常用的SQLAlchemy列选项

    选项名 说明
    primary_key 如果为True,代表表的主键
    unique 如果为True,代表这列不允许出现重复的值
    index 如果为True,为这列创建索引,提高查询效率
    nullable 如果为True,允许有空值,如果为False,不允许有空值
    default 为这列定义默认值

    常用的SQLAlchemy关系选项

    选项名 说明
    backref 在关系的另一模型中添加反向引用
    primary join 明确指定两个模型之间使用的联结条件
    uselist 如果为False,不使用列表,而使用标量值
    order_by 指定关系中记录的排序方式
    secondary 指定多对多关系中关系表的名字
    secondary join 在SQLAlchemy中无法自行决定时,指定多对多关系中的二级联结条件

    常用的SQLAlchemy查询过滤器

    过滤器 说明
    filter() 把过滤器添加到原查询上,返回一个新查询
    filter_by() 把等值过滤器添加到原查询上,返回一个新查询
    limit 使用指定的值限定原查询返回的结果
    offset() 偏移原查询返回的结果,返回一个新查询
    order_by() 根据指定条件对原查询结果进行排序,返回一个新查询
    group_by() 根据指定条件对原查询结果进行分组,返回一个新查询

    常用的SQLAlchemy查询执行器

    方法 说明
    all() 以列表形式返回查询的所有结果
    first() 返回查询的第一个结果,如果未查到,返回None
    first_or_404() 返回查询的第一个结果,如果未查到,返回404
    get() 返回指定主键对应的行,如不存在,返回None
    get_or_404() 返回指定主键对应的行,如不存在,返回404
    count() 返回查询结果的数量
    paginate() 返回一个Paginate对象,它包含指定范围内的结果

    数据库迁移

    • 在开发过程中,需要修改数据库模型,而且还要在修改之后更新数据库。最直接的方式就是删除旧表,但这样会丢失数据。
    • 更好的解决办法是使用数据库迁移框架,它可以追踪数据库模式的变化,然后把变动应用到数据库中。
    • 在Flask中可以使用Flask-Migrate扩展,来实现数据迁移。并且集成到Flask-Script中,所有操作通过命令就能完成。
    • 为了导出数据库迁移命令,Flask-Migrate提供了一个MigrateCommand类,可以附加到flask-script的manager对象上。

    实际操作顺序:

    • 1.python 文件 db init
    • 2.python 文件 db migrate -m"版本名(注释)"
    • 3.python 文件 db upgrade 然后观察表结构
    • 4.根据需求修改模型
    • 5.python 文件 db migrate -m"新版本名(注释)"
    • 6.python 文件 db upgrade 然后观察表结构
    • 7.若返回版本,则利用 python 文件 db history查看版本号
    • 8.python 文件 db downgrade(upgrade) 版本号

     

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

    • before_first_request
      • 在处理第一个请求前执行
    • before_request
      • 在每次请求前执行
      • 如果在某修饰的函数中返回了一个响应,视图函数将不再被调用
    • after_request
      • 如果没有抛出错误,在每次请求后执行
      • 接受一个参数:视图函数作出的响应
      • 在此函数中可以对响应值在返回之前做最后一步修改处理
      • 需要将参数中的响应在此参数中进行返回
    • teardown_request:
      • 在每次请求后执行
      • 接受一个参数:错误信息,如果有相关错误抛

    保持状态: session服务器 cookie客户端

    @app.route("/cookie")

    def set_cookie():

        response = make_response("到这里不知道写有没有人看,如果有请赞一个哦!")

        respones.set_cookie("username","itheima",mac_age=3360)   

        return response

    from flask import Flask,request
    #获取cookie
    @app.route('/request')
    def resp_cookie():
        resp = request.cookies.get('username')
        return resp

    Session

    • 对于敏感、重要的信息,建议要存储在服务器端,不能存储在浏览器中,如用户名、余额、等级、验证码等信息
    • 在服务器端进行状态保持的方案就是Session
    • Session依赖于Cookie

    session数据的获取

    session:请求上下文对象,用于处理http请求中的一些数据内容

    @app.route('/index1')
    def index1():
        session['username'] = 'itcast'
        return redirect(url_for('index'))
    @app.route('/')
    def index():
        return session.get('username')

    防止 CSRF 攻击

    步骤

    1. 在客户端向后端请求界面数据的时候,后端会往响应中的 cookie 中设置 csrf_token 的值
    2. 在 Form 表单中添加一个隐藏的的字段,值也是 csrf_token
    3. 在用户点击提交的时候,会带上这两个值向后台发起请求
    4. 后端接受到请求,以会以下几件事件:
      • 从 cookie中取出 csrf_token
      • 从 表单数据中取出来隐藏的 csrf_token 的值
      • 进行对比
    5. 如果比较之后两值一样,那么代表是正常的请求,如果没取到或者比较不一样,代表不是正常的请求,不执行下一步操作

    Blueprint概念

    简单来说,Blueprint 是一个存储操作方法的容器,这些操作在这个Blueprint 被注册到一个应用之后就可以被调用,Flask 可以通过Blueprint来组织URL以及处理请求。

    Flask使用Blueprint让应用实现模块化,在Flask中,Blueprint具有如下属性:

    • 一个应用可以具有多个Blueprint
    • 可以将一个Blueprint注册到任何一个未使用的URL下比如 “/”、“/sample”或者子域名
    • 在一个应用中,一个模块可以注册多次
    • Blueprint可以单独具有自己的模板、静态文件或者其它的通用操作方法,它并不是必须要实现应用的视图和函数的
    • 在一个应用初始化时,就应该要注册需要使用的Blueprint

    但是一个Blueprint并不是一个完整的应用,它不能独立于应用运行,而必须要注册到某一个应用中。

    初识蓝图

    蓝图/Blueprint对象用起来和一个应用/Flask对象差不多,最大的区别在于一个 蓝图对象没有办法独立运行,必须将它注册到一个应用对象上才能生效

    使用蓝图可以分为三个步骤

    • 1,创建一个蓝图对象
    admin=Blueprint('admin',__name__)
    
    • 2,在这个蓝图对象上进行操作,注册路由,指定静态文件夹,注册模版过滤器
    @admin.route('/')
    def admin_home():
        return 'admin_home'
    
    • 3,在应用对象上注册这个蓝图对象
    app.register_blueprint(admin,url\_prefix='/admin')
    

    当这个应用启动后,通过/admin/可以访问到蓝图中定义的视图函数

    蓝图的url前缀

    • 当我们在应用对象上注册一个蓝图时,可以指定一个url_prefix关键字参数(这个参数默认是/)
    • 在应用最终的路由表 url_map中,在蓝图上注册的路由URL自动被加上了这个前缀,这个可以保证在多个蓝图中使用相同的URL规则而不会最终引起冲突,只要在注册蓝图时将不同的蓝图挂接到不同的自路径即可

    • url_for

    url_for('admin.index') # /admin/
    

    注册静态路由

    和应用对象不同,蓝图对象创建时不会默认注册静态目录的路由。需要我们在 创建时指定 static_folder 参数。

    下面的示例将蓝图所在目录下的static_admin目录设置为静态目录

    admin = Blueprint("admin",__name__,static_folder='static_admin')
    app.register_blueprint(admin,url_prefix='/admin')
    

    现在就可以使用/admin/static_admin/ 访问static_admin目录下的静态文件了 定制静态目录URL规则 :可以在创建蓝图对象时使用 static_url_path 来改变静态目录的路由。下面的示例将为 static_admin 文件夹的路由设置为 /lib

    admin = Blueprint("admin",__name__,static_folder='static_admin',static_url_path='/lib')
    app.register_blueprint(admin,url_prefix='/admin')
    

    设置模版目录

    蓝图对象默认的模板目录为系统的模版目录,可以在创建蓝图对象时使用 template_folder 关键字参数设置模板目录

    admin = Blueprint('admin',__name__,template_folder='my_templates')
    

    注:如果在 templates 中存在和 my_templates 同名文件,则系统会优先使用 templates 中的文件 参考链接:https://stackoverflow.com/questions/7974771/flask-blueprint-template-folder

     

     

     

     

     

     

    你可能感兴趣的:(Flask内容整理入门宝典 !)