我的代码
flask

基于python打造的轻量级web框架，只给开发者提供最核心的模块
微服务
架构体系
拥有丰富的第三方插件
插件 flask-sqlalchemy /flask-migrate/ flask-mail  /flask-caching/ flask-wtf (快速生成前端页面)/flask-admin/ 等

应用
启动服务|配置文件|静态&模板文件
route|url_for()|blueprint
request传参|restful|args|form|json|file
response响应|text|json|img|*|make_response|response对象|Content-Type|img标签
身份验证|form|json|TTPBasicAuth|HTTPDigestAuth
HTTPTokenAuth|pyjwt应用|pyjwt API|Itsdangerous应用|flask_jwt_extended|JWT|JWS
Oauth|Authlib OAuth2.0
状态保持|cookie|cookie API|session|session API|flask-session|HTTPTokenAuth
API
Flask 类
flask request类
flask response对象
flask.Blueprint类
flask route
flask url_for()
flask send_file&send_from_directory
flask.make_response
flask.Config
flask-sqlalchemy 数据基本操作
 flask-sqlalchemy 数据基本操作–实例
Flask 上下文
Flask Middle
Flask Flash
Flask 信号
Flask 应用上下文
Flask flask-session
Flask cookie
Flask session
Flask cookie API(response.set_cookie,request.cookies)
Flask session API
Flask redirect
Flask render_template
Flask SSO
项目实例
Flask 登录样例
flask 初始化
Flask 扩展 Flask-Script
Flask Jinja2模板
flask-bootstrap插件
flask 重定向（redirect）和会话（session）
flask 自定义错误页面
flask-sqlAlchemy 创建表
flask-alchemy-pagination 分页函数
flask 表单
flask Flash消息
flask WTForms
flask-Blueprint
源码
flask v0.1 项目工程
flask v0.1 内部运行程序
flask v0.1 路由
flask v0.1 flask.py
flask v0.1 执行流程 Flask(_name_)
flask 0.1 flaskr.py
flask v0.1 minitwit
flask 0.2
其他
python uuid
参考文献：

http://flask.pocoo.org/docs/0.12/

Flask框架
一、初识Flask
二、Flask路由注册
三、Flask的HTTP请求
四、Flask视图函数
五、Flask模板
六、Flask应用数据库
七、Flask脚本
八、Flask cookie、session、闪现
九、Flask请求扩展、中间件、蓝图
十、Flask之线程协程分析
十一、Flask上下文之偏函数补充
十二、Flask请求上下文
十三、Flask数据库连接池
十四、Flask大总结
十五、SQLAlchemy使用补充

    


全栈工程师开发手册 （作者：栾鹏）

 架构系列文章

在python web框架的世界里充满了选择。有Django，Flask，Pyramid，Tornado，Bottle，Diesel，Pecan，Falcon等等的来吸引开发者的注意。作为一个开发者，你想要从中选择一个框架来帮你完成项目，并且能继续做大事情。

关于读者该选择哪个框架，这里不做选择，本文带大家入门flask框架。
安装Flask
pip install flask

完整的flask开发环境可能需要内容组件比较多,  这里可以先安装下面的组件

将所有相关的包放置在一个txt文件，如：requires.txt,内容如下：
alembic
amqp
billiard
celery
certifi
chardet
Flask
Flask-Migrate
Flask-Script
Flask-Session
Flask-SQLAlchemy
Flask-WTF
Jinja2
kombu
Mako

然后直接安装pip install -r requires.txt
hello world
打开一个Python文件，输入下面的内容并运行该文件。然后访问localhost:5000，我们应当可以看到浏览器上输出了Hello Flask!。
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
    return 'Hello Flask!'

if __name__ == '__main__':
    app.run(debug=True,port=80,host='0.0.0.0')     # 设置debug=True是为了让代码修改实时生效，而不用每次重启加载

app初始化简介
# Flask实例的源码：
class Flask(_PackageBoundObject):
    def __init__(self, import_name,  # 指定应用的名字和工程目录，默认为__name__
                static_path=None,  #  是静态文件存放的路径，会赋值给static_url_path参数
                static_url_path=None,  # 设置静态文件路由的前缀，默认为“/static”
                static_folder='static', # 静态文件的存放目录， 默认值为"static"
                template_folder='templates', # 模板文件的存放目录，默认值为"templates"
                instance_path=None, # 设置配置文件的路径，在instance_relative_config=True情况下生效
                instance_relative_config=False # 设置为True表示配置文件相对于实例路径而不是根路径
                root_path=None) # #  应用程序的根路径

运行测试app程序
app.run(host=None, # 设置ip，默认127.0.0.1
        port=None, # 设置端口，默认5000
        debug=None)  # 设置是否开启调试，默认false

app的配置参数详解
flask实例化后会加载默认的配置参数，我们也可以手动设置参数更新默认的配置，常用的参数选项有：
DEBUG:是否启用debug模式，默认false。
TESTING :启用/禁止测试模式
SECRET_KEY :密钥,在启用session等很重要
SESSION_COOKIE_NAME :设置保存的session在 cookie 的名称
SESSION_COOKIE_DOMAIN：设置会话的域，默认是当前的服务器，因为Session是一个全局的变量，可能应用在多个app中；设置这个参数必须设置SERVER_NAME,否则报错
PERMANENT_SESSION_LIFETIME：session失效时间，作为一个 datetime.timedelta 对象，也可以用秒表示；
LOGGER_NAME:日志记录器的名称，默认__name__;
SERVER_NAME:服务器的名称以及端口，需要它为了支持子域名 (如: 'myapp.dev:5000')
MAX_CONTENT_LENGTH:设置一个请求所允许的最大的上传数据量，单位字节；
SEND_FILE_MAX_AGE_DEFAULT:  设置调用send_file发送文件的缓存时间；
TRAP_HTTP_EXCEPTIONS:如果这个值被设置为 True ， Flask 不会执行 HTTP 异常的错误处理， 而是像对待其它异常一样，通过异常栈让它冒泡;
PREFERRED_URL_SCHEME:设置URL 模式用于 URL 生成。如果没有设置 URL 模式，默认将为 http 。
JSON_AS_ASCII：默认情况下 Flask 序列化对象成 ascii 编码的 JSON。 如果不对该配置项就行设置的话，Flask 将不会编码成 ASCII 保持字符串原样，并且返回 unicode 字符串。jsonfiy 会自动按照 utf-8 进行编码并且传输。
JSON_SORT_KEYS：默认情况下 Flask 将会依键值顺序的方式序列化 JSON。 这样做是为了确保字典哈希种子的独立性，返回值将会一致不会造成 额外的 HTTP 缓存。通过改变这个变量可以重载默认行为。 这是不推荐也许会带来缓存消耗的性能问题。
JSONIFY_PRETTYPRINT_REGULAR：如果设置成 True (默认下)，jsonify 响应对象将会完美地打印。

通过加载文件设置参数
app.config.from_pyfile("./config.cfg") # 指定参数的路径，内容按行书写,配置文件放置在与app的同目录下

def from_pyfile(self, filename, silent=False):
    filename = os.path.join(self.root_path, filename)
    pass

通过类设置参数

注意所有的参数必须大写，否则无效。
class Config(object):  # 该类可以定义在一个py文件中然后导入py文件
    """配置参数"""
    DEBUG = True
app.config.from_object(Config)

通过json格式的文件配置
# config.json
{
    'DEBUG' = True
}
app.config.from_json('config.json') # 配置文件放置在与app的同目录下

直接操作app.config对象进行设置
app.config["DEBUG"] = True
或者
app.config.update({
    "DEBUG":True,
})

获取配置参数的方法
app.config.get("DEBUG")
或者
current_app.config.get("DEBUG")

路由
路由通过使用Flask的app.route装饰器来设置，这类似Java的Spring Web MVC
@app.route('/',methods=["POST","GET"])
def index():
    return 'Index Page'

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

route装饰器会将其装饰的视图函数注册到app的视图函数集中，其主要有三个参数：

路径变量
路由路径也就是请求网址中不是固定的网址，而是含有变量的网址。（注意，这里指的并不是网址？后面的get方式发送是参数，而是向www.example.com/1/test/中的1这个参数，也可能是其他的数值。）路径变量的语法是/path/<converter:varname>。在路径变量前还可以使用可选的转换器，有以下几种转换器。




转换器
作用




string
默认选项，接受除了斜杠之外的字符串


int
接受整数


float
接受浮点数


path
和string类似，不过可以接受带斜杠的字符串


any
匹配任何一种转换器


uuid
接受UUID字符串


下面是Flask官方的例子。
@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
在Web程序中常常需要获取某个试图函数对应的URL，在Flask中需要使用url_for(‘方法名’)来构造对应方法的URL
@app.route('/loginto')
def login():
    print(url_for('login'))   # 会打印出网址中主机名后的部分
    return 'Hello world!'

HTTP参数获取
使用route装饰器的methods参数可以设置接收get或者post方法
@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        print(request.form['userid'])  # 获取post穿过来的参数
        dict = request.form.to_dict()  # 将请求参数解析成字典
        print(dict['userid'])
        return 'POST'
    else:
        print(request.args['userid'])   # 获取get传过来的参数
        dict = request.args.to_dict()  # 将请求参数解析成字典
        print(dict['userid'])
        return 'GET'


获取上传文件
利用Flask也可以方便的获取表单中上传的文件，只需要利用 request 的files属性即可，这也是一个字典，包含了被上传的文件。如果想获取上传的文件名，可以使用filename属性，不过需要注意这个属性可以被客户端更改，所以并不可靠。更好的办法是利用werkzeug提供的secure_filename方法来获取安全的文件名。
from flask import request
from werkzeug.utils 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))

返回内容
返回字符串、元组等可以直接返回。
返回字典使用
from flask import jsonify
@app.route('/test', methods=['GET', 'POST'])
def test():
	dict={'a':'a','b':'aaa'}
	return jsonify(dict)

返回模板
from flask import render_template
@app.route('/test', methods=['GET', 'POST'])
def test():
	return render_template('index.html',name='aaa')  # 可以向模板传递参数

静态文件
Web程序中常常需要处理静态文件，在Flask中需要使用url_for函数并指定static端点名和文件名。在上面的例子中url_for可以获取函数名对应的网址。下面的例子，url_for是写在html模板中的，实际的文件应是static/logo.png文件。
h1 { margin: 0 0 30px 0; background: url({{ url_for('static', filename='logo.png') }}) }

模板生成
Flask默认使用Jinja2作为模板，Flask会自动配置Jinja 模板，所以我们不需要其他配置了。默认情况下，模板文件需要放在templates文件夹下。
使用 Jinja 模板，只需要使用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 %}

日志输出
Flask 为我们预配置了一个 Logger，我们可以直接在程序中使用。这个Logger是一个标准的Python Logger，所以我们可以向标准Logger那样配置它。
app.logger.debug('A value for debugging')
app.logger.warning('A warning occurred (%d apples)', 42)
app.logger.error('An error occurred')

Cookies
Flask也可以方便的处理Cookie。使用方法很简单，直接看官方的例子就行了。下面的例子是如何获取cookie。
from flask import request

@app.route('/')
def index():
    username = request.cookies.get('username')
    # 使用 cookies.get(key) 代替 cookies[key] 避免
    # 得到 KeyError 如果cookie不存在

如果需要发送cookie给客户端，参考下面的例子。
from flask import make_response

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

重定向和错误
redirect和abort函数用于重定向和返回错误页面。
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()

默认的错误页面是一个空页面，如果需要自定义错误页面，可以使用errorhandler装饰器。
from flask import render_template

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

自定义响应http头
默认情况下，Flask会根据函数的返回值自动决定如何处理响应：如果返回值是响应对象，则直接传递给客户端；如果返回值是字符串，那么就会将字符串转换为合适的响应对象。我们也可以自己决定如何设置响应对象，方法也很简单，使用make_response函数即可。
@app.errorhandler(404)
def not_found(error):
    resp = make_response(render_template('error.html'), 404)
    resp.headers['X-Something'] = 'A value'
    return resp

Sessions
我们可以使用全局对象session来管理用户会话。Sesison 是建立在 Cookie 技术上的，不过在 Flask 中，我们还可以为 Session 指定密钥，这样存储在 Cookie 中的信息就会被加密，从而更加安全。直接看 Flask 官方的例子吧。
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 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'

模板简介
这里简单的介绍一下Jinja 模板的使用方法
模板标签
其实Jinja 模板和其他语言和框架的模板类似，反正都是通过某种语法将HTML文件中的特定元素替换为实际的值。如果使用过JSP、Thymeleaf 等模板，应该可以非常容易的学会使用 Jinja模板。
其实从上面的例子中我们应该可以看到Jinja 模板的基本语法了。代码块需要包含在{% %}块中，例如下面的代码。
{% extends 'layout.html' %}
{% block title %}主页{% endblock %}
{% block body %}

    <div class="jumbotron">
        <h1>主页</h1>
    </div>

{% endblock %}

双大括号中的内容不会被转义，所有内容都会原样输出，它常常和其他辅助函数一起使用。下面是一个例子。
<a class="navbar-brand" href={{ url_for('index') }}>Flask小例子</a>

继承
模板可以继承其他模板，我们可以将布局设置为父模板，让其他模板继承，这样可以非常方便的控制整个程序的外观。
例如这里有一个layout.html模板，它是整个程序的布局文件。
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>{% block title %}{% endblock %}</title>
    <link rel="stylesheet" href="{{ url_for('static',filename='css/bootstrap.css') }}"/>
    <link rel="stylesheet" href="{{ url_for('static',filename='css/bootstrap-theme.css') }}"/>

</head>
<body>

<div class="container body-content">
    {% block body %}{% endblock %}
</div>

<div class="container footer">
    <hr>
    <p>这是页脚</p>
</div>

<script src="{{ url_for('static',filename='js/jquery.js') }}"></script>
<script src="{{ url_for('static',filename='js/bootstrap.js') }}"></script>

</body>
</html>

其他模板可以这么写。对比一下面向对象编程的继承概念，我们可以很容易的理解。
{% extends 'layout.html' %}
{% block title %}主页{% endblock %}
{% block body %}

    <div class="jumbotron">
        <h1>主页</h1>
        <p>本项目演示了Flask的简单使用方法，点击导航栏上的菜单条查看具体功能。</p>
    </div>

{% endblock %}

控制流
条件判断可以这么写，类似于JSP标签中的Java 代码，{% %}中也可以写Python代码。下面是Flask官方文档的例子。
 <div class=metanav>
  {% if not session.logged_in %}
    <a href="{{ url_for('login') }}">log in</a>
  {% else %}
    <a href="{{ url_for('logout') }}">log out</a>
  {% endif %}
  </div>

循环的话可以这么写，和在Python中遍历差不多。
 <tbody>
  {% for key,value in data.items() %}
      <tr>
          <td>{{ key }}</td>
          <td>{{ value }}</td>
      </tr>
  {% endfor %}
  <tr>
      <td>文件</td>
      <td></td>
  </tr>
  </tbody>

需要注意不是所有的Python代码都可以写在模板里，如果希望从模板中引用其他文件的函数，需要显式将函数注册到模板中
写在最后
顺便说，通过Flask 我也了解了Python 语言的执行速度。我们都知道编译器编译出来的代码执行起来要比解释器解释代码要快大约几十倍到几千倍不等。以前学Java的时候，感觉Java 慢，主要原因就是等待编译时间比较长。相对来说用Python写脚本就很块了，因为没有编译过程。
但是从Flask的运行速度来看，我切身感受到了Python 执行确实不快。举个例子，在Spring中写一个控制器，接受HTTP参数，并显示到页面上，如果程序编译完之后，这个显示过程基本是瞬时的。但是同样的需求在Flask中，我居然可以感觉到明显的延迟（大概几百毫秒的等待时间）。所以，如果你想写一个比较快的Web程序，还是用Java或者JVM语言吧，虽然看着土，性能确实杠杠的 。