标签：flask

flask-表单

原生表单

1.添加模板文件login.html

<form method="post" action="{{ url_for('check') }}">
    用户名：<input type="text" name="username">
    <input type="submit" value="登陆">
</form>

2.视图函数

# 登陆
@app.route('/login/', methods=['GET', 'POST'])
def login():
    return render_template('login.html')

# 校验
@app.route('/check/', methods=['GET', 'POST'])
def check():
    return '登陆成功, %s~' % request.form['username']

3.将登陆页面和校验的路由合并

@app.route('/login/', methods=['GET', 'POST'])
def login():
    if request.method == 'GET':
        return render_template('login.html')
    return '登陆成功, %s~' % request.form['username']

一个路由处理时，表单的action属性不用书写

flask-wtf

1.说明

​是一个用于表单处理的扩展库，提供了CSRF、校验等功能，使用非常方便。

2.安装

pip install flask-wtf

3.使用

# 原生渲染
# 导入表单基类
from flask_wtf import FlaskForm
# 导入相关类型
from wtforms import StringField, SubmitField
# 导入验证器
from wtforms.validators import DataRequired

# CSRF需要
app.config['SECRET_KEY'] = 'idandan'

# 定义表单类
class NameForm(FlaskForm):
    name = StringField('账号：', validators=[DataRequired()])
    submit = SubmitField('登陆')


@app.route('/formTest/')
def formTest():
    # 创建表单对象
    form = NameForm()
    return render_template('formTest.html', form = form)


# html
<form>
    {{ form.hidden_tag() }}
    {{ form.name .label()}} {{ form.name(id = 'username', class  = 'username') }}
    {{ form.submit }}
</form>



# bootstrap渲染
# 设置bootstrap本地库中的文件
app.config['BOOTSTRAP_SERVER_LOCAL'] = True

# html
{% extends 'bootstrap/base.html' %}
{# 导入 #}
{% import 'bootstrap/wtf.html' as wtf %}

{% block title %}
    表单渲染
{% endblock %}

{% block content %}
    <div class="container">
        {{ wtf.quick_form(form) }}
    </div>
{% endblock %}

4.表单校验

@app.route('/formTest/', methods=['GET', 'POST'])
def formTest():
    # 创建表单对象
    form = NameForm()
    # return render_template('formTest.html', form = form)
    # return render_template('bootForm.html', form = form)

    # 表单校验
    name = None
    if form.validate_on_submit():
        name = form.name.data
        form.name.data = ''
    return render_template('bootForm.html', form = form, name = name)


# html
{% extends 'bootstrap/base.html' %}

{# 导入 #}
{% import 'bootstrap/wtf.html' as wtf %}

{% block title %}
    表单渲染
{% endblock %}

{% block content %}
    <h1>
        Hi,
        {% if name %}
            {{ name }}!
        {% else %}
            Stranger!
        {% endif %}
    </h1>

    <div class="container">
        {{ wtf.quick_form(form) }}
    </div>
{% endblock %}

5.POST重定向GET

@app.route('/formTest/', methods=['GET', 'POST'])
def formTest():
    # 创建表单对象
    form = NameForm()

    # 表单校验
    name = None
    if form.validate_on_submit():
        session['name'] = form.name.data
        form.name.data = ''
        return redirect(url_for('formTest'))
    name = session.get('name')
    return render_template('bootForm.html', form = form, name = name)

6.常见的字段类型

7.常见验证器类

8.自定义字段验证

# 定义表单类
class NameForm(FlaskForm):
    name = StringField('账号：', validators=[DataRequired()])
    submit = SubmitField('登陆')

    # 自定义字段验证函数，格式是写一个‘valudate_字段名’函数
    def validate_name(self, field):
        if len(field.data) < 6:
            raise ValidationError('账号长度不能小于6个字符')

flash消息

1.说明

​ 当用户请求发出后，用户状态发生了改变，需要给出提示、警告等信息时，通常可以通过弹窗的形式给出指示，用户可以跟据提示进行下一步操作，也可手动取消显示。

2.使用

​在合适的时候书写flash消息，调用flash函数

@app.route('/formTest/', methods=['GET', 'POST'])
def formTest():
    # 创建表单对象
    form = NameForm()
    # return render_template('formTest.html', form = form)
    # return render_template('bootForm.html', form = form)

    # 表单校验
    name = None
    if form.validate_on_submit():
        oldName = session.get('name')
        if oldName is not None and oldName != form.name.data:
            flash('Change your name!')
        session['name'] = form.name.data
        return redirect(url_for('formTest'))
    name = session.get('name')
    return render_template('bootForm.html', form = form, name = name)


# html
{% for message in get_flashed_messages() %}
    <h3>{{ message }}</h3>
{% endfor %}

若好多页面都有弹出消息，可以将flash消息放在基础模板中展示。

flask-moment

1.说明

​专门负责时间本地化显示的扩展库，使用非常方便 。

2.安装

pip install flask-moment

3.使用

# 导入类库
from flask_moment import Moment
# 创建对象
moment = Moment(app)

from datetime import datetime, timedelta
@app.route('/moment/')
def moment():
    current_time = datetime.utcnow() + timedelta(seconds=-3600)  # 伪造时间
    return render_template('moment.html', current_time=current_time)

# HTML
{#{% extends 'bootstrap/base.html' %}#}
{% block content %}
    <div class="time">
        <h1>时间本地化显示</h1>
        <h3>距离：{{ moment(current_time).fromNow() }}</h3>
        <h3>时间：{{ moment(current_time).format('LLLL') }}</h3>
    </div>
{% endblock %}

{#加载jquery和moment，因为moment.js需要依赖,使用bootstrap时就不需要再加载jquery#}
{{ moment.include_jquery() }}
{{ moment.include_moment() }}

模板引擎

模板引擎

说明：

模板文件就是按照特定规则书写的一个负责展示效果的html文件；模板引擎就是提供了特定规则的解释和替换的功能。

Jinja2：

在Flask中使用的就是该模板引擎，由Flask核心开发组人员开发。

jinja2使用

1.准备工作，目录结构

project/
manage.py  # 项目的启动控制文件
    templates/  # 所有的模板文件

2.渲染模板文件

在templates下创建一个模板文件（hello.html），内容如下：

<h1>渲染字符串</h1>

​模板渲染

@app.route('/')
def index():
    # return '模板引擎测试'

    # 渲染模板文件
    # return render_template('hello.html')

    # 渲染字符串
    return render_template_string('<h1>渲染字符串</h1>')

3.使用变量

​在templates下创建一个模板文件（hello.html），内容如下：

<h1>Nice，{{ g.name }}</h1>

​
模板渲染

@app.route('/var/')
def va():
    # g对象，在模板使用中不需要分配
    g.name = 'Nian'
    # return render_template('hello.html', name='dandan')
    # return render_template_string('<h1>{{ name }}</h1>', name='dandan')
    return render_template_string('<h1>{{ g.name }}</h1>')

4.使用函数

​在模板文件中可以使用特定的函数，对指定的变量处理后再显示，用法如下：

<h1>Nice，{{ g.name | upper }}</h1>

​常用函数

5.流程控制

​分支语句（if-else）

    {% if name %}
        <h1>{{ name }}</h1>
    {% else %}
        <h1>Stranger</h1>
    {% endif %}


@app.route('/control/')
def control():
    # return render_template('if-else.html', name = 'Nian')
    return render_template('if-else.html')

​循环语句

    <ol>
        {% for i in range(1, 5) %}
            <li>{{ i }}</li>
        {% endfor %}
    </ol>

6.文件包含

​include1.html

# include.html
<h1>Include 1</h1>

{% include 'include2.html' %}


# include2.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>被包含</title>
</head>
<body>
    include 2
</body>
</html>

7.宏的使用

    {# 定义宏 #}
    {% macro show_name(name) %}
        <h1>Hello, {{ name }}</h1>
    {% endmacro %}


    {# 调用宏 #}
    {{ show_name(name) }}


    # 宏的使用
    @app.route('/macro/')
    def macro():
        # return render_template('macro.html', name = 'Nian')
        return render_template('macro2.html', name = 'dandan')

  说明：
      采用类似Python中的函数的形式进行定义和调用，可以把特定功能的内容定义为一个宏，哪里使用哪里调用即可。

8.模板继承

# parents.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{% block title %}父级标题{% endblock %}</title>
</head>
<body>
    {% block body %}
        默认内容
    {% endblock %}
</body>
</html>


# children.html
{% extends 'parents.html ' %}

{% block title %}
    丹丹测试
{% endblock %}

{% block body %}
    这是模板继承   这是=》{{ super() }}
{% endblock %}

flask-bootstrap

1.安装

pip install flask-bootstrap

2.使用：

from flask_bootstrap import Bootstrap

# 创建实例
app = Flask(__name__)
bootstrap = Bootstrap(app)

3.测试模板文件boot.html

{# 继承自bootstrap模板 #}
{% extends 'bootstrap/base.html' %}

{% block title %}
    用户注册
{% endblock %}

{% block content %}
    <div class="container">
        欢迎丹丹来注册
    </div>
{% endblock %}

4.bootstrap继承模板base.html中定义的block

使用bootstrap时，发现重写block后原来的显示效果消失，可能是忘了调用super

定义项目基础模板

1.说明：

一个项目中，很多页面都很相似，只有细微的差别，如果每个页面都定制，势必会有大量的重复代码。为了简化这种重复工作，通常我们会为项目定制一个基础模板，让它继承自bootstrap,其他页面继承自该基础模板，只需稍微定制即可。

2.步骤

1.从bootcss.com复制一个导航条
2.将container-fluid改为container
3.根据需要，定制显示内容

3.基础模板文件base.html

{% extends 'bootstrap/base.html' %}

{% block title %}
    丹丹的标题
{% endblock %}

{% block navbar %}
    <nav class="navbar navbar-inverse">
  <div class="container">
    <!-- Brand and toggle get grouped for better mobile display -->
    <div class="navbar-header">
      <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
        <span class="sr-only">Toggle navigation</span>
        <span class="icon-bar"></span>
        <span class="icon-bar"></span>
        <span class="icon-bar"></span>
      </button>
      <a class="navbar-brand" href="#">首页</a>
    </div>

    <!-- Collect the nav links, forms, and other content for toggling -->
    <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
      <ul class="nav navbar-nav">
        <li class="active"><a href="#">Link <span class="sr-only">(current)</span></a></li>
        <li><a href="#">Link</a></li>
        <li class="dropdown">
          <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">Dropdown <span class="caret"></span></a>
          <ul class="dropdown-menu">
            <li><a href="#">Action</a></li>
            <li><a href="#">Another action</a></li>
            <li><a href="#">Something else here</a></li>
            <li role="separator" class="divider"></li>
            <li><a href="#">Separated link</a></li>
            <li role="separator" class="divider"></li>
            <li><a href="#">One more separated link</a></li>
          </ul>
        </li>
      </ul>
      <form class="navbar-form navbar-left">
        <div class="form-group">
          <input type="text" class="form-control" placeholder="Search">
        </div>
        <button type="submit" class="btn btn-default">Submit</button>
      </form>
      <ul class="nav navbar-nav navbar-right">
        <li><a href="#">Link</a></li>
        <li class="dropdown">
          <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">Dropdown <span class="caret"></span></a>
          <ul class="dropdown-menu">
            <li><a href="#">Action</a></li>
            <li><a href="#">Another action</a></li>
            <li><a href="#">Something else here</a></li>
            <li role="separator" class="divider"></li>
            <li><a href="#">Separated link</a></li>
          </ul>
        </li>
      </ul>
    </div><!-- /.navbar-collapse -->
  </div><!-- /.container-fluid -->
</nav>
{% endblock %}


{# 定制内容 #}
{% block content %}
    <div class="container">
        {# 这里可以为弹出内容显示预留位置 #}
        {% block page_content %}
            默认内容
        {% endblock %}
    </div>
{% endblock %}

错误页面定制

1.添加视图函数

# 错误页面定制
@app.errorhandler(404)
def error(e):
    return render_template('404.html')

2.定制404.html

{% extends 'base.html' %}

{% block title %}
    出错了
{% endblock %}

{% block content %}
    <h1>找不见了吧@_@</h1>
{% endblock %}

回顾url_for函数

1.根据视图函数名反向构造路由地址，路由需要的直接构造，多出来的参数以GET方式 传递

2.若需要构造完整的外部链接，需要添加_extenal=True参数

3.通常网站中的点击链接都是url_for构造的

<li><a href="{{ url_for('register') }}">注册</a></li>

加载静态资源

1.flask框架中静态资源的默认目录为static，项目目录如下：

project/
    manage.py  # 启动控制文件
    static/  # 存放静态资源
    templates/  # 存放模板文件

2.加载网站图标

{# 加载收藏夹的图标 #}
{% block head %}
    {{ super }}
    <link rel="icon" type="image/x-icon" href="{{ url_for('static', filename = 'bg.png') }}">
{% endblock %}

3.静态资源加载

# manage.py
# 加载静态文件
@app.route('/source/')
def source():
    return render_template('static.html')

# static.html
{% block styles %}
    {{ super() }}
    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename = 'css.css') }}">
{% endblock %}

4.设置本地日期和时间

# base.html
{#引入moment.js类#}
{% block scripts %}
    {{ super() }}
    {{ moment.include_moment() }}
{% endblock %}



# manage.py
# 使用Flask-Monment本地化日期和时间
from datetime import datetime
@app.route('/testtime/')
def testtime():
    return render_template('testtime.html', current_time = datetime.utcnow())


# testtime.html
  {% block content %}
    <p>The local date and time is {{ moment(current_time).format('LLL') }}</p>
{% endblock %}

5.表单

# maange.py
from flask import Flask, render_template, session, redirect, url_for
from flask_script import Manager
from flask_bootstrap import Bootstrap
from wtforms import SubmitField, StringField, IntegerField
from wtforms.validators import Required
from flask_wtf import Form

# 实例化对象
app = Flask(__name__)
bootstrap = Bootstrap(app)
manager = Manager(app)
app.config['SECRET_KEY'] = 'idandan'

class PersonInfo(Form):
    name = StringField('Name: ', validators=[Required()])
    age = IntegerField('age: ', validators=[Required()])
    submit = SubmitField('Submit')

@app.route('/', methods=['GET', 'POST'])
def index():
    name = None
    age = None
    form = PersonInfo()

    if form.validate_on_submit():
        session['name'] = form.name.data
        session['age'] = form.age.data
        return redirect(url_for('index'))
        # name = form.name.data
        # age = form.age.data
        # form.name.data = ''
        # form.age.data = ''  # ? 不能清空数据？？？
    # return render_template('personInfo.html', form = form, name = session.get('name'), age = session.get('age'))
    return render_template('personInfo.html', form = form)

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



# personInfo.html
{% import 'bootstrap/wtf.html' as wtf %}

{% block title %}
    Form
{% endblock %}

{% block content %}
{#    <h1>#}
{#        Nice,#}
{#        {% if name %}#}
{#            {{ name }}, your age is {{ age }}?#}
{#        {% else %}#}
{#            Stranger!#}
{#        {% endif %}#}
{#    </h1>#}

    <h1>
        Nice,
        {% if session.get('name') %}
            {{ session.get('name') }}, your age is {{ session.get('age') }}?
        {% else %}
            Stranger!
        {% endif %}
    </h1>

    {{ wtf.quick_form(form) }}

{% endblock %}

Flask入门

web工作原理

1、C/S和B/S架构

​ C/S：客户端/服务器

​ B/S：浏览器/服务器

2、B/S架构工作原理

​ 客户端（浏览器） <=> WEB服务器（apache/nginx） <=> WSGI <=> Python（Flask）

Flask框架

1、简介

​ flask是一个非常小的Python Web框架，被称为微型框架，只提供了一个强健的核心，其他功能都是通过扩展来实现的，意味着可以根据项目的需求量身打造。

2、组成

1. 测试、路由、WSGI系统
2. 模板引擎（jinja2, 是flask核心开发组人员开发）

3、安装

pip install flask

4、完整程序

# 导入类库
from flask import Flask

# 创建实例
app = Flask(__name__)

# 视图函数
@app.route('/')
def index():
    return '<h1>Nice dandan</h1>'

# 启用实例
if __name__ == '__main__':
    app.run()

# 浏览器测试：http://127.0.0.1:5000/

5、启动参数

app.run(debug=True, threaded=True, port=8001, host=’0.0.0.0’)

6、请求与响应

变量或对象

请求钩子函数

7、视图函数

说明：

无参路由

# 无参路由

@app.route('/test2/')
def test2():
   return 'This is test2 page!'

带参路由

# 带参路由，参数写在<>中

@app.route('/welcome/<name>/')
def welcome(name):
   return 'Hello, %s~' % name

指定参数类型，如string(默认)、int、float、path（参数中的/不再作为分隔符）
@app.route('/user/int:uid')
  def show(uid):
      return '%d 号，Nice' % uid

测试path

 @app.route('/path/path:p')
 def path(p):
   return p

'''
说明：
   1.路由末尾的'/'建议加上，需要的时候，浏览器会自动加上，输入时加不加都可以
   2.若需要指定参数，将参数写在<>中，视图函数参数要与路由参数一致
   3.若需要知道参数类型，如int/float/path等，写在参数前，用‘：’与参数隔开
   4.不指定类型，参数默认是string，path其实也是字符串，只是'/'不再作为分隔符
'''  

8、请求（request）

python

请求

@app.route(‘/request/’) 
def req(): 
# 完整的url请求地址 
# return request.url

# 基础的url（除了参数以外的url,即不包括get参数）
# return request.base_url

# 主机地址和端口号
# return request.host_url

# 只有路由信息（只包含装饰器中的路由地址）
# return request.path

# 请求方式
# return request.method

# 客户端的ip地址
# return request.remote_addr

# 获取get参数
# return request.args['name']

# 获取请求头
return request.headers['User-Agent']

9、响应

# 响应
@app.route('/response/')
def response():
    # 默认状态码200
    # return 'Nice'

    # 在响应的后面指定状态码
    # return 'Page not found', 404

    # 先构造一个响应(也可以指定状态吗)，然后返回
    resp = make_response('这是通过函数构造的响应', 404)
    return resp

10、重定向（redirect）

# 重定向
@app.route('/redirect/')
def new():
    # return '新的内容'
    # 重定向，需要指定一个路由地址
    # return redirect('/response/')

    # 根据视图函数，反向的构造出来路由地址，传递的参数是视图函数
    # return url_for('req')

    # 构造带参数的路由，直接写在后面即可
    # return url_for('welcome', name='Nian')
    return redirect(url_for('welcome', name='Nian'))

11、终止（abort）

# 抛出指定错误
@app.route('/abort/')
def err():
    # 使用abort函数，不是说控制权就归你了，
    # 他只是向系统抛出了指定的异常，
    # 异常的处理仍然会按照框架中写好的方式进行
    abort(404)
    return 'abort测试'

# 定制错误页面
@app.errorhandler(404)
def page_not_found(e):
    return 'Not found'

12、会话控制（cookie/session）

# 设置cookie
@app.route('/set_cookie/')
def set_cookie():
    resp = make_response('cookie已设置')

    # 设置cookie
    resp.set_cookie('name', '小啊念')
    return resp

# 获取cookie
@app.route('/get_cookie/')
def get_cookie():
    return request.cookies.get('name') or 'Stranges'


# 设置session
# 设置密钥,用于加密解密的字符串，不只是用于session
app.config['SECRET_KEY'] = '123456'

# 设置session
@app.route('/set_session/')
def set_session():
    session['user'] = 'Likesea'
    return 'session已设置'

# 获取session
@app.route('/get_session/')
def get_session():
    return session.get('user', 'Strangers')

flask-script扩展

1、简介

​ 简单来说就是一个flask终端运行的解析器；因为在测试完项目后，最好不要改动任何代码，

否则可能会带来风险，所以借助扩展库实现启动，通过传递参数完成不同的启动。

2、安装

pip install flask-script

3、使用

# 导入类库
from flask_script import Manager

# 创建对象
manager = Manager(app)

# 启用实例
if __name__ == '__main__':
    manager.run()

# 启动：python manage.py runserver

4、启动参数

-? / --help :查看启动设置帮助
-h / --host :指定主机
-p / --port :指定端口
--threaded  :启动多线程
-d  :开启调试模式
-r  :代码修改后自动加载

# 实例：python manage.py runserver -d -r

蓝本（blueprint）

1、说明：

​ 当代码越来越复杂时，将所有的视图函数放在一个文件中很明显是不合适的，如果能够根据功能模块进行划分，存储在不同的文件中，蓝本就是为解决此问题而生的。

# 导入类库
from flask import Blueprint

# 创建蓝本对象
user = Blueprint('user', __name__)

# 添加路由（视图函数）
@user.route('/login/')
def login():
    return '登陆'


# 注册蓝本,未注册的蓝本处于休眠状态（无法使用）
from user import user

# 可以通过url_prefixl指定路由前缀
app.register_blueprint(user, url_prefix='/user')

扩展

1、MVC

​M：model, 模型，数据模型

V：view, 视图，负责数据展示

​C：controller， 控制器，负责业务逻辑的扩展

2、MTV

​M：model，模型，数据模型

​T：templates， 模板，负责数据展示

V：view function，视图函数，负责业务逻辑的处理

在使用SQLALchemy更新数据的时候，一直不成功。
数据更新的方式采用ajax，具体代码如下：

$(function () {
    $('#user_profile').click(function (event) {
        event.preventDefault();  //prevent the actual form post
        user_profile();

    });

    // Inject our CSRF token into our AJAX request.
    $.ajaxSetup({
        beforeSend: function (xhr, settings) {
            if (!/^(GET|HEAD|OPTIONS|TRACE)$/i.test(settings.type) && !this.crossDomain) {
                xhr.setRequestHeader("X-CSRFToken", $('#csrf_token').val())
            }
        }
    })
})

function user_profile() {
    $.ajax({
        type: $('#tab_1_1 form').attr("method"),
        url: $('#tab_1_1 form').attr("action"),
        data: $('#tab_1_1 form').serialize(),
        contentType: "application/x-www-form-urlencoded",
        success: function (data) {
            console.log(data);
        }
    });
}

但是提交到后台无法获取数据，提交的数据结构如下所示：

csrf_token=IjkwNjQ5OTE2MTJjMGMwZDk4OTc5ZmQxOTZjOTgxMmU4MmU0ZDRmMzAi.DjHgiQ.hDgD-Yz89RkJZPL-YorWJdG7Z7c&fullname=%E9%BB%84%E5%85%B5&nick_name=%E7%8B%AC%E8%A1%8C%E4%BE%A0&phone_number=13429950072&about_me=%E6%88%91%E6%98%AF%E4%B8%80%E4%B8%AA%E5%AE%85%E7%94%B7%EF%BC%8C%E8%AF%B7%E5%A4%A7%E5%AE%B6%E4%B8%8D%E8%A6%81%E6%89%93%E6%89%B0%E6%88%91%E7%BB%A7%E7%BB%AD%E5%AE%85%E3%80%82&website_url=https%3A%2F%2Fpdf-lib.org

之后看一下后台如何接收数据：

# 验证提交
if form.validate_on_submit():
    current_user.fullname = form.fullname.data
    current_user.phone_number = form.phone_number.data
    current_user.nick_name = form.nick_name.data
    current_user.website_url = form.website_url.data
    try:
        sql_query=str(db.session.add(current_user._get_current_object()))
        print(sql_query)
        print(current_user._get_current_object())
        db.session.commit()
    except:
        flash('账户更新失败！')
    flash('账户资料已更新！')

使用这种方式无法获取数据，数据一直没有更新，搞不清是什么情况。之后不断调试，参考了别人文章之后终于把问题解决了。
需要修改源代码如下：

# 验证提交
    if form.validate_on_submit():
        current_user.fullname = request.values.get('fullname', 0)
        current_user.phone_number = request.values.get('phone_number', 0)
        current_user.nick_name = request.values.get('nick_name', 0)
        current_user.about_me = request.values.get('about_me', 0)
        current_user.website_url = request.values.get('website_url', 0)
        try:
            db.session.add(current_user._get_current_object())
            db.session.commit()
        except:
            flash('账户更新失败！')
        flash('账户资料已更新！')

这个是flask获取post参数的方式，具体可以参考这里： https://pdf-lib.org/Home/Details/5201

这样再次获取数据就没有什么问题了。
再次使用SQLALchemy保存数据，数据已经成功更新了。

概述

目前使用的平台在使用的过程中发现性能比较低，所以需要想办法进行性能调优。

使用的工具

Siege是一个http负载测试和基准测试工具。 它旨在让网络开发者在胁迫下测量他们的代码，看看它将如何站起来加载到互联网上。 Siege支持基本认证，cookies，HTTP，HTTPS和FTP协议。 它允许用户使用可配置数量的模拟客户端访问服务器。 这些客户将服务器置于“under siege”。

说白了Siege 就是一个多线程的http服务器压力测试工具，官网在这里，最近版本3.1.4。怎么安装可以在官网上查看。这个官网好像已经很长时间没更新了，我在mac下安装的siege已经到了4.0.4版本。Mac下直接使用brew安装就可以了。

brew install siege

siege
SIEGE 4.0.4
Usage: siege [options]
       siege [options] URL
       siege -g URL
Options:
  -V, --version             VERSION, prints the version number.
  -h, --help                HELP, prints this section.
  -C, --config              CONFIGURATION, show the current config.
  -v, --verbose             VERBOSE, prints notification to screen.
  -q, --quiet               QUIET turns verbose off and suppresses output.
  -g, --get                 GET, pull down HTTP headers and display the
                            transaction. Great for application debugging.
  -p, --print               PRINT, like GET only it prints the entire page.
  -c, --concurrent=NUM      CONCURRENT users, default is 10
  -r, --reps=NUM            REPS, number of times to run the test.
  -t, --time=NUMm           TIMED testing where "m" is modifier S, M, or H
                            ex: --time=1H, one hour test.
  -d, --delay=NUM           Time DELAY, random delay before each requst
  -b, --benchmark           BENCHMARK: no delays between requests.
  -i, --internet            INTERNET user simulation, hits URLs randomly.
  -f, --file=FILE           FILE, select a specific URLS FILE.
  -R, --rc=FILE             RC, specify an siegerc file
  -l, --log[=FILE]          LOG to FILE. If FILE is not specified, the
                            default is used: PREFIX/var/siege.log
  -m, --mark="text"         MARK, mark the log file with a string.
                            between .001 and NUM. (NOT COUNTED IN STATS)
  -H, --header="text"       Add a header to request (can be many)
  -A, --user-agent="text"   Sets User-Agent in request
  -T, --content-type="text" Sets Content-Type in request
      --no-parser           NO PARSER, turn off the HTML page parser
      --no-follow           NO FOLLOW, do not follow HTTP redirects

Copyright (C) 2017 by Jeffrey Fulmer, et al.
This is free software; see the source for copying conditions.
There is NO warranty; not even for MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE.

直接给出几个常用命令。

# get 请求
siege -c 1000 -r 100 -b url
# post 请求
siege -c 1000 -r 100 -b url POST {"accountId":"123","platform":"ios"}"

测试

测试代码

看一下文件树结构，tree

➜  flask tree
.
├── hello1.py
├── hello1.pyc
├── hello2.py
├── hello2.pyc
├── hello3.py
└── templates
    └── hello.html

下面是一段没有使用模板，只返回字符串的Flask代码。

# file hello1.py
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

app.run(debug=False, threaded=True, host="127.0.0.1", port=5000)

下面是一段使用模板文件的Flask代码。

# file hello2.py
from flask import Flask,render_template

app = Flask(__name__)

@app.route('/hello/')
@app.route('/hello/<name>')
def hello(name=None):
    return render_template('hello.html', name=name)

app.run(debug=False, threaded=True, host="127.0.0.1", port=5000)

hello.html文件

<!doctype html>
<title>Hello from Flask</title>
{% if name %}
  <h1>Hello {{ name }}!</h1>
{% else %}
  <h1>Hello, World!</h1>
{% endif %}

flask 直接运行

首先看hello1.py的测试结果

# 100 并发
siege -c 100 -r 10 -b http://127.0.0.1:5000

Transactions:               1000 hits
Availability:             100.00 %
Elapsed time:               1.17 secs
Data transferred:           0.01 MB
Response time:              0.11 secs
Transaction rate:         854.70 trans/sec
Throughput:             0.01 MB/sec
Concurrency:               92.12
Successful transactions:        1000
Failed transactions:               0
Longest transaction:            0.14
Shortest transaction:           0.01

# 200并发
# siege -c 200 -r 10 -b http://127.0.0.1:5000

Transactions:               1789 hits
Availability:              89.45 %
Elapsed time:               2.26 secs
Data transferred:           0.02 MB
Response time:              0.17 secs
Transaction rate:         791.59 trans/sec
Throughput:             0.01 MB/sec
Concurrency:              134.37
Successful transactions:        1789
Failed transactions:             211
Longest transaction:            2.09
Shortest transaction:           0.00

# 1000 并发
siege -c 1000 -r 10 -b http://127.0.0.1:5000

Transactions:              10000 hits
Availability:             100.00 %
Elapsed time:              16.29 secs
Data transferred:           0.12 MB
Response time:              0.00 secs
Transaction rate:         613.87 trans/sec
Throughput:             0.01 MB/sec
Concurrency:                2.13
Successful transactions:       10000
Failed transactions:               0
Longest transaction:            0.08
Shortest transaction:           0.00

不知道为什么200的时候可用率会有一个下降，但是从大趋势可以看出来，访问速率是一直再降的，1000并发的时候已经到613/s了。

在看看第二段代码

# 100 并发
siege -c 100 -r 10 -b http://127.0.0.1:5000/hello/libai

Transactions:               1000 hits
Availability:             100.00 %
Elapsed time:               1.26 secs
Data transferred:           0.07 MB
Response time:              0.12 secs
Transaction rate:         793.65 trans/sec
Throughput:             0.06 MB/sec
Concurrency:               93.97
Successful transactions:        1000
Failed transactions:               0
Longest transaction:            0.14
Shortest transaction:           0.04

# 200并发
siege -c 200 -r 10 -b http://127.0.0.1:5000/hello/libai
Transactions:               1837 hits
Availability:              91.85 %
Elapsed time:               2.52 secs
Data transferred:           0.13 MB
Response time:              0.18 secs
Transaction rate:         728.97 trans/sec
Throughput:             0.05 MB/sec
Concurrency:              134.77
Successful transactions:        1837
Failed transactions:             163
Longest transaction:            2.18
Shortest transaction:           0.00

# 1000 并发
siege -c 1000 -r 10 -b http://127.0.0.1:5000/hello/libai
Transactions:              10000 hits
Availability:             100.00 %
Elapsed time:              17.22 secs
Data transferred:           0.70 MB
Response time:              0.01 secs
Transaction rate:         580.72 trans/sec
Throughput:             0.04 MB/sec
Concurrency:                7.51
Successful transactions:       10000
Failed transactions:               0
Longest transaction:            0.09
Shortest transaction:           0.00

其他方式

参考Flask官方文档推荐的部署方式进行测试。

虽然轻便且易于使用，但是 Flask 的内建服务器不适用于生产 ，它也不能很好 的扩展。本文主要说明在生产环境下正确使用 Flask 的一些方法。

如果想要把 Flask 应用部署到这里没有列出的 WSGI 服务器，请查询其文档中关于 如何使用 WSGI 的部分，只要记住： Flask 应用对象实质上是一个 WSGI 应用。
下面从官方的方式中挑选几种进行性能测试。

Gunicorn

Gunicorn ‘Green Unicorn’ 是一个 UNIX 下的 WSGI HTTP 服务器，它是一个 移植自 Ruby 的 Unicorn 项目的 pre-fork worker 模型。它既支持 eventlet ， 也支持 greenlet 。在 Gunicorn 上运行 Flask 应用非常简单:

gunicorn myproject:app

当然，为了使用gunicorn，我们首先得pip install gunicorn来进行gunicorn的安装。要使用gunicorn启动hello1.py，需要将里面的代码

app.run(debug=False, threaded=True, host="127.0.0.1", port=5000)

删掉。然后执行命令

# 其中 -w 为开启n个进程 -b 为绑定ip和端口
gunicorn hello1:app -w 4 -b 127.0.0.1:4000

gunicorn 默认使用同步阻塞的网络模型(-k sync)，对于大并发的访问可能表现不够好， 它还支持其它更好的模式，比如：gevent或meinheld。所以，我们可以将阻塞模型替换为gevent。

# 其中 -w 为开启n个进程 -b 为绑定ip和端口 -k 为替换阻塞模型为gevent
gunicorn hello1:app -w 4 -b 127.0.0.1:4000  -k gevent

下面我分别测试1000并发10次访问的四种情况，1个进程、4个进程下gevnent和非gevent模型，看看结果。

在测试前，一定要设置ulimit的值大一些，否者会报Too many open files错误，我设置到了65535

ulimit 65535

gunicorn hello1:app -w 1 -b 127.0.0.1:4000
siege -c 1000 -r 10 -b http://127.0.0.1:4000
Transactions:              10000 hits
Availability:             100.00 %
Elapsed time:              15.21 secs
Data transferred:           0.12 MB
Response time:              0.00 secs
Transaction rate:         657.46 trans/sec
Throughput:             0.01 MB/sec
Concurrency:                0.85
Successful transactions:       10000
Failed transactions:               0
Longest transaction:            0.01
Shortest transaction:           0.00

可以看到，单进程比flask直接启动稍稍好一点。

gunicorn hello1:app -w 4 -b 127.0.0.1:4000
siege -c 1000 -r 10 -b http://127.0.0.1:4000

Transactions:              10000 hits
Availability:             100.00 %
Elapsed time:              15.19 secs
Data transferred:           0.12 MB
Response time:              0.00 secs
Transaction rate:         658.33 trans/sec
Throughput:             0.01 MB/sec
Concurrency:                0.75
Successful transactions:       10000
Failed transactions:               0
Longest transaction:            0.01
Shortest transaction:           0.00

# 使用gevent，记得 pip install gevent
gunicorn hello1:app -w 1 -b 127.0.0.1:4000  -k gevent
Transactions:              10000 hits
Availability:             100.00 %
Elapsed time:              15.20 secs
Data transferred:           0.12 MB
Response time:              0.00 secs
Transaction rate:         657.89 trans/sec
Throughput:             0.01 MB/sec
Concurrency:                1.33
Successful transactions:       10000
Failed transactions:               0
Longest transaction:            0.02
Shortest transaction:           0.00

gunicorn hello1:app -w 4 -b 127.0.0.1:4000  -k gevent

Transactions:              10000 hits
Availability:             100.00 %
Elapsed time:              15.51 secs
Data transferred:           0.12 MB
Response time:              0.00 secs
Transaction rate:         644.75 trans/sec
Throughput:             0.01 MB/sec
Concurrency:                1.06
Successful transactions:       10000
Failed transactions:               0
Longest transaction:            0.28
Shortest transaction:           0.00

可以看到，在并发数为1000的时候，使用gunicorn和genent并不明显，但是当我们修改并发数为100或200是进行测试

gunicorn hello1:app -w 1 -b 127.0.0.1:4000  -k gevent
siege -c 200 -r 10 -b http://127.0.0.1:4000
Transactions:               1991 hits
Availability:              99.55 %
Elapsed time:               1.62 secs
Data transferred:           0.02 MB
Response time:              0.14 secs
Transaction rate:        1229.01 trans/sec
Throughput:             0.02 MB/sec
Concurrency:              167.71
Successful transactions:        1991
Failed transactions:               9
Longest transaction:            0.34
Shortest transaction:           0.00

gunicorn hello1:app -w 4 -b 127.0.0.1:4000  -k gevent
siege -c 200 -r 10 -b http://127.0.0.1:4000
Transactions:               2000 hits
Availability:             100.00 %
Elapsed time:               0.71 secs
Data transferred:           0.02 MB
Response time:              0.04 secs
Transaction rate:        2816.90 trans/sec
Throughput:             0.03 MB/sec
Concurrency:              122.51
Successful transactions:        2000
Failed transactions:               0
Longest transaction:            0.17
Shortest transaction:           0.00

可以看到在4进程，使用gevent的时候已经达到了2816。

再测试一下200并发下hello2.py的效率。

gunicorn hello2:app -w 1 -b 127.0.0.1:4000  -k gevent
siege -c 200 -r 10 -b http://127.0.0.1:4000/hello/2
Transactions:               1998 hits
Availability:              99.90 %
Elapsed time:               1.72 secs
Data transferred:           0.13 MB
Response time:              0.14 secs
Transaction rate:        1161.63 trans/sec
Throughput:             0.08 MB/sec
Concurrency:              168.12
Successful transactions:        1998
Failed transactions:               2
Longest transaction:            0.35
Shortest transaction:           0.00

gunicorn hello2:app -w 4 -b 127.0.0.1:4000  -k gevent
siege -c 200 -r 10 -b http://127.0.0.1:4000/hello/2
Transactions:               2000 hits
Availability:             100.00 %
Elapsed time:               0.71 secs
Data transferred:           0.13 MB
Response time:              0.05 secs
Transaction rate:        2816.90 trans/sec
Throughput:             0.19 MB/sec
Concurrency:              128.59
Successful transactions:        2000
Failed transactions:               0
Longest transaction:            0.14
Shortest transaction:           0.0

可以看到和hello1.py的效率差不都，也达到了2800+，性能基本上算是提升了4倍。

uWSGI

官网链接uWSGI，安装请点开链接查看。Mac下直接使用brew install uWSGI就可以安装，安装好后，在网站目录下运行

uWSGI --http 127.0.0.1:4000 --module hello1:app

时间不够了，先写到这里

usWSGI和ngnix

uswgi 安装，使用pip install uswgi就可以了。

写配置文件uswgi.ini，这个文件uswgi的配置文件。

[uwsgi]
# 是否启用主进程
master = true
# 虚拟python环境的目录，即virtualenv生成虚拟环境的目录
home = venv
# wsgi启动文件
wsgi-file = manage.py
# wsgi启动文件中new出的app对象
callable = app
# 绑定端口
socket = 0.0.0.0:5000
# 开启几个进程
processes = 4
# 每个进程几个线程
threads = 2
# 允许的缓冲大小
buffer-size = 32768
# 接受的协议，这里要注意！！！！！！直接使用uwsgi启动时必须有这项，没有的话会造成服务可以启动，但是浏览器不能访问；在只是用nginx进行代理访问时，这项必须删除，否则nginx不能正常代理到uwsgi服务。
protocol=http

其中uwsgi的启动文件为manage.py，其中hello1为上面的hello1.py，注释掉其中的app.run(debug=False, threaded=True, host=”127.0.0.1″, port=5000)。

from flask import Flask
from hello1 import app

manager = Manager(app)

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

然后使用命令uswgi uswgi.ini启动程序，访问本地127.0.0.1:5000就可以看到helloworld了。然后就需要和nginx一起使用了，安装好nginx后，找到nginx的配置文件，如果使用的是apt或者yum安装nginx，则nginx的配置文件在/etc/nginx/nginx.conf中，为了不影响全局效果，这里修改/etc/nginx/sites-available/default文件，这个文件在/etc/nginx/nginx.conf中包含了，所以配置也是生效的。配置文件内容。

# nginx ip 访问次数限制，具体内容请查看参考6，7
limit_req_zone $binary_remote_addr zone=allips:100m rate=50r/s;  

server {
    listen 80 default_server;
    listen [::]:80 default_server;
    # nginx ip 访问次数限制，具体内容请查看参考6，7
    limit_req   zone=allips  burst=20  nodelay; 
    root /var/www/html;
    # Add index.php to the list if you are using PHP
    index index.html index.htm index.nginx-debian.html;
    server_name _;
    # 静态文件代理，nginx的静态文件访问速度比其他容器快很多。
    location /themes/  {
        alias       /home/dc/CTFd_M/CTFd/themes/;
    }
    # uwsgi配置
    location / {
        include uwsgi_params;
        uwsgi_pass 127.0.0.1:5000; 
        # python virtualenv 路径
        uwsgi_param UWSGI_PYHOME /home/dc/CTFd_M/venv; 
        # 当前项目路径
        uwsgi_param UWSGI_CHDIR /home/dc/CTFd_M; 
        # 启动文件
        uwsgi_param UWSGI_SCRIPT manage:app; 
        # 超时
        uwsgi_read_timeout 100;
    }
}

然后启动nginx服务器，访问127.0.0.1就可以正常访问了，由于可能本机配置有问题，不能成功使用这种方式进行系统的访问，后面的对比结果是我新建虚拟机，Ubuntu Server 16.04，2核，2G内存的性能，并且这里访问的网页已经不是前面的hello1.py这种测试程序，而是一个完成的应用平台，可以从Throughput属性看到，已经达到了20+M/s的处理速度。

# 下面的两个测试均是物理机上访问虚机环境，虚机环境为Ubuntu Server 16.04
# 使用uswgi启动
siege -c 200 -r 10 -b http://192.168.2.151:5000/index.html
Transactions:              56681 hits
Availability:              99.90 %
Elapsed time:             163.48 secs
Data transferred:        3385.71 MB
Response time:              0.52 secs
Transaction rate:         346.72 trans/sec
Throughput:            20.71 MB/sec
Concurrency:              180.97
Successful transactions:       56681
Failed transactions:              59
Longest transaction:           32.23
Shortest transaction:           0.05

# 使用uswsgi和nginx做静态代理后
siege -c 200 -r 10 -b http://192.168.2.151/index.html

Transactions:              53708 hits
Availability:              99.73 %
Elapsed time:             122.13 secs
Data transferred:        3195.15 MB
Response time:              0.29 secs
Transaction rate:         439.76 trans/sec
Throughput:            26.16 MB/sec
Concurrency:              127.83
Successful transactions:       53708
Failed transactions:             148
Longest transaction:          103.07
Shortest transaction:           0.00

可以看到，uswsgi和nginx一起使用，能够提升一些效率，从346次/s提升到了439次/s。