snjl

我大概率会编程。


  • 首页

  • 标签

  • 分类

  • 归档

  • 搜索

flask:http方法

发表于 2019-02-13 | 分类于 flask
字数统计: 656 字 | 阅读时长 ≈ 2 分钟

默认情况下,Flask路由响应GET请求。 但是,可以通过为route()装饰器提供方法参数来更改此首选项。为了演示在URL路由中使用POST方法,首先创建一个HTML表单并使用POST方法将表单数据发送到URL。将以下脚本保存到文件:login.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<title>Flask HTTP请求方法处理</title>
</head>
<body>
<form action = "http://localhost:5000/login" method = "post">
<p>输入姓名:</p>
<p><input type = "text" name = "name" value=""/></p>
<p><input type = "submit" value = "提交" /></p>
</form>

</body>
</html>

HTML现在在Python shell中输入以下脚本。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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['name']
return redirect(url_for('success',name = user))
else:
user = request.args.get('name')
return redirect(url_for('success',name = user))

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

Python开发服务器开始运行后,在浏览器中打开login.html,在文本字段中输入名称(如:maxsu )并单击提交。

表单数据被提交到

标签的action属性指定的URL。http://localhost:5000/login被映射到login()函数。 由于服务器已通过POST方法接收数据,因此从表单数据获得’name’参数的值,通过以下方式-
1
user = request.form['name']

Python它作为可变部分传递给URL:/success。 浏览器在窗口中显示欢迎消息。

将login.html中的方法参数更改为GET并在浏览器中再次打开。 在服务器上收到的数据是通过GET方法。 ‘name’参数的值现在通过以下方式获得 -

1
User = request.args.get('name')

Python这里,args是字典对象,它包含一系列表单参数及其对应值。 与之前一样,与’name’参数对应的值将传递到URL:/success。

请求对象

来自客户端网页的数据作为全局请求对象发送到服务器。要处理请求数据,请求对旬应该从Flask模块导入。请求对象的重要属性如下所列

  • form 包含表单参数及其值的键和值对的字典对象。
  • args 解析问号(?)后的URL部分查询字符串的内容。
  • cookies 保存Cookie名称和值的字典对象。
  • file 与上传文件有关的数据。
  • method 当前请求方法。

SQLAlchemy:简单使用SQLAlchemy

发表于 2019-02-13 | 分类于 python , SQLAlchemy
字数统计: 1.5k 字 | 阅读时长 ≈ 6 分钟

使用

导入SQLAlchemy,并初始化DBSession:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 导入:
from sqlalchemy import Column, String, create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

# 创建对象的基类:
Base = declarative_base()

# 定义User对象:
class User(Base):
# 表的名字:
__tablename__ = 'user'

# 表的结构:
id = Column(String(20), primary_key=True)
name = Column(String(20))

# 初始化数据库连接:
engine = create_engine('mysql+mysqlconnector://root:password@localhost:3306/test')
# 创建DBSession类型:
DBSession = sessionmaker(bind=engine)

注:create_engine可以使用echo参数,echo=True,可以输出日志,如下所示“

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2019-02-05 16:20:31,866 INFO sqlalchemy.engine.base.Engine SHOW VARIABLES LIKE 'sql_mode'
2019-02-05 16:20:31,866 INFO sqlalchemy.engine.base.Engine {}
2019-02-05 16:20:31,872 INFO sqlalchemy.engine.base.Engine SHOW VARIABLES LIKE 'lower_case_table_names'
2019-02-05 16:20:31,872 INFO sqlalchemy.engine.base.Engine {}
2019-02-05 16:20:31,879 INFO sqlalchemy.engine.base.Engine SELECT DATABASE()
2019-02-05 16:20:31,879 INFO sqlalchemy.engine.base.Engine {}
2019-02-05 16:20:31,882 INFO sqlalchemy.engine.base.Engine SELECT CAST('test plain returns' AS CHAR(60)) AS anon_1
2019-02-05 16:20:31,882 INFO sqlalchemy.engine.base.Engine {}
2019-02-05 16:20:31,883 INFO sqlalchemy.engine.base.Engine SELECT CAST('test unicode returns' AS CHAR(60)) AS anon_1
2019-02-05 16:20:31,883 INFO sqlalchemy.engine.base.Engine {}
2019-02-05 16:20:31,885 INFO sqlalchemy.engine.base.Engine BEGIN (implicit)
2019-02-05 16:20:31,887 INFO sqlalchemy.engine.base.Engine SELECT `USER`.id AS `USER_id`, `USER`.name AS `USER_name`
FROM `USER`
WHERE `USER`.name = %(name_1)s AND `USER`.id = %(id_1)s
2019-02-05 16:20:31,887 INFO sqlalchemy.engine.base.Engine {'name_1': 'Bob', 'id_1': '5'}

以上代码完成SQLAlchemy的初始化和具体每个表的class定义。如果有多个表,就继续定义其他class,例如School:

1
2
3
4
class School(Base):
__tablename__ = 'school'
id = ...
name = ...

注:类必须继承Base基类,而且必须定义tablename,对应数据库中表的名称,且类中每个字段的名称必须对应数据库中的字段名称(windows中可以大小写,linux未测试),类中的字段可以少,例如数据库中有time字段,如果不是必要字段,可以在类中不定义time字段。

定义了tablename,可以输出类构建的表的信息:

1
2
>>> User.__table__
Out[2]: Table('USER', MetaData(bind=None), Column('id', String(length=20), table=<USER>, primary_key=True, nullable=False), Column('name', String(length=20), table=<USER>), schema=None)

create_engine()用来初始化数据库连接。SQLAlchemy用一个字符串表示连接信息:

1
'数据库类型+数据库驱动名称://用户名:口令@机器地址:端口号/数据库名'

你只需要根据需要替换掉用户名、口令等信息即可。

下面,我们看看如何向数据库表中添加一行记录。

由于有了ORM,我们向数据库表中添加一行记录,可以视为添加一个User对象:

1
2
3
4
5
6
7
8
9
10
# 创建session对象:
session = DBSession()
# 创建新User对象:
new_user = User(id='5', name='Bob')
# 添加到session:
session.add(new_user)
# 提交即保存到数据库:
session.commit()
# 关闭session:
session.close()

注:这里的sesson就是pymysql中的cursor游标,DBSession才是pymysql中的session。
可见,关键是获取session,然后把对象添加到session,最后提交并关闭。DBSession对象可视为当前数据库连接。

如何从数据库表中查询数据呢?有了ORM,查询出来的可以不再是tuple,而是User对象。SQLAlchemy提供的查询接口如下:

1
2
3
4
5
6
7
8
9
# 创建Session:
session = DBSession()
# 创建Query查询,filter是where条件,最后调用one()返回唯一行,如果调用all()则返回所有行:
user = session.query(User).filter(User.id=='5').one()
# 打印类型和对象的name属性:
print('type:', type(user))
print('name:', user.name)
# 关闭Session:
session.close()

运行结果如下:

1
2
type: <class '__main__.User'>
name: Bob

如果要查找多个条件,可以写成以下几种形式:

1
2
3
a = session.query(User).filter(User.name == 'Bob').filter(User.id == '5').all()
a = session.query(User).filter(User.name == 'Bob', User.id == '5').all()
a = session.query(User).filter(User.name == 'Bob' and User.id == '5').all()

更通用的方法是用and_

1
a = session.query(User).filter(and_(User.name == 'Bob', User.id == '5')).all()

使用like,如下所示:

1
a = session.query(User).filter(and_(User.name.like("%%"), User.id.like('%2%'))).all()

使用filter_by

1
a = session.query(User).filter_by(id='5').all()

filter_by特点是不需要使用类属性表示,可以使用参数,例如id,name等。

可见,ORM就是把数据库表的行与相应的对象建立关联,互相转换。

由于关系数据库的多个表还可以用外键实现一对多、多对多等关联,相应地,ORM框架也可以提供两个对象之间的一对多、多对多等功能。

例如,如果一个User拥有多个Book,就可以定义一对多关系如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class User(Base):
__tablename__ = 'user'

id = Column(String(20), primary_key=True)
name = Column(String(20))
# 一对多:
books = relationship('Book')

class Book(Base):
__tablename__ = 'book'

id = Column(String(20), primary_key=True)
name = Column(String(20))
# “多”的一方的book表是通过外键关联到user表的:
user_id = Column(String(20), ForeignKey('user.id'))

当我们查询一个User对象时,该对象的books属性将返回一个包含若干个Book对象的list。

run参数

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

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

Python上面方法中的所有参数都是可选的,作用如下表描述说明

编号 参数 描述
1 host 监听的主机名。默认为127.0.0.1(localhost)。 设置为’0.0.0.0’使服务器在外部可用
2 port 监听端口号,默认为:5000
3 debug 默认为:false。 如果设置为:true,则提供调试信息
4 options 被转发到底层的Werkzeug服务器。

小结

ORM框架的作用就是把数据库表的一行记录与一个对象互相做自动转换。

正确使用ORM的前提是了解关系数据库的原理。

报错

报错找不到mysql的包,需要安装mysql-connector

1
pip install mysql-connector

flask返回json数据

发表于 2019-02-13 | 分类于 flask
字数统计: 174 字 | 阅读时长 ≈ 1 分钟

定义类后,在里面定义方法to_json():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 创建对象的基类:
Base = declarative_base()


# Address对象:
class Address(Base):
# 表的名字:
__tablename__ = 'address'
# 表的结构:
id = Column(Integer, primary_key=True)
address = Column(String(20))
status = Column(Integer)

def to_json(self):
return {
'id': self.id,
'address': self.address,
'status': self.status
}

返回dict数据。

返回json数据,使用jsonify:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from flask import Flask, jsonify

@app.route('/ajax')
def ajax():
session = DBSession()
try:
addresses = session.query(Address).filter().all()
addresses_json = list()
for address in addresses:
print(address.address)
addresses_json.append(address.to_json())
return jsonify({'addresses': addresses_json})

except Exception as e:
print(e)
finally:
session.close()

返回的数据如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
addresses: [
{
address: "xxx#qq.com",
id: 1,
status: 0
},
{
address: "xxx@163.com",
id: 2,
status: 0
}
]
}

flask:cookie处理

发表于 2019-02-13 | 分类于 flask
字数统计: 685 字 | 阅读时长 ≈ 3 分钟

Cookie以文本文件的形式存储在客户端计算机上。

其目的是记住和跟踪与客户使用有关的数据,以获得更好的访问体验和网站统计。Request对象包含一个cookie的属性。

它是所有cookie变量及其对应值的字典对象,客户端已发送。

除此之外,cookie还会存储其到期时间,路径和站点的域名。在Flask中,cookies设置在响应对象上。

使用make_response()函数从视图函数的返回值中获取响应对象。

之后,使用响应对象的set_cookie()函数来存储cookie。重读cookie很容易。

可以使用request.cookies属性的get()方法来读取cookie。在下面的Flask应用程序中,当访问URL => / 时,会打开一个简单的表单

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

这个HTML页面包含一个文本输入,完整代码如下所示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Flask Cookies示例</title>
</head>
<body>

<form action = "/setcookie" method = "POST">
<p><h3>Enter userID</h3></p>
<p><input type = 'text' name = 'name'/></p>
<p><input type = 'submit' value = '登录'/></p>
</form>

</body>
</html>

表单提交到URL => /setcookie。 关联的视图函数设置一个Cookie名称为:userID,并的另一个页面中呈现。

1
2
3
4
5
6
7
8
9
@app.route('/setcookie', methods = ['POST', 'GET'])
def setcookie():
if request.method == 'POST':
user = request.form['name']

resp = make_response(render_template('readcookie.html'))
resp.set_cookie('userID', user)

return resp

readcookie.html代码可为空:

1
2
3
4
5
6
7
8
9
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
</body>
</html>

readcookie.html 包含超链接到另一个函数getcookie()的视图,该函数读回并在浏览器中显示cookie值。

1
2
3
4
@app.route('/getcookie')
def getcookie():
name = request.cookies.get('userID')
return '<h1>welcome '+name+'</h1>'

完整的应用程序代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
from flask import Flask
from flask import render_template
from flask import request
from flask import make_response


app = Flask(__name__)

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

@app.route('/setcookie', methods = ['POST', 'GET'])
def setcookie():
if request.method == 'POST':
user = request.form['name']

resp = make_response(render_template('readcookie.html'))
resp.set_cookie('userID', user)
return resp

@app.route('/getcookie')
def getcookie():
name = request.cookies.get('userID')
print (name)
return '<h1>welcome, '+name+'</h1>'

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

运行该应用程序并访问URL => http://localhost:5000/,设置cookie后,会跳转到readcookie.html,再访问getcookie页面,会看到cookie值。

flask:消息闪现

发表于 2019-02-13 | 分类于 flask
字数统计: 970 字 | 阅读时长 ≈ 4 分钟

一个基于GUI好的应用程序需要向用户提供交互的反馈信息。 例如,桌面应用程序使用对话框或消息框,JavaScript使用alert()函数用于类似的目的。

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

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

1
flash(message, category)

在这里

  • message - 参数是要刷新的实际消息。
  • category - 参数是可选的。 它可以是’错误’,’信息’或’警告’。

要从会话中删除消息,模板调用get_flashed_messages()函数。

1
get_flashed_messages(with_categories, category_filter)

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

以下闪现模板中收到消息。

1
2
3
4
5
6
7
{% with messages = get_flashed_messages() %}
{% if messages %}
{% for message in messages %}
{{ message }}
{% endfor %}
{% endif %}
{% endwith %}

现在我们来看一个简单的例子,演示Flask中的闪现机制。 在下面的代码中,URL => “/”显示了到登录页面的链接,没有指定要发送的消息。

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

该链接引导用户显示登录表单的URL => “/login”。 提交时,login()函数验证用户名和密码,并相应地闪现“成功”或“错误”变量消息。

1
2
3
4
5
6
7
8
9
10
11
12
@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.html 代码如下 -

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Flask示例</title>
</head>
<body>

<h1>登录</h1>
{% if error %}
<p><strong>Error:</strong> {{ error }}
{% endif %}
<form action = "/login" method ="POST">
<dl>
<dt>用户名:</dt>
<dd>
<input type = text name = "username"
value = "{{request.form.username }}">
</dd>
<dt>密码:</dt>
<dd><input type ="password" name ="password"></dd>
</dl>
<p><input type = submit value ="登录"></p>
</form>

</body>
</html>

如果登录成功,则在索引模板上闪现成功消息。以下代码保存在文件(index.html)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Flask消息闪现</title>
</head>
<body>


{% with messages = get_flashed_messages() %}
{% if messages %}
<ul class=flashes>
{% for message in messages %}
<li>{{ message }}</li>
{% endfor %}
</ul>
{% endif %}
{% endwith %}

<h1>Flask Message Flashing Example</h1>
<p>您想要<a href = "{{ url_for('login') }}">
<b>登录?</b></a></p>

</body>
</html>

Flask消息闪现示例的完整代码如下所示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from flask import Flask, flash, redirect, render_template, 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
print(request.method)
if request.method == 'POST':
if request.form['username'] != 'admin' or \
request.form['password'] != 'admin':
error = 'Invalid username or password. Please try again!'
else:
#flash('您已成功登录')
flash('You were successfully logged in')
return redirect(url_for('index'))
return render_template('login.html', error = error)

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

flask简单示例:学生信息添加展示

发表于 2019-02-13 | 分类于 flask
字数统计: 1.7k 字 | 阅读时长 ≈ 8 分钟

项目地址:https://github.com/snjl/python.flask.student_item.git

使用的是flask-sqlalchemy,需要使用pip安装然后导入

1
from flask_sqlalchemy import SQLAlchemy

阅读全文 »

flask:变量规则

发表于 2019-02-13 | 分类于 flask
字数统计: 570 字 | 阅读时长 ≈ 2 分钟

可以通过将可变部分添加到规则参数来动态构建URL。 这个变量部分被标记为。 它作为关键字参数传递给规则所关联的函数。在以下示例中,route()装饰器的规则参数包含附加到URL /hello的变量部分。 因此,如果在浏览器中输入URL: http://localhost:5000/hello/YiibaiYiibai,那么 ‘YiibaiYiibai’ 将作为参数提供给hello()函数。参考如下代码 -

1
2
3
4
5
6
7
8
9
from flask import Flask
app = Flask(__name__)

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

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

Python将上面的脚本保存到文件:hello.py,并从Python shell运行它。
接下来,打开浏览器并输入URL => http://localhost:5000/hello/YiibaiYiibai可以看到结果。

除了默认的字符串变量部分之外,还可以使用以下转换器构造规则 -
编号 | 转换器 | 描述
—|—|—
1 | int | 接受整数
2 | float | 对于浮点值
3 | path | 接受用作目录分隔符的斜杠符(/)在下面的代码中,使用了所有这些构造函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
from flask import Flask
app = Flask(__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()

Python从Python Shell运行上述代码。 在浏览器中访问URL => http:// localhost:5000/blog/11。给定的数字值作为:show_blog()函数的参数。 浏览器显示以下输出

1
Blog Number 11

Shell在浏览器中输入此URL - http://localhost:5000/rev/1.1revision()函数将浮点数作为参数。 以下结果出现在浏览器窗口中

1
Revision Number 1.100000

ShellFlask的URL规则基于Werkzeug的路由模块。
这确保了形成的URL是唯一的,并且基于Apache制定的先例。考虑以下脚本中定义的规则 -

1
2
3
4
5
6
7
8
9
10
11
12
13
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()

Python两条规则看起来都很相似,但在第二条规则中,使用了尾部斜线(/)。 因此,它变成了一个规范的URL。 因此,使用/python或/python/返回相同的输出。 但是,在第一条规则的情况下, URL:/flask/会导致404 Not Found页面。

flask:路由

发表于 2019-02-13 | 分类于 flask
字数统计: 163 字 | 阅读时长 ≈ 1 分钟

现代Web框架使用路由技术来帮助用户记住应用程序URL。 无需从主页导航即可直接访问所需页面。Flask中的route()装饰器用于将URL绑定到函数。 例如 -@app.route(‘/hello’)

1
2
def hello_world():
return 'hello world'

Python这里,URL /hello规则绑定到hello_world()函数。 因此,如果用户访问URL : http://localhost:5000/hello ,就会调用hello_world()函数,这个函数中的执行的结果输出将在浏览器中呈现。应用程序对象的add_url_rule()函数也可用于将URL与函数绑定,如上例所示,使用route()。

1
2
3
4
def hello_world():
return 'hello world'

app.add_url_rule('/', 'hello', hello_world)

flask静态文件

发表于 2019-02-13 | 分类于 flask
字数统计: 298 字 | 阅读时长 ≈ 1 分钟

Web应用程序通常需要一个静态文件,例如支持显示网页的JavaScript文件或CSS文件。 通常,可以通过配置Web服务器提供这些服务,但在开发过程中,这些文件将从包中的静态文件夹或模块旁边提供,它将在应用程序的/static上提供。使用特殊的端点“静态”来为静态文件生成URL。在以下示例中,index.html中的HTML按钮的OnClick事件调用hello.js中定义的javascript函数,该函数在Flask应用程序的URL => / 中呈现。

1
2
3
4
5
6
7
8
9
from flask import Flask, render_template
app = Flask(__name__)

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

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

Pythonindex.html 中的HTML脚本如下所示。

1
2
3
4
5
6
7
8
9
<html>
<head>
<script type = "text/javascript"
src = "{{ url_for('static', filename = 'hello.js') }}" ></script>
</head>
<body>
<input type = "button" onclick = "sayHello()" value = "Say Hello" />
</body>
</html>

HTML文件:hello.js 中定义包含 sayHello() 函数。

1
2
3
function sayHello() {
alert("Hello World")
}

也可以使用html正常的引入方式:

1
<script type = "text/javascript" src = "/static/hello.js" ></script>

flask:重定向和错误

发表于 2019-02-13 | 分类于 flask
字数统计: 467 字 | 阅读时长 ≈ 2 分钟

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

redirect()函数的原型如下

1
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,这是表示’找到’页面。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from flask import Flask, redirect, url_for, render_template, request
# Initialize the Flask application
app = Flask(__name__)

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

@app.route('/login',methods = ['POST', 'GET'])
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(debug = True)

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

1
Flask.abort(code)

code参数使用以下值之一

  • 400 - 对于错误的请求
  • 401 - 用于未经身份验证
  • 403 - 禁止404 - 未找到
  • 406 - 不可接受
  • 415 - 用于不支持的媒体类型
  • 429 - 请求过多

这里对上面的代码中的login()函数进行一些细微的修改。 如果要显示“Unauthourized”页面,而不是重新显示登录页面,请将其替换为中止(401)的调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from flask import Flask, redirect, url_for, render_template, request, abort
app = Flask(__name__)

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

@app.route('/login',methods = ['POST', 'GET'])
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(debug = True)
123…21
snjl

snjl

越过山丘,才发现无人等候。

203 日志
44 分类
107 标签
RSS
GitHub E-Mail Weibo
© 2019 snjl
总访问量次 | 总访客人 |
由 Hexo 强力驱动
|
主题 — NexT.Mist v5.1.4