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虚拟环境的搭建

一，flask的基本使用：

 from flask import Flask

 app = Flask(__name__)

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

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

flask的基本使用

二，基本的配置

 # 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_python方法

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

to_url方法

视图的常用逻辑

不推荐使用 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的使用

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", "", 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)

cookie的设置

备注：

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"] = ""
     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)

session的设置

思考：在视图函数中，如何取到当前请求的相关数据？比如：请求地址，请求方式，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地址