flask学习

作者: Ghost_3538 | 来源:发表于2018-04-02 19:24 被阅读57次

如何理解wsgi, Werkzeug, flask之间的关系

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

快速入门

最小应用代码实现

from flask import Flask   这个类的实例是我们的 WSGI 应用程序
app = Flask(__name__)  创建一个该类的实例，第一个参数是应用模块或者包的名称。
app.debug = True  如果你启用了调试支持，服务器会在代码修改后自动重新载入，并在发生错误时提供一个相当有用的调试器。

@app.route('/')   使用 route() 装饰器告诉 Flask 什么样的URL 能触发我们的函数。
def hello_world():
    return 'Hello World!'

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

启用调试模式

app.debug = True 如果你启用了调试支持，服务器会在代码修改后自动重新载入，并在发生错误时提供一个相当有用的调试器。

或者： app.run(debug=True)

路由

Flask 的 URL 规则基于 Werkzeug 的路由模块。这个模块背后的思想是基于 Apache 以及更早的 HTTP 服务器主张的先例，保证优雅且唯一的 URL。

app.route() 装饰器把一个函数绑定到对应的 URL 上。

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

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

变量规则

要给 URL 添加变量部分，你可以把这些特殊的字段标记为 <variable_name> ，这个部分将会作为命名参数传递到你的函数。规则可以用 <converter:variable_name> 指定一个可选的转换器。

@app.route('/user/<username>')
def show_user_profile(username):
    # show the user profile for that user
    return 'User %s' % username

@app.route('/post/<int:post_id>')
def show_post(post_id):
    # show the post with the given id, the id is an integer
    return 'Post %d' % post_id

构造 URL 好处：它允许你一次性修改 URL，而不是到处边找边改。

你可以用 url_for() 来给指定的函数构造 URL。它接受函数名作为第一个参数，也接受对应 URL 规则的变量部分的命名参数。未知变量部分会添加到 URL 末尾作为查询参数。

>>> with app.test_request_context():
...  print url_for('index')
...  print url_for('login')
...  print url_for('login', next='/')
...  print url_for('profile', username='John Doe')
...
/
/login
/login?next=/
/user/John%20Doe

HTTP 方法

默认情况下，路由只回应 GET 请求，但是通过 route() 装饰器传递 methods 参数可以改变这个行为。

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        do_the_login()
    else:
        show_the_login_form()

静态文件

给静态文件生成地址

在你的包中或是模块的所在目录中创建一个名为 static 的文件夹，在应用中使用 /static 即可访问。
给静态文件生成 URL ，使用特殊的 'static' 端点名:

url_for('static', filename='style.css')
这个文件应该存储在文件系统上的 static/style.css

模板渲染

可以使用 render_template() 方法来渲染模板代码实现

from flask import render_template

@app.route('/hello/')
@app.route('/hello/<name>')
def hello(name=None):
    return render_template('hello.html', name=name)

模板文件

<!doctype html>
<title>Hello from Flask</title>
{% if name %}
  <h1>Hello {{ name }}!</h1>
{% else %}
  <h1>Hello World!</h1>
{% endif %}

请求对象

当前请求的 HTTP 方法可通过 method 属性来访问。通过:attr:~flask.request.form 属性来访问表单数据（ POST 或 PUT 请求提交的数据）

你可以通过 args 属性来访问 URL 中提交的参数（ ?key=value ）:

searchword = request.args.get('q', '')

@app.route('/login', methods=['POST', 'GET'])
def login():
    error = None
    if request.method == 'POST':      通过method方法获取请求方法
        if valid_login(request.form['username'],  通过request.form 方法获取表单数据
                       request.form['password']):
            return log_the_user_in(request.form['username'])
        else:
            error = 'Invalid username/password'
    # the code below is executed if the request method
    # was GET or the credentials were invalid
    return render_template('login.html', error=error)

文件上传

用 Flask 处理文件上传很简单。只要确保你没忘记在 HTML 表单中设置 enctype="multipart/form-data" 属性，不然你的浏览器根本不会发送文件。

from flask import request

@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
    if request.method == 'POST':
        f = request.files['the_file']       获取文件
        f.save('/var/www/uploads/uploaded_file.txt')  保存文件
    ...

from flask import request
from werkzeug import secure_filename

@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
    if request.method == 'POST':
        f = request.files['the_file']   获取文件
        f.save('/var/www/uploads/' + secure_filename(f.filename))  安全获取文件的名称

Cookie

设置cookie

from flask import make_response

@app.route('/')
def index():
    resp = make_response(render_template(...))
    resp.set_cookie('username', 'the username')
    return resp

读取cookie

from flask import request

@app.route('/')
def index():
    username = request.cookies.get('username')
    # use cookies.get(key) instead of cookies[key] to not get a
    # KeyError if the cookie is missing.

重定向和错误

from flask import abort, redirect, url_for

@app.route('/')
def index():
    return redirect(url_for('login'))  重定向

@app.route('/login')
def login():
    abort(401)   错误
    this_is_never_executed()

定制错误页面

from flask import render_template

@app.errorhandler(404)
def page_not_found(error):
    return render_template('page_not_found.html'), 404

flask响应方式三种

如果返回的是一个合法的响应对象，它会从视图直接返回。
如果返回的是一个字符串，响应对象会用字符串数据和默认参数创建。
如果返回的是一个元组，且元组中的元素可以提供额外的信息。这样的元组必须是 (response, status, headers) 的形式，且至少包含一个元素。 status 值会覆盖状态代码， headers 可以是一个列表或字典，作为额外的消息标头值。
如果上述条件均不满足， Flask 会假设返回值是一个合法的 WSGI 应用程序，并转换为一个请求对象。

@app.errorhandler(404)
def not_found(error):
    resp = make_response(render_template('error.html'), 404)
    resp.headers['X-Something'] = 'A value'
    return resp

会话session

在 Cookies 的基础上实现的，并且对 Cookies 进行密钥签名

from flask import Flask, session, redirect, url_for, escape, request

app = Flask(__name__)

@app.route('/')
def index():
    if 'username' in session:
        return 'Logged in as %s' % escape(session['username'])
    return 'You are not logged in'

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        session['username'] = request.form['username']  登录设置session值
        return redirect(url_for('index'))
    return '''
        <form action="" method="post">
            <p><input type=text name=username>
            <p><input type=submit value=Login>
        </form>
    '''

@app.route('/logout')
def logout():
    # remove the username from the session if it's there
    session.pop('username', None)          退出登录，删除session值，去掉登录状态
    return redirect(url_for('index'))

# set the secret key.  keep this really secret:
app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'   session签名随机密码

消息闪现

消息日志记录

日志记录格式

app.logger.debug('A value for debugging')
app.logger.warning('A warning occurred (%d apples)', 42)
app.logger.error('An error occurred')

代码实现

import logging
from flask import Flask
app = Flask(__name__)
app.debug = True

@app.route('/')
def hello_world():
    try:
        j = 1/0
    except:
        app.logger.debug("message_info") 记录日志
    print "haha"
    return 'Hello World!'

if __name__ == '__main__':
    handler = logging.FileHandler('flask.log', encoding='UTF-8')
    handler.setLevel(logging.DEBUG)
    logging_format = logging.Formatter(
        '%(asctime)s - %(levelname)s - %(filename)s - %(funcName)s - %(lineno)s - %(message)s')
    handler.setFormatter(logging_format)
    app.logger.addHandler(handler)
    app.run('localhost',9999)

可插拨视图

主要用途：可定制，可插拨的视图来替代部分实现

第一步：创建一个flask.views.View 的子类，并且引入dispatch_request()方法

第二步：通过使用as_view()方法，把类转换成实际视图函数

from flask.views import View 
class ShowUsers(View):
    def dispatch_request(self):
        users = User.query.all()
        return render_template('users.html', objects=users)
app.add_url_rule('/users/', view_func=ShowUsers.as_view('show_users'))  传递给函数的 字符串是最终视图的名称

也可以基于http方法调度：

from flask.views import MethodView 
class UserAPI(MethodView):
    def get(self):
        users = User.query.all() 
        ...
    def post(self):
        user = User.from_form_data(request.form) 
        ...
app.add_url_rule('/users/', view_func=UserAPI.as_view('users'))

蓝图

基本概念：蓝图被注册到应用之后。所要执行的操作的集合，Flask 会把蓝图和视图函数关联起来,并生成两个端点之前的 URL 。

蓝图blueprint，实现应用模块化，使用蓝图让应用层次清晰，开发者可以更容易开发，和维护项目

蓝图，通常作用于相同的URL地址前缀，他们可以放在同一个模块中。

蓝图可以极大简化应用并为扩展提供集中的注册入口。

blueprint对象和flask应用对象的工作方式类似，但不是一个真正的应用。它更像一个用于构建和扩展应用的蓝图

为什么使用蓝图：

把一个应用分解为一套蓝图。这是针对大型应用的理想方案:一个项目可以实例化一个应用,初始化多个扩展,并注册许多蓝图。
在一个应用的 URL 前缀和(或)子域上注册一个蓝图。 URL 前缀和(或)子域的参数成为蓝图中所有视图的通用视图参数(缺省情况下)。
使用不同的 URL 规则在应用中多次注册蓝图。
通过蓝图提供模板过滤器、静态文件、模板和其他工具。蓝图不必执行应用或视图函数。
蓝图的缺点是一旦应用被创建后,只有销毁整个应用对象才能注销蓝图。

蓝图实例：show.py

from flask import Blueprint, render_template, abort 
from jinja2 import TemplateNotFound
simple_page = Blueprint('simple_page', __name__, template_folder='templates')

@simple_page.route('/', defaults={'page': 'index'})  使用此装饰器时，蓝图会记录下所登记的show函数
@simple_page.route('/<page>')
def show(page):
    try:
        return render_template('pages/%s.html' % page)
    except TemplateNotFound: 
        abort(404)

当以后注册蓝图时，这个函数会被注册到应用中，它会把 构建 Blueprint 时所使用的名称(在本例为 simple_pa ge )作为函数端点 的前缀。

可以这样注册蓝图：

# app.py

from flask import Flask
from user.simple_page import simple_page
app = Flask(__name__) 
app.register_blueprint(simple_page)

注册后形成的url--视图映射规则：
[<Rule '/static/<filename>' (HEAD, OPTIONS, GET) -> static>, 
<Rule '/<page>' (HEAD, OPTIONS, GET) -> simple_page.show>,
<Rule '/' (HEAD, OPTIONS, GET) -> simple_page.show>]

蓝图还可以挂接到不同的位置:
app.register_blueprint(simple_page, url_prefix='/pages')

这样就会形成如下规则:
[<Rule '/static/<filename>' (HEAD, OPTIONS, GET) -> static>,
<Rule '/pages/<page>' (HEAD, OPTIONS, GET) -> simple_page.show>, 
<Rule '/pages/' (HEAD, OPTIONS, GET) -> simple_page.show>]

总之,你可以多次注册蓝图,但是不一定每个蓝图都能正确响应。是否能够多次注册实际 上取决于你的蓝图是如 何编写的,是否能根据不同的位置做出正确的响应。

蓝图资源

静态文件：

蓝图的第三个参数是 static_folder 。
这个参数用以指定蓝图的静态文件所在的文件夹,它可以是一个绝对路径也 可以是相对路径。:
admin = Blueprint('admin', __name__, static_folder='static')

模板：
使用蓝图来暴露模板,那么可以使用 Blueprint 的 template_folder 参数:
admin = Blueprint('admin', __name__, template_folder='templates') 分绝对和相对

理解上下文（上下文是环境的一个快照，是一个用来保存状态的对象）

flask分应用上下文和请求上下文


current_app = LocalProxy(_find_app)   应用上下文，当前app实例对象

g = LocalProxy(partial(_lookup_app_object, 'g')) 应用上下文，用作零时存储的对象
每个请求的g都是独立的，并且在整个请求内都是可访问修改的。
对g对象调用过程如下：
    访问g-->从当前线程的应用上下文栈顶获取应用上下文-->取出其中的g对象-->进行操作。
所以可以通过一个g对象而让所有线程互不干扰的访问自己的g。

request = LocalProxy(partial(_lookup_req_object, 'request'))  请求上下文，封装了客户端发出的http请求
session = LocalProxy(partial(_lookup_req_object, 'session'))  请求上下文，存储用户对话

本地线程

Thread Local 希望不同的线程对于内容的修改只在线程内发挥作用，线程间互不影响

原理：threading.current_thread().dict里添加一个包含对象mydata的id的值，保存不同线程的状态

Werkzeug Local

Werkzeug 使用自定义storage保存不同线程下的状态

提供释放本地线程的release_local方法

获取get_ident函数，获取线程或者协程标识符

Werkzeug 两种数据结构

LocalStack : 基于Werkzeug.local.local 实现的栈结构，可以将对象推入和弹出，可以快速拿到栈顶对象。

LocalProxy：标准代理模式，这个函数执行之后就是通过LocalStack实例化的栈顶的栈顶对象，对于LocalProxy对象的操作都会转发到这个栈顶对象。

理解flask.request

源码globles.py 文件

from functools import partial
from werkzeug.local import LocalStack, LocalProxy

def _lookup_req_object(name):
    top = _request_ctx_stack.top     _request_ctx_stack是底层一个请求上下文栈结构
    if top is None:
        raise RuntimeError(_request_ctx_err_msg)
    return getattr(top, name)

request = LocalProxy(partial(_lookup_req_object, 'request')) 

请求上下文request流程如下：
    1，请求产生
    2，请求过程中向 _request_ctx_stack推入请求上下文对象，这个请求上下文会变成栈顶，request就会成为这个请求上下文，也就包含了这次请求相关的信息和数据。
    3，在视图函数使用request就可以使用request.args.get('name')

flask扩展生态

Flask-Script 添加运行服务器，设置数据库，定制shell等功能的命令。

Flask-WTF 处理web表单

Flask-Sqlalchemy 关系型数据库扩展

Flask-RESTful 实现一个Restful的请求

Flask-Mail 发送邮件

Flask-Babel 国际化I18N和本地化L10N

Flask-PyMongo 使用MongoDB数据库

Flask-Cache 使用缓存

Flask-Login 登录管理

Flask-HTTPAuth 认证

Flask-Admin 是一个简单易用的Flask扩展，让你可以很方便并快速地为Flask应用程序增加管理界面。

Flask-DebugToolbar 内置调试工具

Flask-Migrate 数据库迁移框架

Flask-Security 提供角色管理，权限管理，用户登录，邮箱验证，密码重置，密码加密

flask 钩子函数使用方法

before_first_request

注册一个函数,在处理第一个请求之前运行，只运行一次，后面不再运行

示例：
@app.before_first_request  
def bf_first_request():  
    g.string = 'before_first_request'

before_request

注册一个函数,在处理每次请求之前运行.每次都运行

@app.before_request和@app.teardown_request的组合可以用于打开一个资源和关闭一个资源，

@app.before_request  
def bf_request():  
    g.string = 'before_request'

after_request

注册一个函数,在每次请求之后运行.注册的函数至少需要含有一个参数,这个参数实际上为服务器的响应,且函数中需要返回这个响应参数.

装饰器修饰的函数接收一个响应对象，我们拿到了这个响应对象后可以对内容进行修改（虽然很少见）还可以在上面追加COOKIE进行返回。

@app.after_request  
def af_request(param):  
    return param  接收这个参数，然后要返回

 param是服务器的响应 
 示例：
 {'_on_close': [], 'response': ['Hello World!'], 'headers': Headers([('Content-Type', u'text/html; charset=utf-8'), ('Content-Length', u'12')]), '_status_code': 200, '_status': '200 OK', 'direct_passthrough': False}

teardown_request

会在每个请求后执行，请求发生异常时也会被调用，处理函数必须传入参数接收异常信息

@app.teardown_request修饰的函数在非调试模式下才能在出现异常时被执行

@app.teardown_request
def teardown_request(error):
    print("请求之后调用")

app.errorhandler

装饰器用于错误处理

传入装饰器的值为一错误状态码，修饰的函数必须要有一个参数用于接收错误，为了测试500的效果必须关闭调试模式！

@app.errorhandler(404)
def notFound(error):
    return "404"
@app.errorhandler(500)
def notFound(error):
    return "500"

flask学习

如何理解wsgi, Werkzeug, flask之间的关系

快速入门

启用调试模式

路由

变量规则

构造 URL 好处：它允许你一次性修改 URL，而不是到处边找边改。

HTTP 方法

静态文件

模板渲染

请求对象

文件上传

Cookie

重定向和错误

flask响应方式三种

会话session

消息闪现

消息日志记录

可插拨视图

蓝图

蓝图资源

理解上下文（上下文是环境的一个快照，是一个用来保存状态的对象）

本地线程

理解flask.request

flask扩展生态

flask 钩子函数使用方法

before_first_request

before_request

after_request

teardown_request

app.errorhandler

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

flask

我爱编程

flask框架

flask学习

如何理解wsgi, Werkzeug, flask之间的关系

快速入门

启用调试模式

路由

变量规则

构造 URL 好处：它允许你一次性修改 URL， 而不是到处边找边改。

HTTP 方法

静态文件

模板渲染

请求对象

文件上传

Cookie

重定向和错误

flask响应方式三种

会话session

消息闪现

消息日志记录

可插拨视图

蓝图

蓝图资源

理解上下文（上下文是环境的一个快照，是一个用来保存状态的对象）

本地线程

理解flask.request

flask扩展生态

flask 钩子函数使用方法

before_first_request

before_request

after_request

teardown_request

app.errorhandler

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

flask

我爱编程

flask框架

构造 URL 好处：它允许你一次性修改 URL，而不是到处边找边改。