Flask 基础

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

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

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

pip3 install flask

一. 基本使用

from flask import Flask

app = Flask(__name__)

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

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

二、配置文件

flask中的配置文件是一个flask.config.Config对象（继承字典）,默认配置为：
    {
        'DEBUG':                                get_debug_flag(default=False),  # 是否开启Debug模式
        '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,
        'LOGGER_HANDLER_POLICY':               'always',
        '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,
        'SESSION_REFRESH_EACH_REQUEST':         True,
        'MAX_CONTENT_LENGTH':                   None,
        'SEND_FILE_MAX_AGE_DEFAULT':            timedelta(hours=12),
        'TRAP_BAD_REQUEST_ERRORS':              False,
        'TRAP_HTTP_EXCEPTIONS':                 False,
        'EXPLAIN_TEMPLATE_LOADING':             False,
        'PREFERRED_URL_SCHEME':                 'http',
        'JSON_AS_ASCII':                        True,
        'JSON_SORT_KEYS':                       True,
        'JSONIFY_PRETTYPRINT_REGULAR':          True,
        'JSONIFY_MIMETYPE':                     'application/json',
        'TEMPLATES_AUTO_RELOAD':                None,
    }

方式一：
    app.config['DEBUG'] = True
    PS： 由于Config对象本质上是字典，所以还可以使用app.config.update(...)


方式二：
    1、app.config.from_pyfile("python文件名称")
    如：
        settings.py
            DEBUG = True
        app.config.from_pyfile("settings.py")

    2、app.config.from_envvar("环境变量名称")
        环境变量的值为python文件名称名称，内部调用from_pyfile方法

    3、app.config.from_json("json文件名称")
        JSON文件名称，必须是json格式，因为内部会执行json.loads

    4、app.config.from_mapping({'DEBUG':True})
        字典格式

    5、app.config.from_object("python类或类的路径")  # 从sys.path中已经存在路径开始写
    举例：
        app.config.from_object('pro_flask.settings.TestingConfig')
        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 TestingConfig(Config):
                TESTING = True

    PS: settings.py文件默认路径要放在程序root_path目录，如果instance_relative_config为True，则就是instance_path目录

三、路由系统

• @app.route('/user/<username>')     # 只有名字
• @app.route('/post/<int:post_id>')    # int 类型
• @app.route('/post/<float:post_id>') # float类型
• @app.route('/post/<path:path>')
• @app.route('/login', methods=['GET', 'POST'])

常用路由系统有以上五种，所有的路由系统都是基于以下对应关系来处理：

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

注册路由方式

#################### 第一种 ####################
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') # endpoint 不写默认为函数名 
@auth
def index():
    return 'Index'


#################### 第二种 ####################    
def index():
    return "Index"
self.add_url_rule(rule='/index.html', endpoint="index", view_func=index, methods=["GET","POST"])
# or
app.add_url_rule(rule='/index.html', endpoint="index", view_func=index, methods=["GET","POST"])
app.view_functions['index'] = index


#################### 第三种，CBV ####################
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']       # 允许的method
    decorators = [auth, ]   # 装饰器
    def dispatch_request(self):
        print('Index')
        return 'Index!'
app.add_url_rule('/index', view_func=IndexView.as_view(name='index'))  # name=endpoint


#################### 第四种 ####################
class IndexView(views.MethodView):
    methods = ['GET']
    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)  # 访问 www.xx.com/index/ 或 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,             # 子域名访问
        from flask import Flask, views, url_for
        app = Flask(import_name=__name__)
        app.config['SERVER_NAME'] = 'flepeng.com:5000'

        @app.route("/", subdomain="admin")  # 访问的是admin.flepeng.com:5000
        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>") # 访问的是xxx.flepeng.com:5000
        def username_index(username):
            """Dynamic subdomains are also supported
            Try going to user1.your-domain.tld/dynamic"""
            return username + ".your-domain.tld"

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

自定制路由匹配规则

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

app = Flask(import_name=__name__)

class RegexConverter(BaseConverter):
	"""
	自定义URL匹配正则表达式
	"""
	def __init__(self, map, regex):
		super(RegexConverter, self).__init__(map)
		self.regex = regex

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

	def to_url(self, value):
		"""
		使用url_for反向生成URL时，传递的参数经过该方法处理，返回的值用于生成URL中的参数
		"""
		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(url_for('index', nid='888'))
	return 'Index'

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

四、模板

1、模板的使用

Flask使用的是Jinja2模板，所以其语法和Django无差别，但是Flask的模板支持的语法更贴近python，支持函数等

2、自定义模板方法

Flask中自定义模板方法的方式和Bottle相似，创建一个函数并通过参数的形式传入render_template，如：

############### html文件 #####################
<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    <h1>自定义函数</h1>
    {{ww()|safe}}
</body>
</html>


############### run.py #####################
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Flask,render_template
app = Flask(__name__)
 
def index():
    return '<h1>index</h1>'
 
@app.route('/login', methods=['GET', 'POST'])
def login():
    return render_template('login.html', ww=index)
 
app.run()


############### 其他 html文件 #####################
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    {% macro input(name, type='text', value='') %}
        <input type="{{ type }}" name="{{ name }}" value="{{ value }}">
    {% endmacro %}

    {{ input('n1') }}
    {% include 'tp.html' %}
    <h1>asdf{{ v.k1}}</h1>
</body>
</html>

注意：Markup等价django的mark_safe

五、请求和响应

from flask import Flask
from flask import request
from flask import render_template
from flask import redirect
from flask import make_response

app = Flask(__name__)

@app.route('/login.html', methods=['GET', "POST"])
def login():
    # 请求相关信息 
    # request.url          http://127.0.0.1/console/editor
    # request.base_url     http://127.0.0.1/console/editor
    # request.url_root     http://127.0.0.1
    # request.host_url     http://127.0.0.1
    # request.host         127.0.0.1
    # request.files
    # f = request.files.get['file_name']   file_name为form表单的name值
    # f.save('/var/www/uploads/' + secure_filename(f.filename))  secure_filename：检测中文是否合法,f.save会直接保存
    
    # 响应相关信息
    # 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')              # 设置cookie
    # response.headers['X-Something'] = 'A value'      # 设置响应头
    # return response

    return "内容"
if __name__ == '__main__':
    app.run()

request 属性 

属性名	解释
form	一个从POST和PUT请求解析的 MultiDict（一键多值字典）。
args	MultiDict，要操作 URL （如 ?key=value ）中提交的参数可以使用 args 属性: searchword = request.args.get('key', '')
values	CombinedMultiDict，内容是form和args。 可以使用values替代form和args。
cookies	请求的cookies，类型是dict。
stream	在可知的mimetype下，如果进来的表单数据无法解码，会没有任何改动的保存到这个 stream 以供使用。很多时候，当请求的数据转换为string时，使用data是最好的方式。这个stream只返回数据一次。
headers	请求头，字典类型。
data	包含了请求的数据，并转换为字符串，除非是一个Flask无法处理的mimetype。
files	MultiDict，带有通过POST或PUT请求上传的文件。
environ	WSGI隐含的环境配置。
method	请求方法，比如POST、GET。
path	获取请求文件路径：/myapplication/page.html
full_path	获取请求文件路径,包括args数据：/myapplication/page.html?k=v
script_root
base_url	获取域名与请求文件路径：http://www.baidu.com/myapplication/page.html
url	获取全部url：http://www.baidu.com/myapplication/page.html?id=1&edit=edit
url_root	获取域名：http://www.baidu.com/
is_xhr	如果请求是一个来自JavaScript XMLHttpRequest的触发，则返回True，这个只工作在支持X-Requested-With头的库并且设置了XMLHttpRequest。
blueprint	蓝图名字。
endpoint	endpoint匹配请求，这个与view_args相结合，可是用于重构相同或修改URL。当匹配的时候发生异常，会返回None。
json	如果mimetype是application/json，这个参数将会解析JSON数据，如果不是则返回None。  可以使用这个替代get_json()方法。
max_content_length	只读，返回MAX_CONTENT_LENGTH的配置键。
module	如果请求是发送到一个实际的模块，则该参数返回当前模块的名称。这是弃用的功能，使用blueprints替代。
routing_exception = None	如果匹配URL失败，这个异常将会/已经抛出作为请求处理的一部分。这通常用于NotFound异常或类似的情况。
url_rule = None	内部规则匹配请求的URL。这可用于在URL之前/之后检查方法是否允许(request.url_rule.methods) 等等。  默认情况下，在处理请求函数中写下 print('request.url_rule.methods', request.url_rule.methods)  会打印：request.url_rule.methods {‘GET’, ‘OPTIONS’, ‘HEAD’}
view_args = None	一个匹配请求的view参数的字典，当匹配的时候发生异常，会返回None。
其他方法	get_json(force=False, silent=False, cache=True) on_json_loading_failed(e)

六、Session

除请求对象之外，还有一个 session 对象。它允许你在不同请求间存储特定用户的信息。它是在 Cookies 的基础上实现的，并且对 Cookies 进行密钥签名要使用会话，你需要设置一个密钥。app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'

• 设置：session['username'] ＝ 'xxx'
• 删除：session.pop('username', None)

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():
    # remove the username from the session if it's there
    session.pop('username', None)
    return redirect(url_for('index'))
 
# set the secret key.  keep this really secret:
app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'

默认session会存储在cookie中，如下

session源码解析

######################## sessions.py #############################
class SecureCookieSessionInterface(SessionInterface):
    def open_session(self, app, request):
        s = self.get_signing_serializer(app)
        if s is None:
            return None
        # 读取val这个val就是session的值,session_cookie_name这个就是配置文件的session_cookie_name
        val = request.cookies.get(app.session_cookie_name)
        if not val:                     # 如果是空的
            return self.session_class() # 则返回空字典
        max_age = total_seconds(app.permanent_session_lifetime)
        try:
            # 在内部加载，解密，反序列化
            data = s.loads(val, max_age=max_age)
            # 又实例化对象
            return self.session_class(data)
        except BadSignature:
            return self.session_class()

    def save_session(self, app, session, response):
        domain = self.get_cookie_domain(app)
        path = self.get_cookie_path(app)

        # If the session is modified to be empty, remove the cookie.
        # If the session is empty, return without setting the cookie.
        if not session:
            if session.modified:
                response.delete_cookie(
                    app.session_cookie_name,
                    domain=domain,
                    path=path
                )

            return

        # Add a "Vary: Cookie" header if the session was accessed at all.
        if session.accessed:
            response.vary.add('Cookie')

        if not self.should_set_cookie(app, session):
            return

        httponly = self.get_cookie_httponly(app)
        secure = self.get_cookie_secure(app)
        samesite = self.get_cookie_samesite(app)
        expires = self.get_expiration_time(app, session)
        # 对session进行加密，然后dumps编程字符串
        val = self.get_signing_serializer(app).dumps(dict(session))
        # 然后在写入用户的浏览器上
        response.set_cookie(
            app.session_cookie_name,
            val,
            expires=expires,
            httponly=httponly,
            domain=domain,
            path=path,
            secure=secure,
            samesite=samesite
        )

也可以通过重写open-session和save-session方法，让session存储在 内存 中或者 redis 中，

pip3 install Flask-Session
############################# run.py #########################################
from flask import Flask
from flask import session
from pro_flask.utils.session import MySessionInterface
app = Flask(__name__)

app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
app.session_interface = MySessionInterface()
@app.route('/login.html', methods=['GET', "POST"])
def login():
    print(session)
    session['user1'] = 'alex'
    session['user2'] = 'alex'
    del session['user2']

    return "内容"

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

############################ session.py ######################
#!/usr/bin/env python
# -*- coding:utf-8 -*-
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)   # 在cookie中通过配置的name获取session
        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)

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

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

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

        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)

也可以使用第三方session，让session存储在redis 中

#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
pip3 install redis
pip3 install flask-session
"""


from flask import Flask, session, redirect
from flask.ext.session import Session


app = Flask(__name__)
app.debug = True
app.secret_key = 'asdfasdfasd'


app.config['SESSION_TYPE'] = 'redis'
from redis import Redis
app.config['SESSION_REDIS'] = Redis(host='192.168.0.94',port='6379')
Session(app)


@app.route('/login')
def login():
    session['username'] = 'alex'
    return redirect('/index')


@app.route('/index')
def index():
    name = session['username']
    return name


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

七、蓝图

蓝图用于为应用提供目录划分：

小型应用程序：示例

大型应用程序：示例

其他：

• 蓝图URL前缀：xxx = Blueprint('account', __name__,url_prefix='/xxx')
• 蓝图子域名：xxx = Blueprint('account', __name__,subdomain='admin')
  # 前提需要给配置SERVER_NAME： app.config['SERVER_NAME'] = 'flepeng.com:5000'
  # 访问时：admin.flepeng.com:5000/login.html

######################### count.py #################
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Blueprint
from flask import render_template
from flask import request

account = Blueprint('account', __name__)


@account.route('/login.html', methods=['GET', "POST"])
def login():
return render_template('login.html')
######################### run.py #################
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Flask

app = Flask(__name__,template_folder='templates',static_folder='statics',static_url_path='/static')

from .views.account import account
from .views.blog import blog
from .views.user import user

app.register_blueprint(account)   # 注册
app.register_blueprint(blog)
app.register_blueprint(user)

if __name__ == '__main__':
    app.run

八、message（了解）

message是一个基于Session实现的用于保存数据的集合，其特点是：使用一次就删除。又称闪现

from flask import Flask, flash, redirect, render_template, request, get_flashed_messages

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


@app.route('/')
def index1():
    messages = get_flashed_messages()
    print(messages)
    return "Index1"


@app.route('/set')
def index2():
    v = request.args.get('p')
    flash(v)
    return 'ok'


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

九、中间件（了解）

from flask import Flask, flash, redirect, render_template, request
 
app = Flask(__name__)
app.secret_key = 'some_secret'
 
@app.route('/')
def index1():
    return render_template('index.html')
 
@app.route('/set')
def index2():
    v = request.args.get('p')
    flash(v)
    return 'ok'
 
class MiddleWare:
    def __init__(self,wsgi_app):
        self.wsgi_app = wsgi_app
 
    def __call__(self, *args, **kwargs):
        return self.wsgi_app(*args, **kwargs)
 
if __name__ == "__main__":
    app.wsgi_app = MiddleWare(app.wsgi_app)
    app.run(port=9999)

十、请求扩展

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Flask, Request, render_template

app = Flask(__name__, template_folder='templates')
app.debug = True


@app.before_first_request     # 只有第一次请求时，会调用，按注册顺序依次执行
def before_first_request1():
    print('before_first_request1')


@app.before_first_request     # 只有第一次请求时，会调用
def before_first_request2():
    print('before_first_request2')


@app.before_request           # 请求之前的处理，按照注册的顺序依次执行，若果有return，则直接返回，返回时经过所有after_request
def before_request1():
    Request.nnn = 123
    print('before_request1')


@app.before_request
def before_request2():
    print('before_request2')


@app.after_request            # 请求完成之后的处理，按照注册的逆序依次执行
def after_request1(response):
    print('before_request1', response)
    return response


@app.after_request
def after_request2(response):
    print('before_request2', response)
    return response


@app.errorhandler(404)         # 当发生错误时执行，比如404错误
def page_not_found(error):
    return 'This page does not exist', 404


@app.context_processor         # 为所有的模板传递的函数，调用方式：{{ val_1 }} 仿佛是jinja2内置的变量一样
def template_var()
    return {'val_1':'10'}


@app.template_global()         # 为所有的模板传递的函数，调用方式：{{ my_fun(1,2) }} 
def my_fun(a1, a2):
    return a1 + a2


@app.template_filter()         # 为所有的模板传递的函数，调用方式{{ 1|db(2,3)}}
def db(a1, a2, a3):
    return a1 + a2 + a3


@app.route('/')
def hello_world():
    return render_template('hello.html')


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

十一、Flask插件

• WTForms
• SQLAchemy
• Flask-session
• 等...    

http://flask.pocoo.org/extensions/