Flask基础

Flask基本代码解析

# 导入Flask类
from flask import Flask

# 创建一个app应用
# __name__指向程序所在的包
# 初始化参数 import_name Flask程序所在的包
'''Flask构造函数的参数
    self,
    import_name,
    static_url_path=None,           # 静态文件访问路径
    static_folder="static",         # 静态文件存储的文件夹
    static_host=None,
    host_matching=False,
    subdomain_matching=False,
    template_folder="templates",    # 模板文件存储的文件夹
    instance_path=None,
    instance_relative_config=False,
    root_path=None,
'''
app=Flask(__name__)

# 加载配置方式1：通过配置对象加载配置
# 配置对象，里面定义需要给app添加的一系列配置
class Config(object):
    # 开启调试模式
    DEBUG=True
# 配置对象加载配置
app.config.from_object(Config)

# 加载配置方式2：从配置文件中加载配置
app.config.from_pyfile('config.ini')

# 加载配置方式3：通过环境变量加载配置
app.config.from_envvar('FLASKCONFIG')

# 加载配置方式4：在run方法中添加配置，代码见主函数

# 装饰器的作用：将路由映射到视图函数
# 网页地址也叫路由
@app.route('/')
def index():
    pass

if __name__ == '__main__':
    # web服务器的入口
    app.run()
    # app.run(debug=True,port=8080) #加载配置方式4

加载配置

有4种方式
    1.通过配置对象加载配置
    2.从配置文件中加载配置
    3.通过环境变量加载配置
    4.在run方法中添加配置
具体事例见上述代码

路由传递参数

如果路由传递了参数，那么视图函数需要接受 <user_id>，举例如下
@app.route('/demo/<user_id>')
def index(user_id):
    return "hello world."
    
对传递参数进行限定 <int:user_id>
@app.route('/demo/<int:user_id>')
def index(user_id):
    return "hello world."

指定请求方式

GET请求和POST请求
@app.route('/demo1',methods=['GET','POST'])
def index():
    return "hello world."
    
从请求中获得请求方式
request.method
request 需要从flask中导入
    from flask import request

返回json

@app.route('demo2')
def demo2():
    json_dict={
        'user_id':10,
        'user_name':'laowang'
    }
    return jsonify(json_dict)
    
jsonify需要从flask中导入
    from flask import jsonify

重定向

@app.route('/demo3')
def demo3():
    return redirect('https://baidu.com')

redirect需要从flask中导入
    from flask import redirect
    
重定向到自己的视图函数
@app.route('/demo4')
def demo4():
    return redirect(url_for('demo2'))
    
url_for 需要从flask中导入
    from flask import url_for

自定义状态码

@app.route('/demo5')
def demo5():
    return "状态码666",666

正则匹配路由

根据自己的规则去限定参数进行访问
应用场景：限制用户访问
具体实现步骤
    1.导入转换器基类
        在Flask中，所有路由的匹配规则都是使用转换器对象进行记录的
    2.自定义转换器
        自定义类继承于转换器基类
    3.添加转换器到默认的转换器字典中
    4.使用自定义转换器
        实现自定义匹配规则

# 假设已经创建app

# 1.导入转换器基类
from werkzeug.routing import BaseConverter

# 2.自定义转换器
class RegexConverter(BaseConverter):
    def __init__(self,url_map,*args):
        # super调用父类
        super(RegexConverter,self).__init__(url_map)
        # 将第一个接受的参数当做匹配规则进行保存
        self.regex=args[0]
    # 父类中还有两个方法to_python和to_url
    def to_python(self, value):
        # value代表匹配的值，可以输出查看
        # 匹配之后，可以对匹配到的参数进行一次处理再返回
        return str(value)
    def to_url(self, value):
        pass

# 3.添加转换器到转换器字典中
app.url_map.converters['re']=RegexConverter

# 4.使用自定义的转换器
@app.route('/user/<re("[0-9]{3}"):user_id>')
def index(user_id):
    return user_id

异常的捕获

@app.errorhandler(404)     
# errorhandler()括号中应该传递的是要捕获的异常的状态码
def error404(e):
    return "404异常"

请求钩子

客户端和服务器交互的时候，有些准备工作或者扫尾工作需要处理
比如：
    在请求开始时，建立数据库连接
    在请求开始时，根据需求进行权限验证
    在请求开始时，指定数据的交互格式

# 1.在第一次请求之前调用，可以再次方法内部做一些初始化操作
@app.before_first_request
def before_first_request():
    print("before_first_request")
    
# 2.在每一次请求之前调用
@app.before_request
def before_request():
    print("before_request")
    
# 3.在每一次请求之后调用
@app.after_request
def after_request():
    print("after_request")

在视图函数执行之后调用，并且把视图函数所生成的响应传入，能够做对响应最后一步统一处理

状态保持

1.用户登录状态保持
    1.Cookie：某些网站为了辨别用户身份，会进行会话跟踪，存储用户在本地的数据
        存储在浏览器（客户端）当中，一段纯文本信息
        不用域名的Cookie是不能互相访问的
        cookie机制采用的是在客户端保持状态的方案

# 设置cookie
from flask import make_response
@app.route('/cookie')
def cookie():
    resp=make_response("这是Cookie")
    resp.set_cookie('username','liuxing',max_age=3600)
    # max_age用来设置过期时间
    return resp
    
# 获取cookie
from flask import request
@app.route('/request')
def requests():
    resp=request.cookies.get('username')
    return resp

    2.Session
        在服务器端保存Session，Session依赖于cookie
        session机制采用的是在服务器端保持状态的方案。
        Session在设置之前必须有secret_key
        如：
            app.secret_key = 'abcd'
        会话（Session）跟踪：
            会话，指用户登录网站后的一系列动作，比如浏览商品添加到购物车并购买。
            会话（Session）跟踪是Web程序中常用的技术，用来跟踪用户的整个会话。常用的会话跟踪技术

# 设置Session
from flask import session
@app.route('/index')
def index():
    session['username']='laowang'
    return 'hahhah'

# 获取Session
@app.route('index1')
def index1():
    print(session.get('username'))
    return 'heheh'

jinjia2模板

1.变量代码块
    前端模板
        <h1>{{ post.title }}</h1>
        {{ post.age }}
        {{ post.height }}
        {{ my_string }}
        {{ my_int }}
        {{ my_list }}
    后端代码

from flask import render_template
@app.route('/moban')
def moban():
    POST={
        'title':'喜洋洋',
        'age':18,
        'height':1.75
    }
    my_string='hello'
    my_int=10
    my_list=[1,2,3,4,5,6]
    return render_template('demo.html',
                            post=POST,
                            my_string=my_string,
                            my_int=my_int,
                            my_list=my_list)

2.字符串的过滤操作
    1.禁止转义
        <p>{{ '<em>hello</em>' | safe }}</p>
    2.首字母变大写
        {{ 'hello' | capitalize }}
    3.转换成小写
        {{ 'HELLO' | lower }}
    4.转换成大写
        {{ 'hello' | upper }}
    5.字符串的反转
        {{ 'world' | reverse}}
    6.格式化输出
        {{ '%s is %d' | format('name',17) }}
    7.字符串的截断
        {{ 'hello every one' | truncate(9) }}
3.列表的操作
    1.获取第一个元素
        {{ [1,2,3,4,5,6] | first }}
    2.取到最后一个元素
        {{ [1,2,3,4,5,6] | last }}
    3.获取列表长度
        {{ [1,2,3,4,5,6] | length }}
    4.列表求和
        {{ [1,2,3,4,5,6] | sum }}
    5.列表排序
        {{ [1,2,3,4,5,6] | sort }}
4.自定义过滤器
    步骤
        1.自己写一个函数
        2.把该函数添加到过滤器集中
        def do_listrever(li):
            #通过原列丧创建一个新列表
            temp_li = list(li)
            temp_li.reverse()
            return temp_li
            
        app.add_template_filter(do_listrever , 'lireverse')
        # lireverse是过滤器名称
        
        在模板中的使用
            {{ [1,2,3,4,5,6] | lireverse }}
5.控制功能
    1.if语句
        {% if comments | length > 0 %}
            There are {{ comments | length }}
        {% else %}
        {% endif %}
    2.循环语句
        {% for ps in post %}
            {{ post.title }}
            {{ post.text }}
        {% endfor %}

表单验证

在Flask中，为了处理web表单，我们一般使用Flask-WTF扩展，它封装了WTForms，并且它有验证表单数据的功能
1.WTForms支持的HTML标准字段

2.WTForms常用验证函数

表单验证在Flask中有两种实现方式
    1.普通实现方式
        1.在HTML页面中直接写form表单
        2.视图函数中获取表单数据

HTML代码

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

Python代码

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

    2.使用Flask-WTF实现表单

HTML代码

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

Python代码

#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)

数据库

flask-sqlalchemy

环境迁移

requirements文件
在项目的终端中使用以下命令
    pip freeze > requirements.txt
然后就会生成一个requirements.txt
把requirements.txt拷贝到目标主机
在目标主机中使用以下命令可以安装原主机中的环境
    pip install -r requirements.txt

消息闪现

给模板中传递消息
flash --> 需要对内容加密 需要设置secret_key
app.secret_key='abc'
flash(u'闪现消息')  #u用来解决编码问题

模板中需要遍历消息
使用遍历获取消息
{% for message in get_flashed_messages() %}
    {{ message }}
{% endfor %}