<form class="form-signin" method="post">
        <h2 class="form-signin-heading">请登录</h2>

        <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">

        <label for="inputEmail" class="sr-only">邮箱：</label>
        <input type="email" id="inputEmail" class="form-control" name="email" placeholder="请输入邮箱地址" required autofocus>
        <label for="inputPassword" class="sr-only">密码：</label>
        <input type="password" id="inputPassword" class="form-control" name="password" placeholder="请输入密码" required>
        <div class="checkbox">
          <label>
            <input type="checkbox" name="remember" value="1"> 记住我
          </label>
        </div>
        <button class="btn btn-lg btn-primary btn-block" type="submit">立即登录</button>
</form>

def create_app():
    """
    主入口文件创建app，供其他蓝图使用
    :return: 返回一个app
    """
    app = Flask(__name__)
    # 防止csrf注入攻击
    CSRFProtect(app)
    # 注册蓝图模块
    app.register_blueprint(cms_bp, url_prefix="/cms")
    app.register_blueprint(common_bp, url_prefix="/common")
    app.register_blueprint(front_bp)

    # 导入配置文件
    app.config.from_object(config)
    # 数据库db初始化app
    db.init_app(app)
    # 后台登录login_manager初始化app
    cms_login_manager.init_app(app)
    return app


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

<meta name="csrf-token" content="{{ csrf_token() }}">

''use strict'';
var cpajax = {
    "get": function(args){
        args["method"] = "get";
        this.ajax(args);
    },
    "post": function(args){
        args["method"] = "post";
        this.ajax(args);
    },
    "ajax": function(args){
        this._ajaxSetup();
        $.ajax(args);
    },
    "_ajaxSetup": function(args){
        $.ajaxSetup({
            "beforeSend": function(xhr, settings){
                if(!/^(GET|HEAD|OPTIONS|TRACE)$/i.test(settings.type) && !this.crossDomain){
                    var csrftoken = $("meta[name=csrf-token]").attr("content");
                    xhr.setRequestHeader("X-CSRFToken", csrftoken);
                }
            }
        });
    }
};

$(function(){
    $("#submit").on("click", function(event){
        event.preventDefault();

        var oldpwdE = $("input[name=oldpwd]");
        var newpwdE = $("input[name=newpwd]");
        var newpwd2E = $("input[name=newpwd2]");

        var oldpwd = oldpwdE.val();
        var newpwd = newpwdE.val();
        var newpwd2 = newpwd2E.val();

        //1、要在模板中的meta标签中渲染一个csrf-token
        //2、在ajax请求的头部设置x-CSRFtoken
        console.log("aaaaaaa");
        cpajax.post({
            "url": "/cms/resetpwd",
            "data": {
                "oldpwd": oldpwd,
                "newpwd": newpwd,
                "newpwd2": newpwd2
            },
            "success": function(data){
                console.log(data)
            },
            "fail": function(error){
                console.log(error)
            }
        })
    })
});

一个最小的应用

一个最小的应用看起来像这样:

1 from flask import Flask
2 app = Flask(__name__)
3 
4 @app.route(''/'')
5 def hello_world():
6     return ''Hello World!''
7 
8 if __name__ == ''__main__'':
9     app.run()

把它保存成 hello.py (或者类似的文件)，然后用 Python 解释器运行它。确保你的应用不叫做 flask.py， 因为这会与 Flask 本身冲突。

$ python hello.py
 * Running on http://127.0.0.1:5000/

现在浏览 http://127.0.0.1:5000/，你会看到你的 Hello World 问候。

那么这段代码做了什么？

1. 首先我们导入了类 Flask 。这个类的实例化将会是我们的 WSGI 应用。第一个参数是应用模块的名称。 如果你使用的是单一的模块（就如本例），第一个参数应该使用 __name__。因为取决于如果它以单独应用启动或作为模块导入， 名称将会不同 （ ''__main__'' 对应于实际导入的名称）。获取更多的信息，请阅读 Flask 的文档。
2. 接着，我们创建一个该类的实例。我们传递给它模块或包的名称。这样 Flask 才会知道去哪里寻找模板、静态文件等等。
3. 我们使用装饰器 route() 告诉 Flask 哪个 URL 才能触发我们的函数。
4. 定义一个函数，该函数名也是用来给特定函数生成 URLs，并且返回我们想要显示在用户浏览器上的信息。
5. 最后我们用函数 run() 启动本地服务器来运行我们的应用。if __name__ ==''__main__'': 确保服务器只会在该脚本被 Python 解释器直接执行的时候才会运行，而不是作为模块导入的时候。

请按 control-C 来停止服务器。

app.run(host=''0.0.0.0'') 

调试模式

run() 方法是十分适用于启动一个本地开发服务器，但是你需要在修改代码后手动重启服务器。 这样做并不好，Flask 能做得更好。如果启用了调试支持，在代码修改的时候服务器能够自动加载， 并且如果发生错误，它会提供一个有用的调试器。

有两种方式开启调式模式。一种是在应用对象上设置标志位:

app.debug = True app.run() 

或者作为 run 的一个参数传入:

app.run(debug=True) 

两种方法效果是一样的。

运行中的调试器的截图:

是不是还有其它的调试器？请查看 使用调试器。

路由

现代 Web 应用程序有优雅的 URLs。这能够帮助人们记住 URLs，这点在面向使用慢网络连接的移动设备的应用上有用。 如果用户不必通过点击首页而直接访问想要的页面，很可能他们会喜欢这个页面而且下次再次访问。

正如上面所说， route() 装饰器是用于把一个函数绑定到一个 URL 上。这有些基本的例子:

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

但是不仅如此！你可以动态地构造 URL 的特定部分，也可以在一个函数上附加多个规则。

@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 

@app.route(''/projects/'')
def projects(): return ''The project page'' @app.route(''/about'') def about(): return ''The about page'' 

>>> from flask import Flask, url_for >>> app = Flask(__name__) >>> @app.route(''/'') ... def index(): pass ... >>> @app.route(''/login'') ... def login(): pass ... >>> @app.route(''/user/<username>'') ... def profile(username): pass ... >>> 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 

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

静态文件

动态的 web 应用同样需要静态文件。CSS 和 JavaScript 文件通常来源于此。理想情况下， 你的 web 服务器已经配置好为它们服务，然而在开发过程中 Flask 能够做到。 只要在你的包中或模块旁边创建一个名为 static 的文件夹，在应用中使用 /static 即可访问。

给静态文件生成 URL ，使用特殊的 ''static'' 端点名:

url_for(''static'', filename=''style.css'') 

这个文件应该存储在文件系统上称为 static/style.css。

渲染模板

在 Python 中生成 HTML 并不好玩，实际上是相当繁琐的，因为你必须自行做好 HTML 转义以保持应用程序的安全。 由于这个原因，Flask 自动为你配置好 Jinja2 模版。

你可以使用方法 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) 

Flask 将会在 templates 文件夹中寻找模版。因此如果你的应用是个模块，这个文件夹在模块的旁边，如果它是一个包，那么这个文件夹在你的包里面:

Case 1: 一个模块:

/application.py
/templates
    /hello.html

Case 2: 一个包:

/application
    /__init__.py
    /templates
        /hello.html

对于模板，你可以使用 Jinja2 模板的全部功能。详细信息查看官方的 Jinja2 Template Documentation 。

这里是一个模版的例子：

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

在模版中你也可以使用 request, session 和 g [1] 对象，也能使用函数 get_flashed_messages() 。

模版继承是十分有用的。如果想要知道模版继承如何工作的话，请阅读文档 模板继承 。基本的模版继承使得某些特定元素（如标题，导航和页脚）在每一页成为可能。

自动转义是开启的，因此如果 name 包含 HTML，它将会自动转义。如果你信任一个变量，并且你知道它是安全的 （例如一个模块把 wiki 标记转换到 HTML ），你可以用 Markup 类或 |safe 过滤器在模板中标记它是安全的。 在 Jinja 2 文档中，你会见到更多例子。

这是一个 Markup 类如何工作的基本介绍：

>>> from flask import Markup >>> Markup(''<strong>Hello %s!</strong>'') % ''<blink>hacker</blink>'' Markup(u''<strong>Hello &lt;blink&gt;hacker&lt;/blink&gt;!</strong>'') >>> Markup.escape(''<blink>hacker</blink>'') Markup(u''&lt;blink&gt;hacker&lt;/blink&gt;'') >>> Markup(''<em>Marked up</em> &raquo; HTML'').striptags() u''Marked up \xbb HTML'' 

接收请求数据

对于 web 应用来说，对客户端发送给服务器的数据做出反应至关重要。在 Flask 中由全局对象 request 来提供这些信息。如果你有一定的 Python 经验，你会好奇这个对象怎么可能是全局的，并且 Flask 是怎么还能保证线程安全。 答案是上下文作用域:

from flask import request

with app.test_request_context(''/hello'', method=''POST''): # now you can do something with the request until the # end of the with block, such as basic assertions: assert request.path == ''/hello'' assert request.method == ''POST'' 

from flask import request

with app.request_context(environ): assert request.method == ''POST'' 

from flask import request

@app.route(''/login'', methods=[''POST'', ''GET'']) def login(): error = None if request.method == ''POST'': if valid_login(request.form[''username''], request.form[''password'']): return log_the_user_in(request.form[''username'']) else: error = ''Invalid username/password'' # the code below this is executed if the request method # was GET or the credentials were invalid return render_template(''login.html'', error=error) 

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

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

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

这是一个相当无意义的例子因为用户会从主页重定向到一个不能访问的页面（ 401意味着禁止访问）， 但是它说明了重定向如何工作。

默认情况下，每个错误代码会显示一个黑白错误页面。如果你想定制错误页面，可以使用 errorhandler() 装饰器:

from flask import render_template

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

注意到 404 是在 render_template() 调用之后。告诉 Flask 该页的错误代码应是 404 ， 即没有找到。默认的 200 被假定为：一切正常。

关于响应

一个视图函数的返回值会被自动转换为一个响应对象。如果返回值是一个字符串，它被转换成一个响应主体是该字符串，错误代码为 200 OK ，媒体类型为 text/html 的响应对象。 Flask 把返回值转换成响应对象的逻辑如下：

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

如果你想要获取在视图中得到的响应对象，你可以用函数 make_response() 。

想象你有这样一个视图:

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

你只需要用 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 

会话

除了请求对象，还有第二个称为 session 对象允许你在不同请求间存储特定用户的信息。 这是在 cookies 的基础上实现的，并且在 cookies 中使用加密的签名。这意味着用户可以查看 cookie 的内容， 但是不能修改它，除非它知道签名的密钥。

要使用会话，你需要设置一个密钥。这里介绍会话如何工作:

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

这里提到的 escape() 可以在你不使用模板引擎的时候做转义（如同本例）。

>>> import os
>>> os.urandom(24) ''\xfd{H\xe5<\x95\xf9\xe3\x96.5\xd1\x01O<!\xd5\xa2\xa0\x9fR"\xa1\xa8'' 

使用基于 cookie 的会话需注意: Flask 会将你放进会话对象的值序列化到 cookie。如果你试图寻找一个跨请求不能存留的值， cookies 确实是启用的，并且你不会获得明确的错误信息，检查你页面请求中 cookie 的大小，并与 web 浏览器所支持的大小对比。

消息闪烁

好的应用和用户界面全部是关于反馈。如果用户得不到足够的反馈，他们可能会变得讨厌这个应用。Flask 提供了一个 真正的简单的方式来通过消息闪现系统给用户反馈。消息闪现系统基本上使得在请求结束时记录信息并在下一个 （且仅在下一个）请求中访问。通常结合模板布局来显示消息。

使用 flash() 方法来闪现一个消息，使用 get_flashed_messages() 能够获取消息，get_flashed_messages() 也能用于模版中。针对一个完整的例子请查阅 消息闪现。

日志

有时候你会处于一种你处理的数据应该是正确的，然而实际上并不正确的状况。比如你可能有一些客户端代码， 代码向服务器发送一个 HTTP 请求但是显然它是畸形的。这可能是由于用户篡改数据，或客户端代码失败。 大部分时候针对这一情况返回 400 BadRequest 就可以了，但是有时候不行因为代码必须继续工作。

你可能仍然想要记录发生什么不正常事情。这时候日志就派上用处。从 Flask 0.3 开始日志记录是预先配置好的。

这里有一些日志调用的例子:

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

附带的 logger 是一个标准的日志类 Logger ，因此更多的信息请 查阅官方文档 logging documentation。

整合 WSGI 中间件

如果你想给你的应用添加 WSGI 中间件，你可以封装内部 WSGI 应用。例如如果你想使用 Werkzeug 包中的某个中间件来应付 lighttpd 中的 bugs，你可以这样做:

from werkzeug.contrib.fixers import LighttpdCGIRootFix
app.wsgi_app = LighttpdCGIRootFix(app.wsgi_app) 

部署到 Web 服务器

准备好部署你的新 Flask 应用？你可以立即部署到托管平台来完成快速入门，以下是向小项目提供免费的方案:

• Deploying Flask on Heroku
• Deploying WSGI on dotCloud with Flask-specific notes

你可以托管 Flask 应用的其它选择：

• Deploying Flask on Webfaction
• Deploying Flask on Google App Engine
• Sharing your Localhost Server with Localtunnel

如果你管理你自己的主机并且想要自己运行，请参看 部署方式。