Flask框架应用

简介

Flask 是一个使用 Python 编写的轻量级 Web 应用程序框架。Armin Ronacher带领一个名为Pocco的国际Python爱好者团队开发了Flask。

Flask环境

Flask安装条件

安装Flask通常需要Python 2.6或更高版本。虽然Flask及其依赖项适用于Python 3（Python 3.3以上版本），但是许多Flask扩展不能正确支持它。因此，建议在Python 2.7上安装Flask。

pip install Flask

Flask应用

测试Hello World

Hello.py

#!/usr/config/env python
# -*- coding:utf-8 -*-


from flask import Flask
app = Flask(__name__)

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

if __name__ == '__main__':
    # app.run(host, port, debug, options)
    # app.run()
    app.run(host='0.0.0.0',port='4000',debug=True)

必须在项目中导入Flask模块。 Flask类的一个对象是我们的WSGI应用程序。

Flask构造函数使用当前模块（__name __）的名称作为参数。

Flask类的route()函数是一个装饰器，它告诉应用程序哪个URL应该调用相关的函数。

app.route(rule, options)

rule 参数表示与该函数的URL绑定。
options 是要转发给基础Rule对象的参数列表。

在上面的示例中，'/ ' URL与hello_world()函数绑定。因此，当在浏览器中打开web服务器的主页时，将呈现该函数的输出。

最后，Flask类的run()方法在本地开发服务器上运行应用程序。

app.run(host, port, debug, options)

所有参数都是可选的

序号	参数与描述
1	host 要监听的主机名。默认为127.0.0.1（localhost）。设置为“0.0.0.0”以使服务器在外部可用
2	port 默认值为5000
3	debug 默认为false。如果设置为true，则提供调试信息
4	options 要转发到底层的Werkzeug服务器。

上面给出的Python脚本是从Python shell执行的。

Python Hello.py

在浏览器中打开上述URL（localhost:5000）。将显示“Hello World”消息。

调试模式

通过调用run()方法启动Flask应用程序。但是，当应用程序正在开发中时，应该为代码中的每个更改手动重新启动它。为避免这种不便，请启用调试支持。如果代码更改，服务器将自行重新加载。它还将提供一个有用的调试器来跟踪应用程序中的错误（如果有的话）。

在运行或将调试参数传递给run()方法之前，通过将application对象的debug属性设置为True来启用Debug模式。

app.debug = True
app.run()
app.run(debug = True)

Flask路由

现代Web框架使用路由技术来帮助用户记住应用程序URL。可以直接访问所需的页面，而无需从主页导航。

Flask中的route()装饰器用于将URL绑定到函数。例如：

#!/usr/config/env python
# -*- coding:utf-8 -*-


from flask import Flask
app = Flask(__name__)

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

if __name__ == '__main__':
    app.run(host='0.0.0.0',port='4000',debug=True)

在这里，URL '/ hello' 规则绑定到hello_world()函数。因此，如果用户访问http：// localhost：5000 / hello URL，hello_world()函数的输出将在浏览器中呈现。

application对象的add_url_rule()函数也可用于将URL与函数绑定，如上例所示，使用route()。

Flask变量规则

通过向规则参数添加变量部分，可以动态构建URL。此变量部分标记为。它作为关键字参数传递给与规则相关联的函数。

在以下示例中，route()装饰器的规则参数包含附加到URL '/hello'的。因此，如果在浏览器中输入http://localhost:5000/hello/w3cschool作为URL，则'w3cschool'将作为参数提供给hello()函数。

#!/usr/config/env python
# -*- coding:utf-8 -*-


from flask import Flask
app = Flask(__name__)

@app.route('/hello/<name>')
def hello_world(name):
    return 'Hello %s' %name

if __name__ == '__main__':
    app.run(host='0.0.0.0',port='4000',debug=True)

除了默认字符串变量部分之外，还可以使用以下转换器构建规则：

序号	转换器和描述
1	int 接受整数
2	float 对于浮点值
3	path 接受用作目录分隔符的斜杠

在下面的代码中，使用了所有这些构造函数：

从Python Shell运行上面的代码。访问浏览器中的URL http://localhost:5000/blog/11。

给定的数字用作show_blog()函数的参数。浏览器显示以下输出：

#!/usr/config/env python
# -*- coding:utf-8 -*-


from flask import Flask
app = Flask(__name__)

@app.route('/hello/<name>')
def hello_world(name):
    return 'Hello %s' %name

@app.route('/blog/<int:postID>')
def show_blog(postID):
   return 'Blog Number %d' % postID

@app.route('/rev/<float:revNo>')
def revision(revNo):
   return 'Revision Number %f' % revNo

if __name__ == '__main__':
    app.run(host='0.0.0.0',port='4000',debug=True)

Flask的URL规则基于Werkzeug的路由模块。这确保形成的URL是唯一的，并且基于Apache规定的先例。

考虑以下脚本中定义的规则：

#!/usr/config/env python
# -*- coding:utf-8 -*-


from flask import Flask
app = Flask(__name__)

@app.route('/flask')
def hello_flask():
   return 'Hello Flask'

@app.route('/python/')
def hello_python():
   return 'Hello Python'

if __name__ == '__main__':
    app.run(host='0.0.0.0',port='4000',debug=True)

这两个规则看起来类似，但在第二个规则中，使用斜杠（/）。因此，它成为一个规范的URL。因此，使用 /python 或 /python/返回相同的输出。但是，如果是第一个规则，/flask/ URL会产生“404 Not Found”页面。

Flask URL构建

url_for()函数对于动态构建特定函数的URL非常有用。该函数接受函数的名称作为第一个参数，以及一个或多个关键字参数，每个参数对应于URL的变量部分。

以下脚本演示了如何使用url_for()函数：

#!/usr/config/env python
# -*- coding:utf-8 -*-


from flask import Flask,redirect,url_for
app = Flask(__name__)

@app.route('/admin')
def hello_admin():
    return 'Hello admin'

@app.route('/guest/<guest>')
def hello_guest(guest):
    return 'Hello %s as Guest' %guest

@app.route('/user/<name>')
def hello_user(name):
    if name == 'admin':
        return redirect(url_for('hello_admin'))
    else:
        return redirect(url_for('hello_guest',guest=name))

if __name__ == '__main__':
    app.run(host='0.0.0.0',port='4000',debug=True)

打开浏览器并输入URL - http://localhost:4000/user/niuniu

打开浏览器并输入URL - http://localhost:4000/user/admin

上述脚本有一个函数user(name)，它接受来自URL的参数的值。

User()函数检查接收的参数是否与'admin'匹配。如果匹配，则使用url_for()将应用程序重定向到hello_admin()函数，否则重定向到将接收的参数作为guest参数传递给它的hello_guest()函数。

保存上面的代码并从Python shell运行。

Flask HTTP方法

http方法

序号	方法与描述
1	GET 以未加密的形式将数据发送到服务器。最常见的方法。
2	HEAD 和GET方法相同，但没有响应体。
3	POST 用于将HTML表单数据发送到服务器。POST方法接收的数据不由服务器缓存。
4	PUT 用上传的内容替换目标资源的所有当前表示。
5	DELETE 删除由URL给出的目标资源的所有当前表示。

默认情况下，Flask路由响应GET请求。但是，可以通过为route()装饰器提供方法参数来更改此首选项。

为了演示在URL路由中使用POST方法，首先让我们创建一个HTML表单，并使用POST方法将表单数据发送到URL。

新建login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Login</title>
</head>
<body>
<form action="http://localhost:4000/login" method="post">
    <p>Enter Name:</p>
    <p>
        <input type="text" name="xzz">
    </p>
    <p>
        <input type="submit" value="submit">
    </p>
</form>

</body>
</html>

创建login.py

#!/usr/config/env python
# -*- coding:utf-8 -*-


from flask import Flask, redirect, url_for, request

app = Flask(__name__)


@app.route('/success/<name>')
def success(name):
    return 'welcome %s' % name


@app.route('/login', methods=['POST', 'GET'])
def login():
    if request.method == 'POST':
        user = request.form['xzz']
        return redirect(url_for('success', name=user))
    else:
        user = request.args.get('xzz')
        return redirect(url_for('success', name=user))


if __name__ == '__main__':
    app.run(host='127.0.0.1', port='4000', debug=True)

开发服务器开始运行后，在浏览器中打开login.html，在文本字段中输入name，然后单击提交。

换成get请求

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Login</title>
</head>
<body>
<form action="http://localhost:4000/login" method="get">
    <p>Enter Name:</p>
    <p>
        <input type="text" name="xzz">
    </p>
    <p>
        <input type="submit" value="submit">
    </p>
</form>

</body>
</html>

同样提交操作

Flask模板

视图函数的主要作用是生成请求的响应,这是最简单请求.实际上,视图函数有两个作用:

处理业务逻辑
返回响应内容

在大型应用中,把业务逻辑和表现内容放在一起,会增加代码的复杂度和维护成本.

模板其实是一个包含响应文本的文件,其中用占位符(变量)表示动态部分,告诉模板引擎其具体的值需要从使用的数据中获取
使用真实值替换变量,再返回最终得到的字符串,这个过程称为'渲染'
Flask 是使用 Jinja2 这个模板引擎来渲染模板

使用模板的好处

视图函数只负责业务逻辑和数据处理(业务逻辑方面)
而模板则取到视图函数的数据结果进行展示(视图展示方面)
代码结构清晰,耦合度低

模板基本使用

在项目下创建 templates 文件夹，用于存放所有模板文件，并在目录下创建一个模板文件 html 文件 hello.html

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <title>Title</title>
</head>

<body>
  <h2>我是模板</h2>
  {{ my_int }}
  <br>
  {{ my_str }}
  <br>
  {{ my_list }}
  <br>
  {{ my_dict }}
  <hr>
  <h2>模板的list数据获取</h2>
  <hr>
  {{ my_list[0] }}
  <br>
  {{ my_list.1 }}
  <hr>
  <h2>字典数据获取</h2>
  <hr>
  {{ my_dict['name'] }}
  <br>
  {{ my_dict.age }}
  <hr>
  <h2>算术运算</h2>
  <br>
  {{ my_list.0 + 10 }}
  <br>
  {{ my_list[0] + my_list.1 }}
</body>

</html>

创建视图函数,将该模板内容进行渲染返回

hello.py

#!/usr/config/env python
# -*- coding:utf-8 -*-


from flask import Flask,render_template

app = Flask(__name__)

# @app.route('/data')
# def index():
#     return render_template('hello.html')

@app.route('/data')
def index():
    my_int = 18
    my_str = 'lucy'
    my_list = [1,4,9,3,2]
    my_dict = {
        'name':'durrant',
        'age':26
    }
    # render_template方法:渲染模板
    # 参数1: 模板名称  参数n: 传到模板里的数据

    return render_template('hello.html',
                           my_int = my_int,
                           my_str = my_str,
                           my_list = my_list,
                           my_dict = my_dict
                           )

if __name__ == '__main__':
    app.run(host='127.0.0.1', port='4000', debug=True)

Flask静态文件

Web应用程序通常需要静态文件，例如javascript文件或支持网页显示的CSS文件。通常，配置Web服务器并为您提供这些服务，但在开发过程中，这些文件是从您的包或模块旁边的static文件夹中提供，它将在应用程序的/static中提供。

特殊端点'static'用于生成静态文件的URL。

在下面的示例中，在index.html中的HTML按钮的OnClick事件上调用hello.js中定义的javascript函数，该函数在Flask应用程序的“/”URL上呈现。

#!/usr/config/env python
# -*- coding:utf-8 -*-


from flask import Flask, render_template
app = Flask(__name__)

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

if __name__ == '__main__':
    app.run(host='127.0.0.1', port='4000', debug=True)

index.html的HTML脚本如下所示：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>

    <script type="text/javascript" src = "{{ url_for('static', filename = 'hello.js')}}"></script>
</head>
<body>
<input type="button" onclick="sayHello()" value="Say Hello" />
</body>
</html>
Hello.js包含sayHello()函数

function sayHello() {
   alert("Hello World")
}

Flask Request对象

来自客户端网页的数据作为全局请求对象发送到服务器。为了处理请求数据，应该从Flask模块导入。

Request对象的重要属性如下所列：

Form - 它是一个字典对象，包含表单参数及其值的键和值对。
args - 解析查询字符串的内容，它是问号（？）之后的URL的一部分。
Cookies - 保存Cookie名称和值的字典对象。
files - 与上传文件有关的数据。
method - 当前请求方法。

Flask 将表单数据发送到模板

我们已经看到，可以在 URL 规则中指定 http 方法。触发函数接收的 Form 数据可以以字典对象的形式收集它并将其转发到模板以在相应的网页上呈现它。

在以下示例中，'/' URL 会呈现具有表单的网页（student.html）。填入的数据会发布到触发 result() 函数的 '/result' URL。

result() 函数收集字典对象中的 request.form 中存在的表单数据，并将其发送给 result.html。

该模板动态呈现表单数据的 HTML 表格。

下面给出的是应用程序的 Python 代码：

#!/usr/config/env python
# -*- coding:utf-8 -*-


from flask import Flask, render_template,request
app = Flask(__name__)

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

@app.route('/result',methods=['POST','GET'])
def result():
    if request.method == 'POST':
        result = request.form
        return render_template('result.html',result=result)

if __name__ == '__main__':
    app.run(host='127.0.0.1', port='4000', debug=True)

下面给出的是 student.html 的 HTML 脚本。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="http://localhost:4000/result" method="POST">
     <p>Name <input type = "text" name = "Name" /></p>
     <p>Physics <input type = "text" name = "Physics" /></p>
     <p>Chemistry <input type = "text" name = "chemistry" /></p>
     <p>Maths <input type ="text" name = "Mathematics" /></p>
     <p><input type = "submit" value = "submit" /></p>
  </form>
</body>
</html>

下面给出了模板（ result.html ）的代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<table border = 1>
     {% for key, value in result.items() %}
    <tr>
       <th> {{ key }} </th>
       <td> {{ value }}</td>
    </tr>
 {% endfor %}
</table>
</body>
</html>

Flask Cookies

Cookie以文本文件的形式存储在客户端的计算机上。其目的是记住和跟踪与客户使用相关的数据，以获得更好的访问者体验和网站统计信息。

Request对象包含Cookie的属性。它是所有cookie变量及其对应值的字典对象，客户端已传输。除此之外，cookie还存储其网站的到期时间，路径和域名。

在Flask中，对cookie的处理步骤为：

设置cookie

设置cookie,默认有效期是临时cookie,浏览器关闭就失效
可以通过 max_age 设置有效期，单位是秒

resp = make_response("success")   # 设置响应体
resp.set_cookie("w3cshool", "w3cshool", max_age=3600)

获取cookie

获取cookie，通过request.cookies的方式，返回的是一个字典，可以获取字典里的相应的值

cookie_1 = request.cookies.get("w3cshool")

删除cookie

这里的删除只是让cookie过期，并不是直接删除cookie
删除cookie，通过delete_cookie()的方式，里面是cookie的名字

resp = make_response("del success")  # 设置响应体
resp.delete_cookie("w3cshool")

设置cookie举例

#!/usr/config/env python
# -*- coding:utf-8 -*-

from flask import Flask, make_response,request
app = Flask(__name__)

@app.route('/set_cookies')
def set_cookie():
    resp = make_response('success')
    resp.set_cookie('wyzxw','wyzxw',max_age=3600)
    return resp

@app.route('/get_cookies')
def get_cookie():
    cookie_1 = request.cookies.get('wyzxw')
    return cookie_1

@app.route('/delete_cookies')
def delete_cookie():
    resp = make_response('del success')
    resp.delete_cookie('wyzxw')
    return resp

if __name__ == '__main__':
    app.run(host='127.0.0.1', port='4000', debug=True)

设置cookies

运行应用程序，在浏览器中输入 127.0.0.1:5000/set_cookies 来设置cookies，设置 cookies 的输出如下所示

获取cookie

根据视图函数中相对应的路径，输入 http://127.0.0.1:5000/get_cookies ，读回 cookies 的输出如下所示：

删除cookie

根据视图函数中相对应的路径，输入 http://127.0.0.1:5000/delete_cookies ，删除 cookies 的输出如下所示：

Flask 会话

Flask Sessions（会话）

与Cookie不同，Session（会话）数据存储在服务器上。会话是客户端登录到服务器并注销服务器的时间间隔。需要在该会话中保存的数据会存储在服务器上的临时目录中。

为每个客户端的会话分配会话ID。会话数据存储在cookie的顶部，服务器以加密方式对其进行签名。对于此加密，Flask应用程序需要一个定义的SECRET_KEY。

Session对象也是一个字典对象，包含会话变量和关联值的键值对。

例如，要设置一个'username'会话变量，请使用以下语句：

Session['username'] = 'admin'

要释放会话变量，请使用pop()方法。

session.pop('username', None)

以下代码是Flask中的会话工作的简单演示。URL '/'只是提示用户登录，因为未设置会话变量'username'。
```python
@app.route('/')
def index():
   if 'username' in session:
      username = session['username']
         return 'Logged in as ' + username + '<br>' + \
         "<b><a href = '/logout'>click here to log out</a></b>"
   return "You are not logged in <br><a href = '/login'></b>" + \
      "click here to log in</b></a>"

当用户浏览到“/login”login()视图函数时，因为它是通过GET方法调用的，所以将打开一个登录表单。

表单发送回'/login'，现在会话变量已设置。应用程序重定向到'/'。此时会话变量'username'被找到。

@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>
      <p<<input type = submit value = Login/></p>
   </form>
	
   '''

应用程序还包含一个logout()视图函数，它会弹出'username'会话变量。因此，'/' URL再次显示开始页面。

@app.route('/logout')
def logout():
   # remove the username from the session if it is there
   session.pop('username', None)
   return redirect(url_for('index'))

运行应用程序并访问主页。（确保设置应用程序的secret_key）

from flask import Flask, session, redirect, url_for, escape, request
app = Flask(__name__)
app.secret_key = 'any random string'

完整代码

from flask import Flask

from flask import render_template

from flask import request

from flask import make_response

from flask import Flask, session, redirect, url_for, escape, request

app = Flask(__name__)

app.secret_key = 'fkdjsafjdkfdlkjfadskjfadskljdsfklj'

@app.route('/')

def index():

    if 'username' in session:

        username = session['username']

        return '登录用户名是:' + username + '<br>' + "<b><a href = '/logout'>点击这里注销</a></b>"

    return "您暂未登录， <br><a href = '/login'></b>" + "点击这里登录</b></a>"

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

      <p><input type ="submit" value ="登录"/></p>

   </form>

   '''

@app.route('/logout')

def logout():

   # remove the username from the session if it is there

   session.pop('username', None)

   return redirect(url_for('index'))

if __name__ == '__main__':

    app.run(host='127.0.0.1', port='4000', debug=True)

Flask 重定向和错误

Flask类有一个redirect()函数。调用时，它返回一个响应对象，并将用户重定向到具有指定状态代码的另一个目标位置。

redirect()函数的原型如下：

Flask.redirect(location, statuscode, response)

location参数是应该重定向响应的URL。
statuscode发送到浏览器标头，默认为302。
response参数用于实例化响应。

以下状态代码已标准化：

HTTP_300_MULTIPLE_CHOICES
HTTP_301_MOVED_PERMANENTLY
HTTP_302_FOUND
HTTP_303_SEE_OTHER
HTTP_304_NOT_MODIFIED
HTTP_305_USE_PROXY
HTTP_306_RESERVED
HTTP_307_TEMPORARY_REDIRECT

默认状态代码为302，表示'found'。

在以下示例中，redirect()函数用于在登录尝试失败时再次显示登录页面。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div>登录页面</div>
<form action = "/login" method = "post">
      <p><input type ="text" name ="username"/></p>
      <p><input type ="submit" value ="登录"/></p>
</form>

</body>
</html>

redirect.py

#!/usr/config/env python
# -*- coding:utf-8 -*-


from flask import Flask, render_template,redirect,url_for,request
app = Flask(__name__)


@app.route('/')
def index():
    return render_template('login.html')

@app.route('/login',methods=['GET','POST'])
def login():
    if request.method == 'POST' and request.form['username'] == 'admin':
        return redirect(url_for('success'))
    return redirect(url_for('index'))

@app.route('/success')
def success():
    return 'logged in successfully'

if __name__ == '__main__':
    app.run(host='127.0.0.1', port='4002', debug=True)

Flask类具有带有错误代码的abort()函数。

Flask.abort(code)

Code参数采用以下值之一：

400 - 用于错误请求
401 - 用于未身份验证的
403 - Forbidden
404 - 未找到
406 - 表示不接受
415 - 用于不支持的媒体类型
429 - 请求过多

让我们对上述代码中的login()函数稍作更改。如果要显示'Unauthurized'页面，请将其替换为调用abort(401)，而不是重新显示登录页面。

#!/usr/config/env python
# -*- coding:utf-8 -*-


from flask import Flask, render_template,redirect,url_for,request,abort
app = Flask(__name__)


@app.route('/')
def index():
    return render_template('login.html')

@app.route('/login',methods=['GET','POST'])
def login():
    if request.method == 'POST':
        if request.form['username'] == 'admin':
            return redirect(url_for('success'))
        else:
            abort(401)
    else:
        return redirect(url_for('index'))

@app.route('/success')
def success():
    return 'logged in successfully'

if __name__ == '__main__':
    app.run(host='127.0.0.1', port='4002', debug=True)

Flask 消息闪现

一个好的基于 GUI 的应用程序会向用户提供有关交互的反馈。例如，桌面应用程序使用对话框或消息框，JavaScript 使用警报用于类似目的。

在 Flask Web 应用程序中生成这样的信息性消息很容易。Flask 框架的闪现系统可以在一个视图中创建消息，并在名为 next 的视图函数中呈现它。

Flask 模块包含 flash() 方法。它将消息传递给下一个请求，该请求通常是一个模板。

flash(message, category)

message 参数是要闪现的实际消息。
category 参数是可选的。它可以是“error”，“info”或“warning”。

为了从会话中删除消息，模板调用 get_flashed_messages()。

get_flashed_messages(with_categories, category_filter)

两个参数都是可选的。如果接收到的消息具有类别，则第一个参数是元组。第二个参数仅用于显示特定消息。

以下闪现在模板中接收消息。

{% with messages = get_flashed_messages() %}
   {% if messages %}
      {% for message in messages %}
         {{ message }}
      {% endfor %}
   {% endif %}
{% endwith %}

让我们看一个简单的例子，演示Flask中的闪现机制。在以下代码中，'/' URL 显示登录页面的链接，没有消息闪现。

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

该链接会将用户引导到'/ login' URL，该 URL 显示登录表单。提交时，login() 视图函数验证用户名和密码，并相应闪现 'success' 消息或创建 'error' 变量。

@app.route('/login', methods = ['GET', 'POST'])
def login():
    error = None
    if request.method == 'POST':
        if request.form['username'] != 'admin' or \
           request.form['password'] != 'admin':
           error = 'Invalid username or password. Please try again!'
       else:
           flash('You were successfully logged in')
           return redirect(url_for('index'))
    return render_template('login.html', error = error)

如果出现错误，则会重新显示登录模板，并显示错误消息。

login_error.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Login</title>
</head>
<body>
 <form method = "post" action = "http://localhost:4002/login">
        <table>
            <tr>
                <td>Username</td>
                <td><input type = 'username' name = 'username'></td>
            </tr>
            <tr>
                <td>Password</td>
                <td><input type = 'password' name = 'password'></td>
            </tr>
            <tr>
                <td><input type = "submit" value = "Submit"></td>
            </tr>
        </table>
    </form>
    {% if error %}
        <p><strong>Error</strong>: {{ error }}</p>
    {% endif %}
</body>
</html>

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Index</title>
</head>
<body>
    {% with messages = get_flashed_messages() %}
         {% if messages %}
               {% for message in messages %}
                    <p>{{ message }}</p>
               {% endfor %}
         {% endif %}
    {% endwith %}
<h3>Welcome!</h3>
<a href = "{{ url_for('login') }}">login</a>
</body>
</html>

下面给出了 Flask 消息闪现示例的完整代码：

Flash.py

#!/usr/config/env python
# -*- coding:utf-8 -*-

from flask import Flask, render_template,flash,redirect,request,url_for
app = Flask(__name__)

app.secret_key = 'random string'

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

@app.route('/login',methods=['GET','POST'])
def login():
    error = None

    if request.method == 'POST':
        if request.form['username'] != 'admin' or request.form['password'] != 'admin':
            error = 'Invalid username or password. Please try again!'
        else:
            flash('You were successfully logged in')
            return redirect(url_for('index'))

    return render_template('login_error.html',error = error)

if __name__ == '__main__':
    app.run(host='127.0.0.1', port='4002', debug=True)

Flask 文件上传

在 Flask 中处理文件上传非常简单。它需要一个 HTML 表单，其 enctype 属性设置为“multipart / form-data”，将文件发布到 URL。URL 处理程序从 request.files[] 对象中提取文件，并将其保存到所需的位置。

每个上传的文件首先会保存在服务器上的临时位置，然后将其实际保存到它的最终位置。目标文件的名称可以是硬编码的，也可以从 request.files[file] 对象的 filename 属性中获取。但是，建议使用 secure_filename() 函数获取它的安全版本。

可以在 Flask 对象的配置设置中定义默认上传文件夹的路径和上传文件的最大大小

app.config[‘UPLOAD_FOLDER’] 定义上传文件夹的路径 app.config[‘MAX_CONTENT_LENGTH’] 指定要上传的文件的最大大小（以字节为单位）

以下代码具有 '/ upload' URL 规则，该规则在 templates 文件夹中显示 'upload.html'，以及 '/ upload-file' URL 规则，用于调用 uploader() 函数处理上传过程。

'upload.html' 有一个文件选择器按钮和一个提交按钮

upload.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>File upload</title>
</head>
<body>
<form action="http://localhost:4002/uploader" method="post" enctype="multipart/form-data">
    <input type="file" accept=".jpg,.png" name="file">
    <input type="submit">
</form>

</body>
</html>

upload.py

#!/usr/config/env python
# -*- coding:utf-8 -*-


from flask import Flask, render_template,request
from werkzeug.utils import secure_filename
import os

app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = 'upload/'

@app.route('/upload')
def upload_file():
    return render_template('upload.html')

@app.route('/uploader',methods=['GET','POST'])
def uploader():
    if request.method == 'POST':
        f = request.files['file']
        f.save(os.path.join(os.path.dirname(os.path.abspath(__file__)), secure_filename(f.filename)))
        return 'file uploaded successfully'

if __name__ == '__main__':
    app.run(host='127.0.0.1', port='4002', debug=True)

posted @ 2021-02-02 15:56 Binzichen 阅读(181) 评论(0) 编辑收藏举报

刷新页面返回顶部

Loading

超香Q的五香卤猪脚

Flask框架应用

简介

Flask环境

Flask安装条件

Flask应用

调试模式

Flask路由

Flask变量规则

Flask URL构建

Flask HTTP方法

换成get请求

Flask模板

模板基本使用

Flask静态文件

Flask Request对象

Flask 将表单数据发送到模板

Flask Cookies

设置cookie

获取cookie

删除cookie

设置cookie举例

设置cookies

获取cookie

删除cookie

Flask 会话

Flask Sessions（会话）

Flask 重定向和错误

Flask 消息闪现

Flask 文件上传

公告