Python 【web框架】之Flask

时间 2020-06-09

原文原文链接

flask 是Python实现的轻量级web框架。没有表单，orm等，但扩展性很好。不少Python web开发者十分喜欢。本篇介绍flask的简单使用及其扩展。html

文中示例源码已经传到github：https://github.com/ZingP/webstudy.git.前端

1 安装flask

pip install flask

2 框架本质

flask是基于Werkzeug模块和Jinja2模板引擎实现的。前者实现了WSGI协议。咱们来看一下用Werkzeug怎么实现一个web服务端：python

from werkzeug.wrappers import Request, Response

@Request.application
def hello(request):
    print(request)
    return Response('Hello Werkzeug!')

if __name__ == '__main__':
    from werkzeug.serving import run_simple
    run_simple('localhost', 9000, hello)

而后运行该文件，从浏览器上访问http://localhost:9000/ 就能看到Hello Werkzeug!了。mysql

3 快速开始

开始第一个flask：git

from flask import Flask,render_template

app = Flask(__name__)     # 建立一个Flask对象，__name__传成其余字符串也行。

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

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

直接运行，而后访问http://127.0.0.1:5000/就能够看到Hello world！了。其中Flask这个类中能够初始化如下变量：（能够点击Flask进去看源码，能够看到构造函数）github

def __init__(
        self,
        import_name,                        # 能够写任意字符串，通常写__name__，这样不会重名
        static_url_path=None,               # 静态文件前缀，若是该项配置成static_url_path='/yyy',访问静态文件的目录则为http://127.0.0.1:5000/sss/**.jpg
        static_folder='static',             # 静态文件路径，好比在项目目录下建立static目录，存放静态文件。访问经过http://127.0.0.1:5000/static/**.jpg
        static_host=None,
        host_matching=False,
        subdomain_matching=False,
        template_folder='templates',        # 模板文件夹，视图函数中须要引入from flask import render_template
        instance_path=None,                 # 当前路径/instance
        instance_relative_config=False,     # 若是该项为True,则会到 上面这个路径下去找配置文件
        root_path=None                      # 根目录
    ):

4 配置文件

flask的配置有不少种方式：web

（1）经过字典类型配置，直接在视图函数所在的py文件里，经过app.config['字段名'] = 值，就能够配置了。如：正则表达式

app.config['DEBUG'] = True  # 打开调试模式，以字典的方式配置

字段名能够有如下内容：redis

default_config = ImmutableDict({
        'ENV':                                  None,
        'DEBUG':                                None,
        'TESTING':                              False,
        'PROPAGATE_EXCEPTIONS':                 None,
        'PRESERVE_CONTEXT_ON_EXCEPTION':        None,
        'SECRET_KEY':                           None,
        'PERMANENT_SESSION_LIFETIME':           timedelta(days=31),
        'USE_X_SENDFILE':                       False,
        'SERVER_NAME':                          None,
        'APPLICATION_ROOT':                     '/',
        'SESSION_COOKIE_NAME':                  'session',
        'SESSION_COOKIE_DOMAIN':                None,
        'SESSION_COOKIE_PATH':                  None,
        'SESSION_COOKIE_HTTPONLY':              True,
        'SESSION_COOKIE_SECURE':                False,
        'SESSION_COOKIE_SAMESITE':              None,
        'SESSION_REFRESH_EACH_REQUEST':         True,
        'MAX_CONTENT_LENGTH':                   None,
        'SEND_FILE_MAX_AGE_DEFAULT':            timedelta(hours=12),
        'TRAP_BAD_REQUEST_ERRORS':              None,
        'TRAP_HTTP_EXCEPTIONS':                 False,
        'EXPLAIN_TEMPLATE_LOADING':             False,
        'PREFERRED_URL_SCHEME':                 'http',
        'JSON_AS_ASCII':                        True,
        'JSON_SORT_KEYS':                       True,
        'JSONIFY_PRETTYPRINT_REGULAR':          False,
        'JSONIFY_MIMETYPE':                     'application/json',
        'TEMPLATES_AUTO_RELOAD':                None,
        'MAX_COOKIE_SIZE': 4093,
    })

经过app.字段名 = 值，如：sql

app.debug = True  # 调试模式

这种方式是之前一种方式为基础的，将第一种方式中的各类字段，抽出经常使用字段，让其支持这种配置方式。

另外直接更新一个字典也能够：

app.config.update({...})  #更新这个字典的方式

（2）　方式二：从py文件中导入配置。app.config.from_pyfile('.py文件')，如：

app.config.from_pyfile('settings.py')

相似还有：

app.config.from_pyfile('settings.py')

# app.config.from_envvar('环境变量名')
# 若是环境变量名为py文件，会自动调用app.config.from_pyfile()

# app.config.from_json('json文件')            # json文件形式

# app.config.from_mapping({"DEBUG": True})    # 字典形式

# app.config.from_object('python类或者类的路径')
# app.config.from_object('settings.TestConfig')

# 在settings.py中：
class Config(object):
    DEBUG = False
    TESTING = False
    DATABASE_URI = 'sqlite://:memory:'


class ProductionConfig(Config):
    DATABASE_URI = 'mysql://user@localhost/foo'


class DevelopmentConfig(Config):
    DEBUG = True


class TestConfig(Config):
    TESTING = True

注意：配置文件中的key必须是大写；另外，经过类导入配置文件的路径须要从sys.path中存在的开始写。

5 路由系统

5.1 常规路由

flask 的路由系统是有一个装饰器+视图函数实现：

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

当我看到这样的路由方式仍是比较惊讶的，不过不论是什么样的路由，最后都是将url和视图函数一一对应。若是咱们点开route这个装饰器，不难看到这样一句源码：

def route(self, rule, **options):
        """A decorator that is used to register a view function for a
        given URL rule.  This does the same thing as :meth:`add_url_rule`
        but is intended for decorator usage::

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

        For more information refer to :ref:`url-route-registrations`.

        :param rule: the URL rule as string
        :param endpoint: the endpoint for the registered URL rule.  Flask
                         itself assumes the name of the view function as
                         endpoint
        :param options: the options to be forwarded to the underlying
                        :class:`~werkzeug.routing.Rule` object.  A change
                        to Werkzeug is handling of method options.  methods
                        is a list of methods this rule should be limited
                        to (``GET``, ``POST`` etc.).  By default a rule
                        just listens for ``GET`` (and implicitly ``HEAD``).
                        Starting with Flask 0.6, ``OPTIONS`` is implicitly
                        added and handled by the standard request handling.
        """
        def decorator(f):
            endpoint = options.pop('endpoint', None)
            self.add_url_rule(rule, endpoint, f, **options)
            return f
        return decorator

从self.add_url_rule(rule, endpoint, f, **options)这句看，flask是经过装饰器把路由规则和视图函数关联起来。实际上咱们也能够这么写路由：

def hello_world():
    from flask import url_for
    url = url_for("xxx")
    print("URL:", url)
    return 'Hello World!'

app.add_url_rule("/", view_func=hello_world, endpoint="xxx", methods=['GET', 'POST'])
# endpoint 这里用来反向生成url，默认是函数名
# methods 指的是支持的请求方式

不过推荐仍是用装饰器的方式写路由，经常使用路由写法有如下几种：

@app.route('/user/<username>')
@app.route('/post/<int:post_id>')
@app.route('/post/<float:post_id>')
@app.route('/post/<path:path>')
@app.route('/login', methods=['GET', 'POST'])

注意，当匹配参数是，须要在视图函数中接收一下，如：

@app.route('/user/<int:uid>')
def hello_world(uid):
    print("UID:", uid)
    return 'Hello World!'

规则支持的匹配类型有如下几种：

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

5.2 自定义路由

也许你会以为这些路由规则不太自由，不够用；那么能够经过自定义的方式：

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

app = Flask(__name__)


# 自定义经过正则匹配url
class RegexConverter(BaseConverter):
    """
    自定义URL匹配正则表达式
    """

    def __init__(self, map, regex):
        super(RegexConverter, self).__init__(map)
        self.regex = regex   # 会按照传入的正则表达式进行匹配

    def to_python(self, value):
        """
        路由匹配时，匹配成功后传递给视图函数中参数的值
        :param value: 
        :return: 
        """
        return value

    def to_url(self, value):
        """
        使用url_for反向生成URL时，传递的参数通过该方法处理，返回的值用于生成URL中的参数
        :param value: 
        :return: 
        """
        val = super(RegexConverter, self).to_url(value)
        return val

# 添加到flask中
app.url_map.converters['regex'] = RegexConverter


@app.route('/index/<regex("\d+"):nid>')
def index(nid):
    print(nid)
    url = url_for('index', nid=nid)    # 反向生成url
    print(url)
    return 'Index'


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

运行以后，访问http://127.0.0.1:5000/index/9999会在后端打印nid是9999，而反向生成的url是/index/9999。

5.3 使用装饰器

也许咱们想给视图函数定制一些功能，好比加一些装饰器，那应该这样写：

def auth(func):
    def inner(*args, **kwargs):
        print('before')
        result = func(*args, **kwargs)
        print('after')
        return result

    return inner


@app.route('/index.html', methods=['GET', 'POST'], endpoint='index')
@auth       # 装饰器必定要放在app.route这个装饰器之下
def index():
    return 'Index'

其中，装饰器auth必定要放在app.route这个装饰器之下才能使路由装饰器先生效。路由还能够这样写：

def index():
    return "Index"

# 方式一：
# app.add_url_rule(rule='/index.html', endpoint="index", view_func=index, methods=["GET", "POST"])

# 方式二：
app.add_url_rule(rule='/index.html', endpoint="index", view_func=index, methods=["GET", "POST"])
app.view_functions['index'] = index

5.4 支持CBV

是否能像django同样支持CBV呢？固然能够：

from flask import views
def auth(func):
    def inner(*args, **kwargs):
        print('before')
        result = func(*args, **kwargs)
        print('after')
        return result

    return inner


class IndexView(views.View):
    methods = ['GET']
    decorators = [auth, ]

    def dispatch_request(self):
        print('Index')
        return 'Index!'


app.add_url_rule('/index', view_func=IndexView.as_view(name='index'))  # name=endpoint 反向url使用

其中，decorators是须要添加的装饰器。固然还能够定义get，post等函数：

class IndexView(views.MethodView):
    methods = ['GET', 'POST']
    decorators = [auth, ]

    def get(self):
        return 'Index.GET'

    def post(self):
        return 'Index.POST'

app.add_url_rule('/index', view_func=IndexView.as_view(name='index'))  # name=endpoint

补充，@app.route和app.add_url_rule参数：

# rule,                  URL规则

# view_func,             视图函数名称

# defaults = None,       默认值, 当URL中无参数，函数须要参数时，使用defaults = {'k': 'v'}为函数提供参数

# endpoint = None,       名称，用于反向生成URL，即： url_for('名称')

# methods = None,        容许的请求方式，如：["GET", "POST"]

# strict_slashes = None, 对URL最后的 / 符号是否严格要求，
# 如：@app.route('/index', strict_slashes=False)访问http: //www.xx.com/index/或http://www.xx.com/index都可
#    @app.route('/index', strict_slashes=True)仅能访问http://www.xx.com/index  

# redirect_to = None, 重定向到指定地址如：@app.route('/index/<int:nid>', redirect_to='/home/<nid>')
# 或
# def func(adapter, nid):
#     return "/home/888"
# @app.route('/index/<int:nid>', redirect_to=func)

# subdomain = None, 子域名访问
app = Flask(import_name=__name__)
app.config['SERVER_NAME'] = 'lyy.com:5000'
@app.route("/", subdomain="admin")
def static_index():
    """Flask supports static subdomains
    This is available at static.your-domain.tld"""
    return "static.your-domain.tld"

@app.route("/dynamic", subdomain="<username>")
def username_index(username):
    """Dynamic subdomains are also supported
    Try going to user1.your-domain.tld/dynamic"""
    return username + ".your-domain.tld"

6 使用模板

6.1 常规模板

使用的是jinjia2语法，和django差很少。除了不支持simple_tag，毕竟有更简便的方法自定义。

6.2 自定义模板

py文件：返回HTML文档时须要引入 render_template

from flask import Flask, render_template

app = Flask(__name__)

# 可直接定义一个函数，到前端页面去使用
def myhtml(abc):
    return '<h1>liuyouyuan{}</h1>'.format(abc)

@app.route('/index', methods=['GET', 'POST'])
def login():
    return render_template('index.html', yyy=myhtml)    # yyy就至关于前端使用时的函数名字

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

看看index.html直接给yyy()传参数，就像调用Python函数同样：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <p>{{ yyy("niubi")|safe}}</p>
</body>
</html>

7 请求与响应

7.1 视图函数中拿到请求信息

在flask中，须要引入from flask import request，经过request拿到请求信息。

from flask import Flask, request

app = Flask(__name__)

@app.route('/')
def hello_world():
    print(request)      # 引入request以后，不须要手动传给视图函数，flask内部会自动传，直接获取就行。
    return 'Hello World!'


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

能够看到，引入request以后，不须要手动传给视图函数，flask内部会自动传，直接获取就行。能够从request中获取到的请求信息有：

# 请求相关信息
# request.method
# request.args
# request.form
# request.values
# request.cookies
# request.headers
# request.path
# request.full_path
# request.script_root
# request.url
# request.base_url
# request.url_root
# request.host_url
# request.host
# request.files
# obj = request.files['the_file_name']
# obj.save('/var/www/uploads/' + secure_filename(f.filename))

其中获取文件直接save到一个目录就行。

7.2 相应相关

from flask import render_template
from flask import redirect
from flask import make_response

# 响应相关信息
# return "字符串"
# return render_template('html模板路径',**{})
# return redirect('/index.html')

# response = make_response(render_template('index.html'))
# response是flask.wrappers.Response类型
# response.delete_cookie('key')
# response.set_cookie('key', 'value')
# response.headers['X-Something'] = 'A value'

在flask中基本都是经过导入一个全局的变量，而后从视图函数中直接引用，每一个视图函数每次请求来拿到的都是不同的。

8 session

8.1 默认session

默认的Session是基于Cookies实现的，放在浏览器上。若是要对session加密，须要设置密钥。基本使用以下：

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']
        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():
    # 从session移除username
    session.pop('username', None)
    return redirect(url_for('index'))


# 若是要加密session，在此处设置秘钥
app.secret_key = 'reffbyujHSDU!ASn#UIddODN*1243 WEfM'

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

8.2 自定义session

flask中的SessionInterface留了两个钩子函数，咱们来看一下：

def open_session(self, app, request):
	"""This method has to be implemented and must either return ``None``
	in case the loading failed because of a configuration error or an
	instance of a session object which implements a dictionary like
	interface + the methods and attributes on :class:`SessionMixin`.
	"""
	raise NotImplementedError()

def save_session(self, app, session, response):
	"""This is called for actual sessions returned by :meth:`open_session`
	at the end of the request.  This is still called during a request
	context so if you absolutely need access to the request you can do
	that.
	"""
	raise NotImplementedError()

请求来时，open_session会尝试去获取session；当返回信息时，会调用save_session。因此，咱们要自定义session时，只须要继承接口类，再重写这两个方法便可。　　

如今新建一个session.py文件，写好自定义的session类：

import uuid
import json
from flask.sessions import SessionInterface
from flask.sessions import SessionMixin
from itsdangerous import Signer, BadSignature, want_bytes


class MySession(dict, SessionMixin):
    def __init__(self, initial=None, sid=None):
        self.sid = sid
        self.initial = initial
        super(MySession, self).__init__(initial or ())

    def __setitem__(self, key, value):
        super(MySession, self).__setitem__(key, value)

    def __getitem__(self, item):
        return super(MySession, self).__getitem__(item)

    def __delitem__(self, key):
        super(MySession, self).__delitem__(key)


class MySessionInterface(SessionInterface):
    session_class = MySession
    container = {}

    def __init__(self):
        import redis
        self.redis = redis.Redis()

    def _generate_sid(self):
        return str(uuid.uuid4())

    def _get_signer(self, app):
        if not app.secret_key:
            return None
        return Signer(app.secret_key, salt='flask-session',
                      key_derivation='hmac')

    def open_session(self, app, request):
        """
        程序刚启动时执行，须要返回一个session对象
        """
        sid = request.cookies.get(app.session_cookie_name)
        if not sid:
            sid = self._generate_sid()
            return self.session_class(sid=sid)

        signer = self._get_signer(app)
        try:
            sid_as_bytes = signer.unsign(sid)
            sid = sid_as_bytes.decode()
        except BadSignature:
            sid = self._generate_sid()
            return self.session_class(sid=sid)

        # session保存在redis中
        # val = self.redis.get(sid)
        # session保存在内存中
        val = self.container.get(sid)

        if val is not None:
            try:
                data = json.loads(val)
                return self.session_class(data, sid=sid)
            except:
                return self.session_class(sid=sid)
        return self.session_class(sid=sid)

    def save_session(self, app, session, response):
        """
        程序结束前执行，能够保存session中全部的值
        如：
            保存到resit
            写入到用户cookie
        """
        domain = self.get_cookie_domain(app)
        path = self.get_cookie_path(app)
        httponly = self.get_cookie_httponly(app)
        secure = self.get_cookie_secure(app)
        expires = self.get_expiration_time(app, session)

        val = json.dumps(dict(session))

        # session保存在redis中
        # self.redis.setex(name=session.sid, value=val, time=app.permanent_session_lifetime)
        # session保存在内存中
        self.container.setdefault(session.sid, val)

        session_id = self._get_signer(app).sign(want_bytes(session.sid))

        response.set_cookie(app.session_cookie_name, session_id,
                            expires=expires, httponly=httponly,
                            domain=domain, path=path, secure=secure)

用法以下：

from flask import Flask
from flask import session
from session import MySessionInterface
app = Flask(__name__)

app.secret_key = 'asdWhuDW!@##%bxwy'
app.session_interface = MySessionInterface()

@app.route('/login', methods=['GET', "POST"])
def login():
    print(session)
    session['user1'] = 'lyy'
    session['user2'] = 'yy'
    del session['user2']
    print(session)
    return "test mysession"

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

这样就能够了。

8.3 第三方插件

pip install flask-session 使用简单，能够参考https://pythonhosted.org/Flask-Session/。不过目前只支持flask0.8,此处不在演示。

9 使用蓝图

咱们回想一下以前的全部介绍都是将视图函数写在同一个.py文件中的，对于微小项目能够，可是稍微大点的项目咱们不可能把视图函数都写在同一个文件，否则找起来都很麻烦。因此，确定是要根据必定的逻辑进行目录划分的。蓝图的做用就是划分目录结构。

不过咱们在介绍蓝图以前，先尝试着本身划分一下目录：

9.1 本身划分目录

一个小项目，应该包含app就是app名称，static放置静态文件，views下将视图按功能分为多个py文件。run.py是入口。

(1)__init__.py:

from flask import Flask
app = Flask(__name__)

from .views import account

必定要记得导入视图~~

(2)run.py:

from app import app

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

(3)account.py:

from .. import app

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

9.2 蓝图划分

(1)run.py:

from app01 import app

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

(2)account.py

from flask import Blueprint

account = Blueprint('account', __name__, url_prefix='/yyy', template_folder='', static_folder='')
# 能够为每一个蓝图单独指定一个模板文件和静态文件

@account.route('/')
def hello_world():
    return 'Hello blue!'

host.py:

from flask import Blueprint

host = Blueprint('host', __name__)

@host.route('/host.html')
def hello_host():
    return "host.."

__init__.py:

from flask import Flask
from .views.account import account
from .views.host import host

app = Flask(__name__)

app.register_blueprint(account)     # 注册蓝图
app.register_blueprint(host)

10 message

message在django中是没有的，它是基于Session实现的一个保存数据的集合，其特色是：使用一次就删除，能够用于错误信息。直接看代码吧：

from flask import Flask, flash, request, get_flashed_messages, url_for

app = Flask(__name__)
app.secret_key = 'ewqfQWDWEhqweofhqwofn'


@app.route('/')
def index1():
    messages = get_flashed_messages()   # 取出
    print(messages)
    return "index"


@app.route('/set', endpoint="xxx")
def index2():
    v = url_for("xxx")
    flash(v)    # 存入
    return 'hahahah'

这就OK了。

11 中间件

直接上代码：

from flask import Flask

app = Flask(__name__)

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


class MiddleWare:
    def __init__(self, wsgi_app):
        self.wsgi_app = wsgi_app

    def __call__(self, *args, **kwargs):
        print("456")   # do something
        return self.wsgi_app(*args, **kwargs)


if __name__ == "__main__":
    app.wsgi_app = MiddleWare(app.wsgi_app)
    app.run(port=9999)

12 更多插件

表单插件参考：WTForms orm能够用：SQLAchemy 更多可看：http://flask.pocoo.org/extensions 。