flask 是Python实现的轻量级web框架。没有表单，orm等，但扩展性很好。很多Python web开发者十分喜欢。本篇介绍flask的简单使用及其扩展。
文中示例源码已经传到github：https://github.com/ZingP/webstudy.git.
1 安装flask
pip install flask
2 框架本质
flask是基于Werkzeug模块和Jinja2模板引擎实现的。前者实现了WSGI协议。我们来看一下用Werkzeug怎么实现一个web服务端：
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!了。
3 快速开始
开始第一个flask：
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进去看源码，可以看到构造函数）
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的配置有很多种方式：
（1）通过字典类型配置，直接在视图函数所在的py文件里，通过app.config['字段名'] = 值，就可以配置了。如：
app.config['DEBUG'] = True # 打开调试模式，以字典的方式配置
字段名可以有以下内容：
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.字段名 = 值，如：
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/')
@app.route('/post/')
@app.route('/post/')
@app.route('/post/')
@app.route('/login', methods=['GET', 'POST'])
注意，当匹配参数是，需要在视图函数中接收一下，如：
@app.route('/user/')
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/')
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/', redirect_to='/home/')
# 或
# def func(adapter, nid):
# return "/home/888"
# @app.route('/index/', 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="")
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 'liuyouyuan{}
'.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>Titletitle>
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 '''
'''
@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 。