首页 > > 网络编程 > 其它 >

Falsk_day01

2018-08-26 17:33:01来源：博客园阅读 ()

Flask简介

　　Flask是用 Python 语言基于 Werkzeug 工具箱编写的轻量级Web开发框架。

　　其 WSGI 工具箱采用 Werkzeug（路由模块），模板引擎则使用 Jinja2。这两个也是 Flask 框架的核心。

搭建虚拟环境（Ubuntu）

　　一、安装虚拟环境命令:

　　1、sudo pip install virtualenv

　　2、sudo pip install virtualenvwrapper

　　二、创建虚拟环境命令（需联网）：

　　在python3中,创建虚拟环境（python2创建则不需要 -p python3）：
　　mkvirtualenv -p python3 虚拟环境名称

　　三、使用虚拟环境：

　　1、查看虚拟环境的命令：workon 两次tab键

　　2、使用虚拟环境的命令：workon 虚拟环境名称

　　3、退出虚拟环境的命令：deactivate

　　4、删除虚拟环境的命令（先退出虚拟环境）：rmvirtualenv 虚拟环境名称

　　5、在虚拟环境中安装工具包：pip install 包名称

　　　　例：安装flask-0.10.1的包：pip install flask==0.10.1

　　6、查看虚拟环境中安装的包：pip freeze

第一个Flask程序 HelloWord

　　首选用 pycharm 选择相应的虚拟环境的路径

 1 # 导入Flask模块
 2 from flask import Flask
 3 
 4 
 5 # 创建app实例
 6 app = Flask(__name__)
 7 
 8 
 9 # 通过装饰器路由，把url与视图函数绑定起来
10 @app.route('/')
11 def index():
12     return 'hello word!'
13 
14 
15 if __name__ == '__main__':
16     # 运行当前Flask应用程序
17     app.run()

Hello Word

Flask 程序初始化参数

1 app = Flask(__name__,  # import_name是 Flask 程序所在的包（模块），传__name__就可以。其可以决定 Flask 在访问静态文件时查找的路径
2             # static_path='static',  已废弃(用static_url_path代替)
3             static_url_path='/static',  # 静态文件访问路径，可以不传，默认为：/ + static_folder
4             static_folder='static',  # 静态文件存储的文件夹，可以不传，默认为 static 
5             template_folder='templates'  # 模板文件存储的文件夹，可以不传，默认为 templates 
6             )

View Code

程序加载配置

　　1、从配置对象中加载（常用）：

class Config(object):
    DEBUG = True
app.config.from_object(Config)

　　2、从配置文件中加载：

app.config.form_pyfile('配置文件名')

　　3、从环境变量中加载：

app.config.from_envvar('环境变量名称')

读取配置

app.config.get()
# 在视图函数中使用 current_app.config.get()

app.run的参数

app.run(host="0.0.0.0", port=5000, debug = True)

路由基本定义

　　1、定义路由装饰器：@app.route(“/参数“)

　　2、定义请求方式：methods=[‘GET’,‘POST’]

　　3、获取请求方式：request.method

　　参考代码：

# 路由传递参数
@app.route('/user/<user_id>', methods=['GET', 'POST'])  # methods给路由添加请求方式
def user_info(user_id):
    return 'hello %s %s' % (user_id, request.method)
# 路由传递的参数默认当做 string 处理，也可以指定参数的类型@app.route('/user/<int:user_id>')

Falsk 返回 JSON 数据给客户端（常用 jsonify( )）

 1 from flask import Flask, jsonify
 2 from flask import json
 3 
 4 app = Flask(__name__)
 5 
 6 
 7 @app.route('/')
 8 def index():
 9     return 'index'
10 
11 
12 @app.route('/demo2')
13 def demo2():
14     json_dict = {
15         "name": "wenwang",
16         "age": 18
17     }
18     # 使用json.dumps将字典转成JSON字符串
19     # result = json.dumps(json_dict)
20     # 使用json.loads将JSON字符串转成字典
21     # test_dict = json.loads('{"age": 18, "name": "wenwang"}')
22     # return result
23 
24     # TODO jsonify会指定响应内容数据的格式(告诉客户端我返回给你的数据格式是什么)
25     return jsonify(json_dict)
26 
27 if __name__ == '__main__':
28     app.run(debug=True)

View Code

重定向（redirect( ) ，url_for( ) ）

　　例1、重定向到百度

# 重定向
@app.route('/demo1')
def demo1():
    return redirect('http://www.baidu.com')

　　例2、重定向到视图函数

 1 # 路由传递参数
 2 @app.route('/user/<int:user_id>')
 3 def user_info(user_id):
 4     return 'hello %d' % user_id
 5 
 6 # 重定向
 7 @app.route('/demo2')
 8 def demo2():
 9     # 使用 url_for 生成指定视图函数所对应的 url
10     return redirect(url_for('user_info', user_id=100))

View Code

自定义状态码

@app.route('/demo6')
def demo6():
    return '状态码为 666', 666  # 666就为自定义状态码

正则匹配路由

　　实现步骤：

　　1、导入转换器基类：在 Flask 中，所有的路由的匹配规则都是使用转换器对象进行记录。

　　2、自定义转换器：自定义类继承于转换器基类。

　　3、添加转换器到默认的转换器字典中。

　　4、使用自定义转换器实现自定义匹配规则。

　　代码实现：

 1 from flask import Flask
 2 from flask import redirect
 3 from flask import url_for
 4 from werkzeug.routing import BaseConverter
 5 
 6 
 7 class RegexConverter(BaseConverter):
 8     """自定义正则的转换器"""
 9     # regex = '[0-9]{6}'
10 
11     def __init__(self, url_map, *args):
12         super(RegexConverter, self).__init__(url_map)
13         # 取到第1个参数，给regex属性赋值
14         self.regex = args[0]
15 
16 
17 class ListConverter(BaseConverter):
18     regex = "(\\d+,?)+\\d$"
19 
20     def to_python(self, value):
21         """当匹配到参数之后，对参数做进一步处理之后，再返回给视图函数中"""
22         return value.split(',')
23 
24     def to_url(self, value):
25         """使用url_for的时候，对视图函数传的参数进行处理，处理完毕之后以便能够进行路由匹配"""
26         result = ','.join(str(v) for v in value)
27         return result
28         
29 
30 app = Flask(__name__)
31 # 将自己的转换器添加到默认的转化器列表中
32 app.url_map.converters['re'] = RegexConverter
33 app.url_map.converters['list'] = ListConverter
34 
35 
36 @app.route('/')
37 def index():
38     return 'index'
39 
40 # 自定义转换器
41 # @app.route('/user/<re:user_id>')
42 @app.route('/user/<re("[0-9]{6}"):user_id>')
43 def demo1(user_id):
44     return '用户的id是 %s' % user_id
45 
46 
47 @app.route('/users/<list:user_ids>')
48 def demo2(user_ids):
49     return '用户的id是 %s' % user_ids
50 
51 
52 @app.route('/demo3')
53 def demo3():
54     return redirect(url_for('demo2', user_ids=[1, 3, 4, 5]))
55 
56 
57 if __name__ == '__main__':
58     app.run(debug=True)

View Code

异常捕获（ abort() ，@app.errorhandler()）

　　HTTP 异常主动抛出

abort(404)

　　捕获异常

@app.errorhandler(404)
def internal_server_error(e):
    return '网址找不到了'

　　捕获指定异常

@app.errorhandler(ZeroDivisionError)  # 捕获除数不能为0的异常
def zero_division_error(e):
    return '除数不能为0'

请求钩子（ before_request ，after_request ）

　　为了让每个视图函数避免编写重复功能的代码，Flask提供了通用设施的功能，即请求钩子。

　　请求钩子是通过装饰器的形式实现，Flask支持如下四种请求钩子：

　　1、before_first_request

- 在处理第一个请求前执行

　　2、before_request

- 在每次请求前执行
- 如果在某修饰的函数中返回了一个响应，视图函数将不再被调用

　　3、after_request

- 如果没有抛出错误，在每次请求后执行
- 接受一个参数：视图函数作出的响应
- 在此函数中可以对响应值在返回之前做最后一步修改处理
- 需要将参数中的响应在此参数中进行返回

　　4、teardown_request

- 在每次请求后执行
- 接受一个参数：错误信息，如果有相关错误抛出

　　测试代码：

 1 from flask import Flask
 2 
 3 app = Flask(__name__)
 4 
 5 
 6 @app.before_first_request
 7 def before_first_request():
 8     """在第一次请求之前会访问该函数"""
 9     print('before_first_request')
10 
11 
12 @app.before_request
13 def before_request():
14     """在每次请求之前都会调用"""
15     print('before_request')
16     # 可以对一些的请求进行阻止
17 
18 
19 @app.after_request
20 def after_request(response):
21     """在请求之后会调用，并且函数里面接受一个参数：响应，还需要将响应进行返回"""
22     print('after_request')
23     # 可以在此函数中对响应数据做统一的处理
24     return response
25 
26 
27 @app.teardown_request
28 def teardown_request(error):
29     """在请求之后会执行，如果请求的函数报有异常，会把具体异常传入到此函数"""
30     print('teardown_request')
31 
32 
33 @app.route('/')
34 def index():
35     return 'index'
36 
37 
38 if __name__ == '__main__':
39     app.run(debug=True)