flask内容

Flask是一个基于Python开发并且依赖jinja2模板和Werkzeug WSGI服务的一个微型框架，对于Werkzeug本质是Socket服务端，其用于接收http请求并对请求进行预处理，然后触发Flask框架，开发人员基于Flask框架提供的功能对请求进行相应的处理，并返回给用户，如果要返回给用户复杂的内容时，需要借助jinja2模板来实现对模板的处理，即：将模板和数据进行渲染，将渲染后的字符串返回给用户浏览器。

“微”(micro) 并不表示你需要把整个 Web 应用塞进单个 Python 文件（虽然确实可以 ），也不意味着 Flask 在功能上有所欠缺。微框架中的“微”意味着 Flask 旨在保持核心简单而易于扩展。Flask 不会替你做出太多决策——比如使用何种数据库。而那些 Flask 所选择的——比如使用何种模板引擎——则很容易替换。除此之外的一切都由可由你掌握。如此，Flask 可以与您珠联璧合。

默认情况下，Flask 不包含数据库抽象层、表单验证，或是其它任何已有多种库可以胜任的功能。然而，Flask 支持用扩展来给应用添加这些功能，如同是 Flask 本身实现的一样。众多的扩展提供了数据库集成、表单验证、上传处理、各种各样的开放认证技术等功能。Flask 也许是“微小”的，但它已准备好在需求繁杂的生产环境中投入使用。

flask中虚拟环境的搭建（参考博客）

sudo pip install virtualenv
sudo pip install virtualenvwrapper

# 1、创建目录用来存放虚拟环境
mkdir
$HOME/.virtualenvs

# 2、打开~/.bashrc文件，并添加如下：
export WORKON_HOME=$HOME/.virtualenvs
source /usr/local/bin/virtualenvwrapper.sh

# 3、运行
source ~/.bashrc

创建虚拟环境
mkvirtualenv 虚拟环境名称
例 ：
mkvirtualenv py_flask

mkvirtualenv -p python3 虚拟环境名称
例 ：
mkvirtualenv -p python3 py3_flask

进入虚拟环境
workon 虚拟环境名称

例 ：使用python2的虚拟环境
workon py_flask

例 ：使用python3的虚拟环境
workon py3_flask

退出虚拟环境
deactivate

rmvirtualenv 虚拟环境名称

例 ：删除虚拟环境py3_flask

先退出：deactivate
再删除：rmvirtualenv py3_flask

在虚拟环境中安装包
pip install 包名称

 一，flask的基本使用：

from flask import Flask

app = Flask(__name__)


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


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

 

二，基本的配置

# default_config = ImmutableDict({
#     'DEBUG': False,
#     'TESTING': False,
#     'PROPAGATE_EXCEPTIONS': None,
#     'PRESERVE_CONTEXT_ON_EXCEPTION': None,
#     'SECRET_KEY': None,
#     'PERMANENT_SESSION_LIFETIME': timedelta(days=31),
#     'USE_X_SENDFILE': False,
#     'LOGGER_NAME': None,
#     'SERVER_NAME': None,
#     'APPLICATION_ROOT': None,
#     'SESSION_COOKIE_NAME': 'session',
#     'SESSION_COOKIE_DOMAIN': None,
#     'SESSION_COOKIE_PATH': None,
#     'SESSION_COOKIE_HTTPONLY': True,
#     'SESSION_COOKIE_SECURE': False,
#     'MAX_CONTENT_LENGTH': None,
#     'SEND_FILE_MAX_AGE_DEFAULT': 12 * 60 * 60,  # 12 hours
#     'TRAP_BAD_REQUEST_ERRORS': False,
#     'TRAP_HTTP_EXCEPTIONS': False,
#     'PREFERRED_URL_SCHEME': 'http',
#     'JSON_AS_ASCII': True,
#     'JSON_SORT_KEYS': True,
#     'JSONIFY_PRETTYPRINT_REGULAR': True,
# })



方式一
 创建 Flask 类的对象,指向程序所在的包的名称
app = Flask(__name__)

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

方式二：
# 配置对象，里面定义需要给 APP 添加的一系列配置
class Config(object):
    # DEBUG = True


# 创建 Flask 类的对象,指向程序所在的包的名称
app = Flask(__name__)

# 从配置对象中加载配置
app.config.from_object(Config)

三，路由系统

DEFAULT_CONVERTERS = {
    'default':          UnicodeConverter,
    'string':           UnicodeConverter,
    'any':              AnyConverter,
    'path':             PathConverter,
    'int':              IntegerConverter,
    'float':            FloatConverter,
    'uuid':             UUIDConverter,
}

路由关系的创建

from flask import Flask
from flask import request

app = Flask(__name__)


# 指定访问路径为 demo1
@app.route('/demo1')
def demo1():
    return 'demo1'


# 路由传递的参数默认当做 string 处理，也可以指定参数的类型
@app.route('/user/<int:user_id>')
def user_info(user_id):
    return 'hello %d' % user_id


@app.route('/demo2', methods=['GET', 'POST'])
def demo2():
    # 直接从请求中取到请求方式并返回
    return request.method


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

from werkzeug.routing import BaseConverter
from flask import Flask


# 自定义正则转换器
class RegexConverter(BaseConverter):
    def __init__(self, url_map, *args):
        super(RegexConverter, self).__init__(url_map)
        # 将接受的第1个参数当作匹配规则进行保存
        self.regex = args[0]


app = Flask(__name__)

# 将自定义转换器添加到转换器字典中，并指定转换器使用时名字为: re
app.url_map.converters['re'] = RegexConverter


@app.route('/user/<re("[0-9]{3}"):user_id>')
def user_info(user_id):
    return "user_id 为 %s" % user_id


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

from werkzeug.routing import BaseConverter
from flask import Flask


# 自定义正则转换器
class RegexConverter(BaseConverter):
    def __init__(self, url_map, *args):
        super(RegexConverter, self).__init__(url_map)
        # 将接受的第1个参数当作匹配规则进行保存
        self.regex = args[0]

    def to_python(self, value):
        return int(value)


app = Flask(__name__)

# 将自定义转换器添加到转换器字典中，并指定转换器使用时名字为: re
app.url_map.converters['re'] = RegexConverter


@app.route('/user/<re("[0-9]{3}"):user_id>')
def user_info(user_id):
    print("user_id的类型为", type(user_id))
    return "user_id 为 %s" % user_id


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

to_url:
在使用 url_for 去获取视图函数所对应的 url 的时候，会调用此方法对 url_for 后面传入的视图函数参数做进一步处理
具体可参见 Flask 的 app.py 中写的示例代码：ListConverter

视图的常用逻辑

不推荐使用 json.dumps 转成 JSON 字符串直接返回，因为返回的数据要符合 HTTP 协议规范，
如果是 JSON 需要指定 content-type:application/json

from flask import Flask
from flask import jsonify

app = Flask(__name__)


# 返回JSON
@app.route('/demo4')
def demo4():
    json_dict = {
        "user_id": 10,
        "user_name": "laowang"
    }
    return jsonify(json_dict)


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


# 不推荐使用 json.dumps 转成 JSON 字符串直接返回，因为返回的数据要符合 HTTP 协议规范，
# 如果是 JSON 需要指定 content-type:application/json

重定向

重定向到指定的网址

from flask import Flask
from flask import redirect

app = Flask(__name__)


@app.route('/demo5')
def demo5():
    return redirect('http://www.itheima.com')


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

重定向到自己写的函数中

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

@app.route('/demo5')
def demo5():
    return redirect(url_for('demo1'))

重定向到带有参数的路由函数中

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


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

　　自定义状态码

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

异常的捕获

from flask import Flask
from flask import abort

app = Flask(__name__)


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


@app.route("/demo1")
def demo1():
    # 主动http状态码
    abort(404)
    return "demo1"


# 使用装饰器来捕获异常指定的状态码和异常
@app.errorhandler(404)
def page_not_fund(error):
    print(error)
    return "页面不存在"


@app.route("/demo2")
def div_demo2():
    a = 5
    b = 0
    return a / b


# 使用错误捕获来捕获除数不能为0的的错误
@app.errorhandler(ZeroDivisionError)
def Zero_Division_Error(error):
    print(error)
    return "除数不能为0"


# 第二种捕获异常的方式
# def page_not_found(error):
#     return '你访问的页面不存在', 404
# app.error_handler_spec[None][404] = page_not_found



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

　　注册一个处理程序错误的装饰器，当程序抛出指定错误状态码的时候会调用装饰器所装饰的方法（除了捕获异常的状态码之外还可以捕获指定的异常）

flask中的请求钩子

#! /usr/bin/env python
# *-* coding: utf-8 *-*

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("response", response)
    print("after_request")
    return response


# 在请求之后可以被执行，如果有异常会将此异常传入到这个函数来做处理
@app.teardown_request
def teardown_request(error):
    print(error)
    print("teardown_request")


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


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

before_first_request（在处理第一个请求前执行，后续的执行过程就不会再执行了）
before_request（每次发起请求前都会执行，如果在某个修饰函数中返回一个响应，视图函数将不再被调用）
after_request
（
没有抛出异常，则在每次请求后会执行
接收一个参数：视图函数做出的响应；
在此函数中可以对视图函数做出的响应做最后一步的处理；
需要将参数中的响应在此函数中返回
）
teardown_request
（
每次请求之后都会执行；
接收一个参数：如果抛出异常，则参数会捕捉到这个异常；
）

#! /usr/bin/env python
# *-* coding: utf-8 *-*

from flask import Flask,request
from werkzeug.serving import run_simple

app = Flask(__name__)


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

@app.route('/index', methods=["POST",])
def index():
    print(request.method)
    return 'index index!'

# rule 视图函数和酷游关系的映射关系
# map rule的集合
# BaseConverter匹配路由匹配的规则
# MapAdapter协调以上的路由匹配的工作


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

Werkzeug库的 routing 模块负责实现 URL 解析。不同的 URL 对应不同的视图函数，routing模块会对请求信息的URL进行解析，匹配到URL对应的视图函数，执行该函数以此生成一个响应信息。

routing模块内部有：

• • Rule类
    • 用来构造不同的URL模式的对象，路由URL规则
  • Map类
    • 存储所有的URL规则和一些配置参数
  • BaseConverter的子类
    • 负责定义匹配规则
  • MapAdapter类
    • 负责协调Rule做具体的匹配的工作

请求上下文(request context)

#! /usr/bin/env python
# *-* coding: utf-8 *-*


from flask import Flask
from flask import request

app = Flask(__name__)


@app.route('/index', methods=["GET", "POST"])
def index():
    return 'Hello World!'


@app.route("/args", methods=["GET", "POST"])
def args():
    # get方式地址栏传递参数
    print(request.form.get("name"))
    print(request.form.get("age"))
    # post方式请求体中传递参数
    print(request.args.get("name"))
    print(request.args.get("age"))
    return "success"


@app.route("/file", methods=["POST"])
def up_load_file():
    print(request.method)
    pic = request.files.get("pic")
    pic.save("./static/aaaa.png")
    return "success"


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

request是flask中代表当前请求的request对象，是一个全局的请求上下文的一个变量（可以理解成为一个全局变量，在视图函数中可以直接使用，可以取到当前请求）。

 备注：在地址栏中请求数据的方式可以用args的方式去在request中取值，如果在form表单中的数据需要在form中取值。

cookie的设置

#! /usr/bin/env python
# *-* coding: utf-8 *-*

from flask import Flask
from flask import request
from flask import make_response

app = Flask(__name__)


# 获取cookies
@app.route('/index')
def index():
    username = request.cookies.get("username")
    user_id = request.cookies.get("user_id")
    return '%s---%s' % (username, user_id)


# 设置cookies
@app.route("/login")
def login():
    response = make_response("success")
    response.set_cookie("username", "xiaoimng", max_age=3600)
    response.set_cookie("user_id", "1", max_age=3600)
    return response


# 删除cookies
@app.route("/logout")
def logout():

    response = make_response("删除cookies成功")
    response.delete_cookie("user_id")
    response.delete_cookie("username")
    return response


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

备注：

1，cookie的设置是在response中进行设置，在request中取值；

2，http是一种无状态的协议，浏览器在请求服务器的时候是无状态的，

无状态的原因是：

浏览器与服务器通过socket进行通信，服务器会将请求结果返回给浏览器，请求完毕后服务器都会将通信套接字关闭，并且服务器在关闭套接字之后就会销毁请求的页面的对象；

有时需要保持浏览器的状态，比如用户的登录状态，和浏览过的信息等；

无状态协议

1，协议对事物的处理没有记忆的功能；

2，对于同一个url请求没有上下文的关系；

3，每次执行的结果都是独立的，它执行的结果和情况与上前面的请求和之后的请求没有直接的关系，它不会受前面的请求应答的影响，也不会对后面的请求应答产生影响；

4，服务器没有保持客户端的状态，客户端每次需要自己将状态带到服务区端；

实现状态保持有两种方式；

1，在客户端设置cookie，在每次发送请求的时候将cookie带给服务器端；

2，在服务器端设置session，每次客户福安发送来请求之后，将客户端的cookie与session做做对比；（所有说session是依赖于cookie的，cookie可以单独存在session不可以独立存在）；

#! /usr/bin/env python
# *-* coding: utf-8 *-*
from datetime import timedelta
from flask import Flask
from flask import session

app = Flask(__name__)
app.config["SECRET_KEY"] = "abcdefg"


# app.secret_key["SECRET_KEY"] = "abcsefght"

@app.route('/index')
def index():
    user_name = session.get("user_name")
    user_id = session.get("user_id")
    return "%s---%s" % (user_name, user_id)


@app.route("/login")
def login():
    session.permanent = True
    app.permanent_session_lifetime = timedelta(second=10)
    session["user_name"] = "xiaomingh"
    session["user_id"] = "1"
    return "session设置成功"


@app.route("/logout")
def logout():
    session.pop("user_name", None)
    session.pop("user_id", None)
    return "session删除删除成功"


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

 

思考：在视图函数中，如何取到当前请求的相关数据？比如：请求地址，请求方式，cookie等等

在 flask 中，可以直接在视图函数中使用 request 这个对象进行获取相关数据，而 request 就是请求上下文的对象，保存了当前本次请求的相关数据，请求上下文对象有：request、session

• • request
    • 封装了HTTP请求的内容，针对的是http请求。举例：user = request.args.get('user')，获取的是get请求的参数。
  • session
    • 用来记录请求会话中的信息，针对的是用户信息。举例：session['name'] = user.id，可以记录用户信息。还可以通过session.get('name')获取用户信息。

应用上下文(application context)

它的字面意思是 应用上下文，但它不是一直存在的，它只是request context 中的一个对 app 的代理(人)，所谓local proxy。它的作用主要是帮助 request 获取当前的应用，它是伴 request 而生，随 request 而灭的。

应用上下文对象有：current_app，g

current_app

应用程序上下文,用于存储应用程序中的变量，可以通过current_app.name打印当前app的名称，也可以在current_app中存储一些变量，例如：

• • 应用的启动脚本是哪个文件，启动时指定了哪些参数
  • 加载了哪些配置文件，导入了哪些配置
  • 连了哪个数据库
  • 有哪些public的工具类、常量
  • 应用跑再哪个机器上，IP多少，内存多大

current_app.name
current_app.test_value='value'

g变量

g 作为 flask 程序全局的一个临时变量,充当者中间媒介的作用,我们可以通过它传递一些数据，g 保存的是当前请求的全局变量，不同的请求会有不同的全局变量，通过不同的thread id区别

 

flask_script

#! /usr/bin/env python
# *-* coding: utf-8 *-*


from flask import Flask
# 请求上下文的变量
from flask import request, make_response
# 运用上下文的变量
from flask_script import Manager
from flask import current_app
from flask import g

app = Flask(__name__)
app.debug = True
manager = Manager(app)


@app.route('/')
def hello_world():
    # 类似于一个全局变量的东西
    print(current_app.config.get("DEBUG"))
    return 'Hello World!'


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

通过使用Flask-Script扩展，我们可以在Flask服务器启动的时候，通过命令行的方式传入参数。而不仅仅通过app.run()方法中传参，比如我们可以通过：

python hello.py runserver -host ip地址