Falsk_day01

Flask简介

　　Flask是用 Python 语言基于 Werkzeug 工具箱编写的轻量级Web开发框架。

　　其 WSGI 工具箱采用 Werkzeug（路由模块），模板引擎则使用 Jinja2。这两个也是 Flask 框架的核心。

搭建虚拟环境（Ubuntu）

　　一、安装虚拟环境命令:

　　1、sudo pip install virtualenv

　　2、sudo pip install virtualenvwrapper

　　二、创建虚拟环境命令（需联网）：

　　在python3中,创建虚拟环境（python2创建则不需要 -p python3）：
　　mkvirtualenv -p python3 虚拟环境名称

　　三、使用虚拟环境：

　　1、查看虚拟环境的命令：workon 两次tab键

　　2、使用虚拟环境的命令：workon 虚拟环境名称

　　3、退出虚拟环境的命令：deactivate

　　4、删除虚拟环境的命令（先退出虚拟环境）：rmvirtualenv 虚拟环境名称

　　5、在虚拟环境中安装工具包：pip install 包名称

　　　　例：安装flask-0.10.1的包 ：pip install flask==0.10.1

　　6、查看虚拟环境中安装的包：pip freeze

 第一个Flask程序 HelloWord

　　首选用 pycharm 选择相应的虚拟环境的路径

# 导入Flask模块
from flask import Flask


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


# 通过装饰器路由，把url与视图函数绑定起来
@app.route('/')
def index():
    return 'hello word!'


if __name__ == '__main__':
    # 运行当前Flask应用程序
    app.run()

Flask 程序初始化参数

app = Flask(__name__,  # import_name是 Flask 程序所在的包（模块），传__name__就可以。其可以决定 Flask 在访问静态文件时查找的路径
            # static_path='static',  已废弃(用static_url_path代替)
            static_url_path='/static',  # 静态文件访问路径，可以不传，默认为：/ + static_folder
            static_folder='static',  # 静态文件存储的文件夹，可以不传，默认为 static 
            template_folder='templates'  # 模板文件存储的文件夹，可以不传，默认为 templates 
            )

程序加载配置

　　1、从配置对象中加载（常用）：

class Config(object):
    DEBUG = True
app.config.from_object(Config)

　　2、从配置文件中加载：

app.config.form_pyfile('配置文件名')

　　3、从环境变量中加载：

app.config.from_envvar('环境变量名称')

读取配置

app.config.get()
# 在视图函数中使用 current_app.config.get()

app.run的参数

app.run(host="0.0.0.0", port=5000, debug = True)

路由基本定义

　　1、定义路由装饰器 ：@app.route(“/参数“)

　　2、定义请求方式 ：methods=[‘GET’,‘POST’]

　　3、获取请求方式 ：request.method

　　参考代码：

# 路由传递参数
@app.route('/user/<user_id>', methods=['GET', 'POST'])  # methods给路由添加请求方式
def user_info(user_id):
    return 'hello %s %s' % (user_id, request.method)
# 路由传递的参数默认当做 string 处理，也可以指定参数的类型@app.route('/user/<int:user_id>')

Falsk 返回 JSON 数据给客户端（ 常用 jsonify( )）

from flask import Flask, jsonify
from flask import json

app = Flask(__name__)


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


@app.route('/demo2')
def demo2():
    json_dict = {
        "name": "wenwang",
        "age": 18
    }
    # 使用json.dumps将字典转成JSON字符串
    # result = json.dumps(json_dict)
    # 使用json.loads将JSON字符串转成字典
    # test_dict = json.loads('{"age": 18, "name": "wenwang"}')
    # return result

    # TODO jsonify会指定响应内容数据的格式(告诉客户端我返回给你的数据格式是什么)
    return jsonify(json_dict)

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

重定向（redirect( ) ，url_for( ) ）

　　例1、重定向到百度

# 重定向
@app.route('/demo1')
def demo1():
    return redirect('http://www.baidu.com')

　　例2、重定向到视图函数

# 路由传递参数
@app.route('/user/<int:user_id>')
def user_info(user_id):
    return 'hello %d' % user_id

# 重定向
@app.route('/demo2')
def demo2():
    # 使用 url_for 生成指定视图函数所对应的 url
    return redirect(url_for('user_info', user_id=100))

自定义状态码

@app.route('/demo6')
def demo6():
    return '状态码为 666', 666  # 666就为自定义状态码

正则匹配路由

　　实现步骤：

　　1、导入转换器基类：在 Flask 中，所有的路由的匹配规则都是使用转换器对象进行记录。

　　2、自定义转换器：自定义类继承于转换器基类。

　　3、添加转换器到默认的转换器字典中。

　　4、使用自定义转换器实现自定义匹配规则。

　　代码实现：

from flask import Flask
from flask import redirect
from flask import url_for
from werkzeug.routing import BaseConverter


class RegexConverter(BaseConverter):
    """自定义正则的转换器"""
    # regex = '[0-9]{6}'

    def __init__(self, url_map, *args):
        super(RegexConverter, self).__init__(url_map)
        # 取到第1个参数，给regex属性赋值
        self.regex = args[0]


class ListConverter(BaseConverter):
    regex = "(\d+,?)+\d$"

    def to_python(self, value):
        """当匹配到参数之后，对参数做进一步处理之后，再返回给视图函数中"""
        return value.split(',')

    def to_url(self, value):
        """使用url_for的时候，对视图函数传的参数进行处理，处理完毕之后以便能够进行路由匹配"""
        result = ','.join(str(v) for v in value)
        return result
        

app = Flask(__name__)
# 将自己的转换器添加到默认的转化器列表中
app.url_map.converters['re'] = RegexConverter
app.url_map.converters['list'] = ListConverter


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

# 自定义转换器
# @app.route('/user/<re:user_id>')
@app.route('/user/<re("[0-9]{6}"):user_id>')
def demo1(user_id):
    return '用户的id是 %s' % user_id


@app.route('/users/<list:user_ids>')
def demo2(user_ids):
    return '用户的id是 %s' % user_ids


@app.route('/demo3')
def demo3():
    return redirect(url_for('demo2', user_ids=[1, 3, 4, 5]))


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

异常捕获（ abort() ，@app.errorhandler()）

　　HTTP 异常主动抛出

abort(404)

　　捕获异常

@app.errorhandler(404)
def internal_server_error(e):
    return '网址找不到了'

　　捕获指定异常

@app.errorhandler(ZeroDivisionError)  # 捕获除数不能为0的异常
def zero_division_error(e):
    return '除数不能为0'

 请求钩子（ before_request ，after_request ）

　　为了让每个视图函数避免编写重复功能的代码，Flask提供了通用设施的功能，即请求钩子。

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

　　1、before_first_request

• • 在处理第一个请求前执行

　　2、before_request

• • 在每次请求前执行
  • 如果在某修饰的函数中返回了一个响应，视图函数将不再被调用

　　3、after_request

• • 如果没有抛出错误，在每次请求后执行
  • 接受一个参数：视图函数作出的响应
  • 在此函数中可以对响应值在返回之前做最后一步修改处理
  • 需要将参数中的响应在此参数中进行返回

　　4、teardown_request

• • 在每次请求后执行
  • 接受一个参数：错误信息，如果有相关错误抛出

 　　测试代码：

from flask import Flask

app = Flask(__name__)


@app.before_first_request
def before_first_request():
    """在第一次请求之前会访问该函数"""
    print('before_first_request')


@app.before_request
def before_request():
    """在每次请求之前都会调用"""
    print('before_request')
    # 可以对一些的请求进行阻止


@app.after_request
def after_request(response):
    """在请求之后会调用，并且函数里面接受一个参数：响应，还需要将响应进行返回"""
    print('after_request')
    # 可以在此函数中对响应数据做统一的处理
    return response


@app.teardown_request
def teardown_request(error):
    """在请求之后会执行，如果请求的函数报有异常，会把具体异常传入到此函数"""
    print('teardown_request')


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


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