Python之flask

1.预备知识绪论

Flask是当下流行的Web框架，它是用Python实现的。Flask显著的特点是：它是一个“微”框架。”微”意味着Flask旨在保持核心的简单，但同时又易于扩展。默认情况下，Flask 不包含数据库抽象层、表单验证，或是其它任何已有多种库可以胜任的功能。然而，Flask 支持用扩展来给应用添加这些功能。众多的扩展提供了数据库集成、表单验证、上传处理、各种各样的开放认证技术等功能。Flask的这些特性，使得它在Web开发方面变得非常流行。

# 1. 导入Flask类；
from flask import  Flask


# 2. 实例化一个Flask对象，
#     __name__是模块的名称或者包的名称
#     作用: 根据这个参数确定flask应用的路径， 从而快速查找模板和html文件的默认路径；
#     模块就是python文件; 包就是目录(跟普通目录多加一个__init__.py);
#
app = Flask(__name__)


# 3-1.基本路由:通过路由绑定一个视图函数
#   @app.route('/'): 告诉Flask哪个URL才能出发对应的函数， 又称为路由;
#   对应定义了一个视图函数， 也就是返回给用户浏览器显示的内容;
#  http://www.westos.org/login/
@app.route('/')
def index():
    return  "<h1>hello world</h1>"


@app.route('/login/')
def login():
    return  "login"

# 4. 运行Flask应用， 可以指定ip和端口；
app.run()

2.路由与变量规则

from flask import Flask, request

app = Flask(__name__)
# http:ww.douban.org/123457677/comments/
# http:ww.douban.org/123457673/comments/
# http:ww.douban.org/123457674/comments/
# http:ww.douban.org/123457675/comments/
# 常见路由的规则
#   1. url的一部分可以标记为变量<变量名>
#   2. flask中路由里面的变量常见类型:
#           int, string, float, path, uuid

@app.route('/<int:id>/comments/')
def comment1(id):
    return "Comment id: %s" %(id)

@app.route('/welcome/<string:user>/')
def welcome(user):
    app.logger.debug('this is a debug')
    app.logger.warning('this is a warn')
    return user + "用户, 欢迎光临"


# 特殊的url地址: http://www.baidu.com/query?id=123&name=westos
@app.route('/query')
def query():
    # 获取url地址里面key值对应的value值;
    id = request.args.get('id')
    name = request.args.get('name')
    return "id: %s, name: %s" %(id, name)


app.run()

3.URL构建与反向URL

from flask import Flask, request, url_for

app = Flask(__name__)

@app.route('/welcome/<string:user>/')
def welcome(user):
    return user + "用户, 欢迎光临"

@app.route('/path/')
def path():
    print(request.headers)
    # 查看默认url地址的请求方法;
    # methods is a list of methods this rule should be limited
    # to (``GET``, ``POST`` etc.).  By default a rule
    # just listens for ``GET``
    print(request.method)
    # url_for: 根据函数名, 反向生成url地址
    print("用户正在访问url地址:%s" % (url_for(endpoint="welcome", user="dzh")))
    return "用户正在访问url地址:%s" % (url_for(endpoint="welcome", user=dzh"))
app.run()

4.常见http方法之post与get

# 1. 常见HTTP请求方法:
    GET: 1). 获取信息 2). 提交的信息会展示在url: http://www.wewtos.org/login?user=westos&passwd=westos
    POST:1). 提交信息, 不在url里面展示, 有利于数据的安全性;



# 2. 默认路由接受的请求方法为_____get____?
     如何指定接收多个HTTP请求方法? [email protected]('/login/', methods=['GET', 'POST'])____________________.

    路由: @app.route('/login/', methods=['GET', 'POST'])
    视图函数: def login():


# 3. 如何判断用户请求的HTTP方法?   request.method
     如何获取用户POST请求提交的表单数据? request.form['user']

# 4.模板渲染(jinja2):
why?    python中生成html不易修改与维护, 所以将html的内容独立到templates目录中;
how?
    1). 去当前项目目录下寻找templtes是否存在?再去判断templates目录下是否有login.html文件?
    2). 读取这个login.html文件的内容, 作为render_template的返回值;
    3). 最终返回给用户浏览器;
render_template('login.html')

# 5. 重定向和错误?
redirect
return  render_template('login.html', message="用户名或者密码错误")


# 6. 404处理

from flask import Flask, request, render_template, redirect, url_for, abort

# redirect

app = Flask(__name__)


@app.route('/')
def index():
    return render_template('index.html')


@app.route('/login/', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        print(request.form)
        # 1. 如何获取到用户提交的信息呢?
        user = request.form['user']
        passwd = request.form['passwd']

        # 2. 判断用户名和密码是否正确
        if user == 'root' and passwd =='westos':
            # 如果登陆成功, 跳转到主页;
            return redirect(url_for('index'))
        else:
            # 如果登陆失败, 重新登陆;
            return  render_template('login.html', message="用户名或者密码错误")

    else:
        # 用户是GET请求, 返回登陆的html页面
        # 1. 读取login.html文件的内容
        # 2. 将读取的内容返回给用户界面
        return render_template('login.html')

# 404异常处理： 类似于捕获异常
@app.errorhandler(404)
def not_found(e):
    return  render_template('404.html')


# 抛出异常
@app.route('/user/<int:user_id>/')
def user(user_id):
    if 0<int(user_id)<=100:
        return  "欢迎访问: %s" %(user_id)
    else:
        abort(404)

app.run(port=5002)

5.模板引擎jinja2

# 1. 什么是Jinja2模板引擎?

python的Web开发中， 业务逻辑(实质就是视图函数的内容)和页面逻辑(html
文件)分开的， 使得代码的可读性增强， 代码容易理解和维护；


模板渲染: 在html文件中，通过动态赋值 ， 将重新翻译好的html文件(模板引擎生效) 返回给用户的过程。
其他的模板引擎: Mako, Template, Jinja2

# 1. python中自带的模板
import  string

strObj  = string.Template("$who is $role")
# 渲染字符串的过程;
print(strObj.substitute(who="fentiao", role="cat"))

6.变量显示

# Jinja2变量显示语法: {{ 变量名 }}
# for循环:
    {% for i in li%}

    {% endfor %}

# if语句
    {% if user == 'westos'%}


    {% elif user == 'hello' %}

    {% else %}

    {% endif%}

from flask import Flask, render_template

app = Flask(__name__)

class User(object):
    def __init__(self, name, passwd):
        self.name = name
        self.passwd = passwd

    def __str__(self):
        return  "<User: %s>" %(self.name)

@app.route('/')
def index1():
    name = "这是一个消息"
    li = [1, 2, 4, 5]
    d = dict(a=1, b=2)
    u = User("westos", "passwd")
    return  render_template('index1.html',
                            name = name,
                            li = li,
                            d = d,
                            u = u
                            )


app.run(port=5003)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>


<p>变量:</p> {{ name }}
<p>列表:</p> {{ li }}
 /*依次遍历列表的每一个元素*/
{% for i in li %}
<br/> 列表元素显示: {{ i }}
{% endfor %}



<p>字典:</p> {{ d }}
<p>字典:</p> {{ d.a }}
<p>字典:</p> {{ d['a'] }}
<p>字典:</p> {{ d.b }}
<p>字典:</p> {{ d['b']}}
<p>对象:</p> {{ u }}



<table>
    <tr>
        <th>用户名</th>
        <th>密码</th>
    </tr>

    <tr>
        <td>{{ u.name }}</td>
        <td>{{ u.passwd }}</td>
    </tr>


</table>
</body>
</html>

7.过滤器与自定义过滤器

import time
from flask import Flask, render_template

app = Flask(__name__)


class User(object):
    def __init__(self, name, passwd):
        self.name = name
        self.passwd = passwd

    def __str__(self):
        return "<User: %s>" % (self.name)


# 自定义一个转换时间格式的过滤器

@app.route('/')
def index2():
    name = "      this is a message"
    li = [1, 2, 4, 5]
    d = dict(a=1, b=2)
    liDict = [
        {
            'count': 100,
            'price': 30
        },
        {
            'count': 110,
            'price': 20
        },

    ]
    u = User("westos", "passwd")
    timestamp = time.time()
    return render_template('index2.html',
                           name=name,
                           li=li,
                           d=d,
                           u=u,
                           liDict=liDict,
                           timestamp=timestamp
                           )


def format_date(value, format="%Y-%m-%d %H:%M:%S"):
    #  时间戳----> 元组
    ttime = time.localtime(value)
    # 元组 --- > 指定字符串
    return time.strftime("%Y-%m-%d %H:%M:%S", ttime)


app.add_template_filter(format_date, 'format_date')


@app.route('/index3/')
def index3():
    return render_template('index3.html',
                           timestamp=time.time())
app.run(port=5004)

index2.html：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

/*什么是过滤器?
实质上就是一个转换函数/方法
*/



{{ timestamp }}
{{ timestamp | format_date }}
/*常见的字符串过滤器操作:*/
<ul>
    <li>{{ name | upper }}</li>
    <li>{{ name | lower }}</li>
    <li>{{ "hello" | capitalize }}</li>
    <li>{{ " hello world" | capitalize }}</li>
    <li>{{ name | reverse }}</li>
</ul>


/*常见数值操作*/

<ul>
    <!--四舍五入-->
    <li>{{ -12.9623423435 | round }}</li>
    <li>{{ -12.9623423435 | round | abs }}</li>

</ul>

/*列表常见:*/
<ul>
    <li>{{ li }}</li>
    <li>{{ li | first }}</li>
    <li>{{ li | last }}</li>
    <li>{{ li | length }}</li>
    <li>{{ li | sum }}</li>
    <li>{{ li | sort | reverse }}</li>
    <li>{{ li | join(":") }}</li>
    <li>{{ ["hello", "world"] | upper}}</li>
    <li>{{ ["hello", "woHld"] | lower}}</li>

</ul>
/*列表包含字典常用操作:*/

<ul>
    {% for item in liDict | sort(attribute='price', reverse=false) %}
    {{ item }}
    {% endfor %}
</ul>

</body>
</html>

index3.html：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

{{ timestamp }}
{{ timestamp | format_date }}


</body>
</html>

8.模板的继承

模板继承语法:
    1. 如何继承某个模板?
            {% extends "模板名称" %}


    2. 如何挖坑和填坑?
    挖坑:
        {% block 名称 %}

            默认值

        {% endblock %}


    填坑:
        {% block 名称 %}

        {% endblock %}


    3. 如何调用/继承被替代的模板?
        挖坑:
        {% block 名称 %}

            默认值

        {% endblock %}


    填坑:
        {% block 名称 %}
            #如何继承挖坑时的默认值?
            {{ super() }}

            # 后面写新加的方法.
            ........
        {% endblock %}

9.session操作

# cookie: 客户端浏览器的缓存；
# session: 服务端服务器的缓存;


Session 对象存储特定用户会话所需的属性及配置信息。这样，当用户在应用程序的 Web 页之间跳转时，
存储在 Session 对象中的变量将不会丢失，而是在整个用户会话中一直存在下去。当用户请求来自应用程序的Web 页时，如果该用户还没有会话，则 Web 服务器将自动创建一个 Session 对象。当会话过期或被放弃后，
服务器将终止该会话。Session 对象最常见的一个用法就是存储用户的首选项。

from flask import  Flask, session
import  random
app  = Flask(__name__)
app.config['SECRET_KEY'] =  random._urandom(24)
# 设置是24位的字符， 每次运行服务器的secret_key都是不同的，
# 服务器重启后会清除上一次存储的session信息值;


# 设置session值；
@app.route('/')
def index():
    # 如何设置session的key-value值
    session['name'] = 'dzh'
    return "hello world"

@app.route('/get/')
def get():
    # 如何获取?
    return  session.get('name')

@app.route('/delete/')
def delete():
    # 如何删除?
    print(session.get('name'))
    session.pop('name')
    print(session.get('name'))
    return  'delete'

app.run()

10.判断用户是否登陆的装饰器

import  functools

def is_login(f):

    @functools.wraps(f)
    def wrapper(*args, **kwargs):
        # run函数代码里面， 如果登陆， session加入user， passwd两个key值；
        # run函数代码里面， 如果注销， session删除user， passwd两个key值；
        # 如果没有登陆成功， 则跳转到登陆界面
        if 'user' not in session:
            return  redirect('/login/')
        # 如果用户是登陆状态， 则访问哪个路由， 就执行哪个路由对应的视图函数；
        return  f(*args, **kwargs)
    return  wrapper

11.上传文件

#     实现目标: 如何将文件上传到服务器(保存在指定的文件夹)
"""
import os
from flask import Flask, request, render_template
import  uuid
app = Flask(__name__)
@app.route('/upload/', methods=['GET', 'POST'])
def upload():
    if request.method == 'POST':
        # 获取到用户上传的文件对象
        f = request.files['faceImg']
        print(f.filename)
        # 获取当前项目所在目录位置；
        basepath = os.path.dirname(__file__)
        print(basepath)
        # 拼接路径， 存储文件到static/face/xxxx
        filename = os.path.join(basepath, 'static/face', f.filename)
        # 保存文件
        f.save(filename)
        return  render_template('demo/upload.html', message = "上传成功")

    else:
        return  render_template('demo/upload.html')
app.run()

upload.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="/upload/" method="post" enctype="multipart/form-data">
        <input type="file" name="faceImg">
        <input type="submit" value="提交">

        {%  if message %}
        <p style="color: red">{{ message }}</p>

        {% endif %}
    </form>
</body>
</html>

12.表单处理flask-wtf

1. 为什么使用Flask-WTF？
    request对象公开了所有客户端发送的请求信息。特别是request.form可以访问POST请求提交的表单数据。
    尽管Flask的request对象提供的支持足以处理web表单，但依然有许多任务会变得单调且重复。
    表单的HTML代码生成和验证提交的表单数据就是两个很好的例子。
优势：
    Flask-WTF扩展使得处理web表单能获得更愉快的体验。该扩展是一个封装了与框架无关的WTForms包的Flask集成。


# 2. 什么是表单处理?

    在网页中，为了和用户进行信息交互总是不得不出现一些表单。
    flask设计了WTForm表单库来使flask可以更加简便地管理操作表单数据。
    WTForm中最重要的几个概念如下：

    1). Form类，开发者自定义的表单必须继承自Form类或者其子类。
    Form类最主要的功能是通过其所包含的Field类提供对表单内数据的快捷访问方式。

　　2). 各种Field类，即字段。一般而言每个Field类都对应一个input的HTML标签。
    比如WTForm自带的一些Field类比如BooleanField就对应<input type="checkbox">，
    SubmitField就对应<input type="submit">等等。

　　3). Validator类。这个类用于验证用户输入的数据的合法性。
    比如Length验证器可以用于验证输入数据的长度，
    FileAllowed验证上传文件的类型等等。

　　另外，flask为了防范csfr(cross-site request forgery)攻击，
   默认在使用flask-wtf之前要求app一定要设置过secret_key。
   最简单地可以通过app.config['SECRET_KEY'] = 'xxxx'来配置。



# 3. 常见的Field类

　　PasswordField　　   密码字段，自动将输入转化为小黑点

　　DateField　　       文本字段，格式要求为datetime.date一样

　　IntergerField　　   文本字段，格式要求是整数

　　DecimalField　　    文本字段，格式要求和decimal.Decimal一样

　　FloatField　　      文本字段，值是浮点数

　　BooleanField　　    复选框，值为True或者False

　　RadioField　　      一组单选框

　　SelectField　　     下拉列表，需要注意一下的是choices参数确定了下拉选项，
                       但是和HTML中的<select> 标签一样，其是一个tuple组成的列表，
                       可以认为每个tuple的第一项是选项的真正的值，而第二项是alias。

　　MultipleSelectField　　可选多个值的下拉列表





# Validator是验证函数:

    Validator是验证函数，把一个字段绑定某个验证函数之后，flask会在接收表单中的数据之前对数据做一个验证，
    如果验证成功才会接收数据。验证函数Validator如下，具体的validator可能需要的参数不太一样，这里只给出
    一些常用的，更多详细的用法可以参见wtforms/validators.py文件的源码，参看每一个validator类需要哪些参数：

　　*基本上每一个validator都有message参数，指出当输入数据不符合validator要求时显示什么信息。

　　Email　　验证电子邮件地址的合法性，要求正则模式是^.+@([^.@][^@]+)$

　　EqualTo　　比较两个字段的值，通常用于输入两次密码等场景，可写参数fieldname，不过注意其是一个字符串变量，指向同表单中的另一个字段的字段名

　　IPAddress　　验证IPv4地址，参数默认ipv4=True,ipv6=False。如果想要验证ipv6可以设置这两个参数反过来。

　　Length　　验证输入的字符串的长度，可以有min,max两个参数指出要设置的长度下限和上限,注意参数类型是字符串，不是INT!!

　　NumberRange　　验证输入数字是否在范围内，可以有min和max两个参数指出数字上限下限，注意参数类型是字符串，不是INT!!然后在这个validator的message参数里可以设置%(min)s和%(max)s两个格式化部分，来告诉前端这个范围到底是多少。其他validator也有这种类似的小技巧，可以参看源码。

　　Optional　　无输入值时跳过同字段的其他验证函数

　　Required　　必填字段

　　Regexp　　用正则表达式验证值，参数regex='正则模式'

　　URL　　验证URL，要求正则模式是^[a-z]+://(?P<host>[^/:]+)(?P<port>:[0-9]+)?(?P<path>\/.*)?$

　　AnyOf　　确保值在可选值列表中。参数是values（一个可选值的列表）。特别提下，和SelectField进行配合使用时，不知道为什么SelectField的choices中项的值不能是数字。。否则AnyOf的values参数中即使有相关数字也无法识别出当前选项是合法选项。我怀疑NoneOf可能也是一样的套路。

　　NoneOf　　确保值不在可选值列表中

import random
from flask import Flask, redirect, render_template
from forms import LoginForm
from flask_bootstrap import  Bootstrap

app = Flask(__name__)
bootstrap = Bootstrap(app)
app.config['SECRET_KEY'] =  random._urandom(24)


@app.route('/success/')
def success():
    return  "success"


@app.route('/login/', methods=('GET', 'POST'))
def submit():
    # 实例化表单对象;
    form = LoginForm()
    if form.validate_on_submit():
        print(form.data)
        return redirect('/success/')
    return render_template('demo/login.html', form=form)
app.run(port=8000)