Flask框架知识总结（入门篇）

一.Flask基础

1.1 Flask简介

Flask诞生于2010年，是用Python语言基于Werkzeug工具箱编写的轻量级Web开发框架。Flask本身相当于一个内核，其他几乎所有的功能都要用到扩展（邮件扩展Flask-Mail，用户认证Flask-Login），都需要用第三方的扩展来实现。其 WSGI 工具箱采用 Werkzeug（路由模块），模板引擎则使用 Jinja2。这两个也是Flask框架的核心。Python最出名的框架要数Django，此外还有Flask、Tornado等框架。虽然Flask不是最出名的框架，但是Flask应该算是最灵活的框架之一，这也是Flask受到广大开发者喜爱的原因。

flask中常用扩展包

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

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

1.2 Flask安装环境

使用虚拟环境安装Flask，可以避免包的混乱和版本的冲突，虚拟环境是Python解释器的副本，在虚拟环境中你可以安装扩展包，为每个程序单独创建的虚拟环境，可以保证程序只能访问虚拟环境中的包。而不会影响系统中安装的全局Python解释器，从而保证全局解释器的整洁。当然可以用主流的容器docker进行安装，后面会专门进行介绍docker的使用。
虚拟环境使用virtualenv创建，可以查看系统是否安装了virtualenv：

$ virtualenv --version

安装虚拟环境

pip install virtualenv

此命令需要管理员权限。您可以在Linux / Mac OS上的 pip 之前添加 sudo 。
如果您使用的是Windows，请以管理员身份登录。在Ubuntu上， virtualenv可以使用它的包管理器安装。

sudo apt-get install virtualenv

安装后，将在文件夹中创建新的虚拟环境。

mkdir newproject
cd newproject
virtualenv venv

要在 Linux / OS X 上激活相应的环境，请使用以下命令：

venv/bin/activate

要在 Windows 上激活相应的环境，可以使用以下命令：

venv\scripts\activate

我们现在准备在这个环境中安装Flask：

pip install Flask

1.3 requirements 文件

Python 项目中必须包含一个 requirements.txt 文件，用于记录所有依赖包及其精确的版本号，以便在新环境中进行部署操作。
在虚拟环境使用以下命令将当前虚拟环境中的依赖包以版本号生成至文件中：

pip freeze >requirements.txt

需求文件的内容示例如下：

alembic==0.9.2
blinker==1.4
click==6.7
dominate==2.3.1
Flask==0.10.1
Flask-Bootstrap==3.3.7.1
Flask-Login==0.4.0
Flask-Mail==0.9.1
Flask-Migrate==2.0.4
Flask-Redis==0.3.0
Flask-Script==2.0.5
Flask-SQLAlchemy==2.2
Flask-Testing==0.6.2
Flask-WTF==0.14.2
gunicorn==19.7.1
itsdangerous==0.24
Jinja2==2.9.6
Mako==1.0.6
MarkupSafe==1.0
MySQL-python==1.2.5
mysqlclient==1.3.10
PyMySQL==0.7.11
python-dateutil==2.6.0
python-editor==1.0.3
redis==2.10.5
six==1.10.0
SQLAlchemy==1.1.10
uWSGI==2.0.15
visitor==0.1.3
Werkzeug==0.12.2
WTForms==2.1
xmltodict==0.11.0

当需要创建这个虚拟环境的完全副本，可以创建一个新的虚拟环境，并在其上运行以下命令：

pip install -r requirements.txt

1.4 Hello World 程序

flask运行过程

• 当客户端想要获取资源时，一般会通过浏览器发起HTTP请求。
• 此时，Web服务器会把来自客户端的所有请求都交给Flask程序实例。
• 程序实例使用Werkzeug来做路由分发（URL请求和视图函数之间的对应关系）。
• 根据每个URL请求，找到具体的视图函数并进行调用。
• Flask调用视图函数后，可以返回两种内容：
  1. 字符串内容：将视图函数的返回值作为响应的内容，返回给客户端(浏览器)。
  2. HTML模版内容：获取到数据后，把数据传入HTML模板文件中，模板引擎负责渲染HTTP响应数据，然后返回响应数据给客户端(浏览器)。

实例如下：

• 新建Flask项目
• 导入Flask类

from flask import Flask

• Flask函数接收一个参数name，它会指向程序所在的模块

app = Flask(__name__)

• 装饰器的作用是将路由映射到视图函数index

@app.route('/')
def index():
    return 'Hello World'

• Flask应用程序实例的run方法启动WEB服务器

if __name__ == '__main__':
    app.run()

1.5 路由定义的基本方式

请求方式限定

使用 methods 参数指定可接受的请求方式，可以是多种

@app.route('/',methods=['GET', 'POST'])
def hello():
    return 'hello world'

给路由传参示例

有时我们需要将同一类URL映射到同一个视图函数处理，比如：使用同一个视图函数 来显示不同用户的订单信息。
路由传递的参数默认当做string处理

@app.route('/orders/<order_id>')
def hello_itheima(order_id):
    # 此处的逻辑: 去查询数据库改用户的订单信息, 并返回
    print(type(order_id)) # 类型为unicode
    return 'hello itcast %d' % order_id

这里指定int, 会调用系统的路由转换器进行匹配和转换.

@app.route('/orders/<int:order_id>')
def hello_itheima(order_id):
    print(type(order_id)) # 类型为int
    return 'hello itcast %d' % order_id

二.模板

2.1 Jinja2模板引擎

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

• 视图函数只负责业务逻辑和数据处理(业务逻辑方面)。
• 而模板则取到视图函数的数据结果进行展示(视图展示方面)。
• 代码结构清晰，耦合度低

注释

• 使用 {# #} 进行注释

{# 这是注释 #}

变量代码块

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

{{ post.title }}

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

{{your_dict['key']}}
{{your_list[0]}}

控制代码块

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

{% if user %}
    {{ user }}
{% else %}
    hello!

{% for index in indexs %}
    {{ index }} 
{% endfor %}

2.2 过滤器

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

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

{{variable | filter_name(*args)}}

• 如果没有任何参数传给过滤器,则可以把括号省略掉。

{{variable | filter_name}}

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

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

常见内建过滤器
字符串操作

• safe：禁用转义

<p>{{ '<em>hello</em>' | safe }}</p>

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

<p>{{ 'hello' | capitalize }}</p>

1. lower：把值转成小写

<p>{{ 'HELLO' | lower }}</p>

• upper：把值转成大写

<p>{{ 'hello' | upper }}</p>

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

<p>{{ 'hello' | title }}</p>

• reverse：字符串反转

<p>{{ 'olleh' | reverse }}</p>

• format：格式化输出

<p>{{ '%s is %d' | format('name',17) }}</p>

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

<p>{{ '<em>hello</em>' | striptags }}</p>

• truncate: 字符串截断

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

列表操作

• first：取第一个元素

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

• last：取最后一个元素

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

• length：获取列表长度

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

• sum：列表求和

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

• sort：列表排序

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

语句块过滤

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

2.3 Flask-WTF表单

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页面中直接写form表单：

示例
使用普通方式实现表单

在HTML页面中直接写form表单：

<form method="post">
    <label>用户名:</label><input type="text" name="username"><br>
    <label>密码:</label><input type="password" name="password"><br>
    <label>确认密码:</label><input type="password" name="password2"><br>
    <input type="submit" value="提交"><br>
    {% for message in get_flashed_messages() %}
        {{ message }}
    {% endfor %}
</form>

视图函数中获取表单数据：

from flask import Flask,render_template,request

app.secret_key = 'heima'

@app.route('/', methods=['GET', 'POST'])
def hello_world():

    # 1. 判断请求方式是post
    if request.method == 'POST':

        # 2. 获取参数, 并效验参数完整性, 如果有问题就进行flash
        username = request.form.get('username')
        password = request.form.get('password')
        password2 = request.form.get('password2')
        if not all([username, password, password2]):
            flash('params error')

        # 3. 效验密码
        elif password != password2:
            flash('password error')

        # 4. 没有问题就返回'success'
        else:
            print username
            return 'success'

    return render_template('wtf.html')

使用Flask-WTF实现表单
模板页面：

<form method="post">
    {#设置csrf_token#}
    {{ form.csrf_token() }}
    {{ form.username.label }}{{ form.username }}<br>
    {{ form.password.label }}{{ form.password }}<br>
    {{ form.password2.label }}{{ form.password2 }}<br>
    {{ form.input }}<br>
</form>

视图函数：

#coding=utf-8
from flask import Flask, render_template, request, flash

#导入wtf扩展的表单类
from flask_wtf import FlaskForm

#导入自定义表单需要的字段
from wtforms import SubmitField,StringField,PasswordField

#导入wtf扩展提供的表单验证器
from wtforms.validators import DataRequired,EqualTo

# 解决编码问题
import sys
reload(sys)
sys.setdefaultencoding("utf-8")

app = Flask(__name__)
app.config['SECRET_KEY']='heima'

#自定义表单类，文本字段、密码字段、提交按钮
# 需要自定义一个表单类
class RegisterForm(FlaskForm):
    username = StringField('用户名:', validators=[DataRequired()]})
    password = PasswordField('密码:', validators=[DataRequired()])
    password2 = PasswordField('确认密码:', validators=[DataRequired(), EqualTo('password', '密码输入不一致')])
    input = SubmitField('提交')

#定义根路由视图函数，生成表单对象，获取表单数据，进行表单数据验证
@app.route('/form', methods=['GET', 'POST'])
def form():
    register_form = RegisterForm()

    if request.method == 'POST':
        # 调用validate_on_submit方法, 可以一次性执行完所有的验证函数的逻辑
        if register_form.validate_on_submit():
            # 进入这里就表示所有的逻辑都验证成功
            username = request.form.get('username')
            password = request.form.get('password')
            password2 = request.form.get('password2')
            print username
            return 'success'

        else:
            #message = register_form.errors.get('password2')[0]
            #flash(message)
            flash('参数有误')

    return render_template('wtf.html', form=register_form)

三.数据库

3.1 Flask中使用数据库

Flask-SQLAlchemy扩展

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

安装 flask-sqlalchemy

pip install flask-sqlalchemy

如果连接的是mysql数据库,需要安装mysqldb

pip install flask-mysqldb

使用Flask-SQLAlchemy管理数据库

在Flask-SQLAlchemy中，数据库使用URL指定，而且程序使用的数据库必须保存到Flask配置对象的SQLALCHEMY_DATABASE_URI键中。

Flask的数据库设置：

app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:mysql@127.0.0.1:3306/test'

其他设置：

# 动态追踪修改设置，如未设置只会提示警告, 不建议开启
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# 查询时会显示原始SQL语句
app.config['SQLALCHEMY_ECHO'] = True

名字	备注
SQLALCHEMY_DATABASE_URI	用于连接的数据库 URI 。例如:sqlite:tmp/test.dbmysql://username:password@server/db
SQLALCHEMY_BINDS	一个映射 binds 到连接 URI 的字典
SQLALCHEMY_ECHO	如果设置为Ture， SQLAlchemy 会记录所有 发给 stderr 的语句，这对调试有用。(打印sql语句)
SQLALCHEMY_RECORD_QUERIES	可以用于显式地禁用或启用查询记录。查询记录 在调试或测试模式自动启用。更多信息见get_debug_queries()。
SQLALCHEMY_POOL_SIZE	数据库连接池的大小。默认是引擎默认值（通常 是 5 ）
SQLALCHEMY_POOL_TIMEOUT	设定连接池的连接超时时间。默认是 10 。
SQLALCHEMY_POOL_RECYCLE	多少秒后自动回收连接。这对 MySQL 是必要的， 它默认移除闲置多于 8 小时的连接。注意如果 使用了 MySQL ， Flask-SQLALchemy 自动设定 这个值为 2 小时。

常用的SQLAlchemy字段类型

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

常用的SQLAlchemy列选项

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

常用的SQLAlchemy关系选项

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

3.2 数据库基本操作

一. 增删改操作
1.基本概念

• 在Flask-SQLAlchemy中，插入、修改、删除操作，均由数据库会话管理。
  会话用db.session表示。在准备把数据写入数据库前，要先将数据添加到会话中然后调用 commit() 方法提交会话。
• 在Flask-SQLAlchemy中，查询操作是通过query对象操作数据。
  最基本的查询是返回表中所有数据，可以通过过滤器进行更精确的数据库查询。

db.session.add(role)    添加到数据库的session中
db.session.add_all([user1, user2]) 添加多个信息到session中
db.session.commit()     提交数据库的修改(包括增/删/改)
db.session.rollback()   数据库的回滚操作
db.session.delete(user) 删除数据库(需跟上commit)

2.示例
2.1 在视图函数中定义模型类

from flask import Flask
from flask_sqlalchemy import SQLAlchemy


app = Flask(__name__)

#设置连接数据库的URL
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:mysql@127.0.0.1:3306/Flask_test'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
#查询时会显示原始SQL语句
app.config['SQLALCHEMY_ECHO'] = True

db = SQLAlchemy(app)

class Role(db.Model):
    # 定义表名
    __tablename__ = 'roles'
    # 定义列对象
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(32), unique=True)
    user = db.relationship('User', backref='role')

    #repr()方法显示一个可读字符串
    def __repr__(self):
        return '<Role: %s %s>' % (self.name, self.id)

class User(db.Model):
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(32), unique=True, index=True)
    email = db.Column(db.String(32),unique=True)
    password = db.Column(db.String(32))
    role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))

    def __repr__(self):
        return '<User: %s %s %s %s>' % (self.name, self.id, self.email, self.password)

if __name__ == '__main__':

    # 创建表：
    db.create_all()
    # 删除表
    db.drop_all()

    app.run(debug=True)
#### 2.2 数据的增删改
```python
# 进入ipython一次执行
In [1]: from demo3_sqlalchemy import *

# 添加一条Role数据
In [2]: role = Role(name='admin')
In [3]: db.session.add(role)
In [4]: db.session.commit()

# 添加一条User数据, 数据有误可以使用回滚, 将add的对象从session移除
In [5]: user = User(name='zhangsan')
In [6]: db.session.add(user)
In [7]: db.session.rollback()
In [9]: user.role_id = 1
In [6]: db.session.add(user)
In [4]: db.session.commit()

# 修改数据
In [13]: user.name = 'lisi'
In [14]: db.session.commit()

# 删除数据
In [16]: db.session.delete(user)
In [17]: db.session.commit()

二. 查询操作

1.基本概念
1.1 常用的SQLAlchemy查询过滤器

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

1.2 常用的SQLAlchemy查询执行器

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

2.示例

2.1 插入角色数据

ro1 = Role(name='admin')
db.session.add(ro1)
db.session.commit()
#再次插入一条数据
ro2 = Role(name='user')
db.session.add(ro2)
db.session.commit()

2.2 一次插入多条数据

us1 = User(name='wang',email='wang@163.com',password='123456',role_id=ro1.id)
us2 = User(name='zhang',email='zhang@189.com',password='201512',role_id=ro2.id)
us3 = User(name='chen',email='chen@126.com',password='987654',role_id=ro2.id)
us4 = User(name='zhou',email='zhou@163.com',password='456789',role_id=ro1.id)
us5 = User(name='tang',email='tang@itheima.com',password='158104',role_id=ro2.id)
us6 = User(name='wu',email='wu@gmail.com',password='5623514',role_id=ro2.id)
us7 = User(name='qian',email='qian@gmail.com',password='1543567',role_id=ro1.id)
us8 = User(name='liu',email='liu@itheima.com',password='867322',role_id=ro1.id)
us9 = User(name='li',email='li@163.com',password='4526342',role_id=ro2.id)
us10 = User(name='sun',email='sun@163.com',password='235523',role_id=ro2.id)
db.session.add_all([us1,us2,us3,us4,us5,us6,us7,us8,us9,us10])
db.session.commit()

2.3 查询演练
完成以下查询：

1. 查询所有用户数据
2. 查询有多少个用户
3. 查询第1个用户
4. 查询id为4的用户[3种方式]

1. 查询所有用户数据
# all()返回查询到的所有对象
User.query.all()

2. 查询有多少个用户
User.query.count()

3. 查询第1个用户
User.query.first()

4. 查询id为4的用户[3种方式]
# filter_by直接用属性名，比较用=, filter用类名.属性名，比较用==
# filter_by用于查询简单的列名，不支持比较运算符
# filter比filter_by的功能更强大，支持比较运算符，支持or_、in_等语法。
User.query.get(4)
User.query.filter_by(id=4).first()  #属性 =
User.query.filter(User.id==4).first() #对象名.属性 ==
User.query.filter_by(id=4).first()  #属性 =

如果你的眼目只关注地下，你永远不知道向上看有多快乐。