盘点Python网页开发轻量级框架Flask知识（下篇）-51CTO.COM

[[408569]]

前言

今天来给大家说一个Python的轻量级web开发框架-------Flask，为什么要推荐它呢?当然是因为它够轻量级了，开发迅速是它的特点，当然它也有缺点，不过这里不说，因为既用它又说它差感觉不好。上篇文章我们说了一半的内容，盘点Python网页开发轻量级框架Flask知识(上篇)，这篇文章继续补全剩下的一半内容，一起来学习下吧~

11.request操作

这是一个专门用来操作网页请求的模块，今天我们围绕这个来具体讲解。

1)request.method

它是request中的请求方法，一般我们用的比较多的便是get和post，由于get 和post需要配合表单一起使用，在这里我们暂时不讲前端的内容，只做简单的演示。

一、get请求

可通过设置它的methods参数来指定请求方式。

@app.route('/get', methods = ['GET','POST']) 
def get(): 
    if request.method == 'GET': 
        return '这是一个GET请求' 
    else: 
        return '这是一个其它请求' 
1.
2.
3.
4.
5.
6.

二、post请求

@app.route('/post', methods = ['POST','GET']) 
def post(): 
    if request.method == 'POST': 
        return '这是一个POST请求' 
    else: 
        return '这是一个其它请求' 
1.
2.
3.
4.
5.
6.

2)request.args

记录get请求中的查询参数，一般用于查询，搜索网址

https://www.kugou.com/yy/html/search.html#searchType=song&searchKeyWord=不谓侠 
1.

它会返回get请求中的参数，比如请求上面的url，它的请求参数便是：

searchType=song&searchKeyWord=不谓侠 
1.

使用方法：

request.args['keyword'] 
request.args.get('keyword') 
1.
2.

3)request.form

记录请求中的表单数据，一般用于表单提交。比如我们注册网站时经常需要进行表单提交。

我们可以使用获取表单中的内容：

request.form['keyword'] 
request.form.get('keyword') 
1.
2.

4)reuqest.values

返回请求中的参数和表单，这个用的比较少，暂不细说。

5)request.cookies

获取网页中的cookies的所有信息，也可以只获取cookies中的一个参数的值。

request.cookies['keyword'] 
request.cookies.get('keyword') 
1.
2.

6)request.headers

返回请求网页头部信息，返回一个列表。

request.headers['keyword'] 
request.headers.get('keyword') 
1.
2.

7)request.url、path、script_root、base_url、url_root

request.url：返回请求中的网页地址 
 
request.path：返回网页存放地址 
 
request.script_root:返回脚本根目录 
 
request.base_url:返回请求相对地址 
 
request.url_root:返回请求网页根目录 
1.
2.
3.
4.
5.
6.
7.
8.
9.

8)request.data

返回请求的数据

request.data #返回一个字节类型的值 
1.

9)request.files

文件上传必备，属于提交表单的类型，所以这是个post类型的请求方式，我们可以使用files的file字段来设置：

@app.route('/upload',methods=['GET','POST']) 
def upload(): 
    if request.method == 'POST': 
        f = request.files['file'] 
        filename = secure_filename(f.filename) #需要设置安全文件类型 
        #f.save(os.path.join('app/static',filename))两种保存方式 
        f.save('app/static/'+str(filename)) 
        return 'ok' 
    else: 
        return 'fail' 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

10)request.json

返回json格式的数据

11)request.environ

返回环境变量的键值

12)request.remote_addr

返回客户端的访问ip地址

13)request.host

返回host信息

12.上下文与请求钩子

1)上下文

可能大部分人对这个概念比较难以琢磨，先来说说上下文，什么是上下文?一说起上下文，我猜大家第一时间一定会想起with，想到with大家肯定会想起上下文的模块contexlib以及魔法方法enter 和exit,可以说，它是将复杂的事情简单化的一个神器的装饰器，我是这样理解的。那么再来看看flask的上下文。

一、应用程序上下文

它作用于flask应用中，可以用作程序实例和存储临时变量，它可分为两种：

g：处理请求时用作临时存储的对象，每次请求都会重设这个变量 
 
current_app： 当前程序实例 
1.
2.
3.

二、请求上下文

顾名思义，它用于网络请求中，它也有两种。

request：请求对象 
Session：存储会话 
1.
2.

2)钩子

再来看看钩子，什么是钩子?这一点是我们先要搞清楚的，钩子其实就是在我们进行请求时，它规范了我们的请求内容和请求方式以及请求时该做什么，什么时候做，具体做哪些事，起到了一个承上启下的作用，所以，它很有用处。

一、在处理第一个请求前运行，可以用来连接数据库进行查询操作

before_first_request 
1.

二、在处理每个请求前运行,可以进行权限校验

before_request 
1.

三、在每个请求结束后自动处理返回的响应数据

after_request 
1.

四、在每个请求结束后自动异常并将异常对象作为参数传到函数中

teardown_request 
1.

五、在视图函数中注册一个函数，会在请求结束后运行

after_this_request 
1.

说完了这么多那么它们该怎么用了，接下来请看我表演：

@app.before_first_request 
def first(): 
    print('我是第一运行的') 
 
@app.before_request 
def every(): 
    print('我又来了') 
 
@app.after_request 
def recv(res): 
    res.headers['Content-Type']='application/json' #更改响应头部数据 
    return res 
 
@app.route('/start/<string:id>') 
def start(id): 
    g.use=request.cookies.get('user') 
    if id==g.use: 
        return request.url 
    else: 
        return request.cookies 
 
ac= app.app_context() #应用上下文管理器 
ac.push() #进 
print(ac) 
a = current_app 
print(a) 
ac.pop() #出 
print(ac) 
 
with app.app_context() as f: 
    b= current_app 
    print(b) 
    print(f) 
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.
30.
31.
32.
33.

13.蓝图

从上面的事例我们可以看出，随着我们开发的东西越来越多，把所有东西放在一个文件里，很显然不切实际。

我们尝试着使用模块调用，于是我编写了两个Python程序，用来调用：

demo1.py

from flask import Flask 
app=Flask(__name__) 
@app.route('/kj') 
def df(): 
    return 'hello world' 
@app.route('/index') 
def lk(): 
    return 'efhsfj' 
1.
2.
3.
4.
5.
6.
7.
8.

demo2.py

from flask import Flask,request 
from demo1 import * 
@app.route('/') 
def login(): 
    return request.url 
if __name__ == '__main__': 
    app.run(debug=True) 
1.
2.
3.
4.
5.
6.
7.

这里demo2是可以成功调用demo1的，但是了，它无法操作demo1的变量以及一些实例，换言之就是只能调用，无法控制改变，于是这个时候蓝图就派上用场了,那么让我们来看看吧。

demo3.py

from flask import Flask 
from demo4 import root 
from demo5 import admin 
app=Flask(__name__) #应用实例 
@app.route('/') 
def lo(): 
    return '1111' 
app.register_blueprint(root,url_prefix='/') #蓝图对象和蓝图挂载点 
app.register_blueprint(root,url_prefix='/root')  
app.register_blueprint(root,url_prefix='/admin')  
app.register_blueprint(admin,url_prefix='/') 
app.register_blueprint(admin,url_prefix='/admin')  
app.register_blueprint(admin,url_prefix='/root')  
if __name__ == '__main__': 
    app.run(debug=True) 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

demo4.py

from flask import Flask,Blueprint 
root=Blueprint('root',__name__) #蓝图名称和蓝图所在的模块 
@root.route('/login') 
def b1(): 
    return 'hello' 
@root.route('/index') 
def b2(): 
    return 'world' 
1.
2.
3.
4.
5.
6.
7.
8.

demo5.py

from flask import Flask,Blueprint 
admin=Blueprint('admin',__name__) #蓝图名称和蓝图所在的模块 
@admin.route('/ff') 
def bw(): 
    return 'ergdsfg' 
@admin.route('/gg') 
def be(): 
    return 'gtergsdf' 
1.
2.
3.
4.
5.
6.
7.
8.

蓝图的精髓无非就是将多个模块引入到一个主模块中使用，相当于我们自己在写模块并把它当到蓝图中供调用。多个蓝图中如果有相同方法可用蓝图视图函数来区分各自的方法。

14.视图

一提到视图，相信大家能想到它的意思，比如mysql数据库中的视图，道理其实都是互通的，并不会有太大的差别，只是功能不一样罢了。创建视图的方式也很简单，都继承自flask的views类。

1)类视图

from flask.views import View 
def ff(): 
    return 'ok' 
class st(View): 
    def dispatch_request(self): #必须实现这个方法 
        return "任性的90后boy" 
# 类视图通过add_url_rule方法和url做映射 
app.add_url_rule(rule='/ff',view_func=st.as_view('tt')) 
1.
2.
3.
4.
5.
6.
7.
8.

2)方法视图

from flask.views import MethodView 
def gg(): 
    return 'ok' 
class login(MethodView): 
    #当客户端通过get方法进行访问的时候执行的函数 
    def get(self): 
        return 'get' 
    # 当客户端通过post方法进行访问的时候执行的函数 
    def post(self): 
        email = request.form.get("user") 
        password = request.form.get("pass") 
        if user== 'gffsadff' and pass== '4fsaferwf': 
            return "登录成功" 
        else: 
            return "登陆失败" 
 
# 通过add_url_rule添加类视图和url的映射，并且在as_view方法中指定该url的名称，方便url_for函数调用 
app.add_url_rule('/gg',view_func=login.as_view('lg')) 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

15.补充

1)全局对象

with app.test_request_context(): 
    print('我是第一个运行的') 
1.
2.

看到这你应该知道它是干嘛的了吧，没错。

它是整个应用中最先启动的，可以用来做一个提醒界面啥的。

2)路由别名

@app.route('/<path:url>',endpoint='name1') #路由别名为name1 
def first_flask(url):  
    print(url_for('name1',url=url)) #如果设置了url参数，url_for（别名,加参数） 
    return redirect(url_for('get'))#重定向 
1.
2.
3.
4.

3)添加路由规则

def fl(): 
    return 'ok3'  
#app.add_url_rule(rule=访问的url,endpoint=路由别名,view_func=视图名称,methods=请求方法) 
app.add_url_rule(rule='/kj',endpoint='name2',view_func=fl,methods=['GET']) 
1.
2.
3.
4.

4)创建路由的其它方式

无需使用装饰器的中央url映射方法，十分方便，要想实现它需创建三个文件：

myapp.py

from flask import Flask 
import views 
app = Flask(__name__) 
@app.route('/') 
def ll(): 
    return 'index' 
 
@app.route('/use/<usename>') 
def use(usename): 
    return usename 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

views.py

def ll(): 
    return 'index' 
def use(usename): 
    return usename 
1.
2.
3.
4.

main.py

from myapp import views 
from flask import Flask 
app=Flask(__name__) 
app.add_url_rule('/', view_func=views.ll) 
app.add_url_rule('/use/<usename>', view_func=views.use) 
if __name__ == '__main__': 
    app.run(debug=True) 
1.
2.
3.
4.
5.
6.
7.

5)常用状态码

200：请求正确 
404： 路径错误 
405： 请求方式错误 
500： 服务器错误 
302： 重定向 
301 ：永久重定向 
1.
2.
3.
4.
5.
6.

16.总结

本文着重讲解了Flask的最基础的用法，Flask是一个十分优秀的web开发框架，它可以十分迅速的开发出web应用，但是它需要依赖众多的包才能完善更多的功能。