FLASK的基本使用

野性酷女 2022-11-21 03:39 285阅读 0赞

### 目录 ###

*   *  一：路由：
     *   *  1: 路由定义：
         *  2: 路由转换器：
         *   *  2.1： 路由转换器的基本使用:
             *  2.2： 路由转换器限制类型：
             *  2.3：自定义路由转换器：
     *  二：请求：
     *   *  1: 了解request:
         *  2：request的基础属性：
         *   *  2.1：request获取请求路径：
             *  2.2：request获取访问的用户和地址：
             *  2.3: 获取请求头：
             *  2.4： 获取请求方式和cookies：
         *  3： request的参数属性：
     *  三：响应：
     *   *  1：返回静态资源（了解）
         *  2：返回元组作为响应（了解）
         *  3：自定义响应对象返回
         *  4：返回JSON数据
         *   *  <方案一>： 使用json模块完成
             *  <方案二>： 使用flask封装的jsonnify模块：
         *  5：重定向
     *  四：状态保持：
     *   *  1：cookie实现
         *  2：session实现
         *  3：JWT tocken实现：
     *  五：异常处理：

## 一：路由： ##

### 1: 路由定义： ###

*  路由绑定的装饰器：app.router(路由地址，请求方式)。
 *  查看路由: app.url\_map。
 *  请求方式忽略大小写。

1.1： 案例; 查看路由的返回格式：

from flask import Flask
    
    app = Flask(__name__)
    
    @app.route('/')
    def hello_word():
        print(app.url_map)
        return 'hello word'
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

结果：返回一个Map类，类中是一个列表，列表分为三部分：路由，请求方式，视图。  
注意：  
**1： 如果一个视图没有写请求方式，则flask自动给get,head,options请求。  
2： flask提供访问静态资源的路由信息：/static/静态文件名， get,head,options请求。  
3： options请求一般用于跨域访问，试探请求。  
4： head请求一般用于查看服务器是否存在某种资源。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center]  
1.2： 修改路由的请求方式：  
注意：请求方式忽略大小写。

from flask import Flask
    
    app = Flask(__name__)
    
    @app.route('/', methods=['get', 'POST'])
    def hello_word():
        print(app.url_map)
        return 'hello word'
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

### 2: 路由转换器： ###

问题：路由如何携带参数呢？

#### 2.1： 路由转换器的基本使用: ####

from flask import Flask
    
    app = Flask(__name__)
    
    @app.route('/user_id/<user_id>')
    def get_userid(user_id):
        print(user_id)
        print(type(user_id))
        return "get user_id  {} ".format(user_id)
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

结果:  
**1: 尖括号内的变量名，必须跟视图的参数名相同。  
2：默认路由匹配的是字符串类型。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 1]

#### 2.2： 路由转换器限制类型： ####

案例要求传入的id必须是int类型：

from flask import Flask
    app = Flask(__name__)
    @app.route('/user_id/<int:user_id>')
    def get_userid(user_id):
        print(user_id)
        print(type(user_id))
        return "get user_id  {} ".format(user_id)
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

结果：  
1： `<int:user_id>` 中间冒号后面不能加空格，不然报错。  
2：格式：<路由转换器的名称:变量名称>  
3：转换器父类的所在地：from werkzeug.routing import BaseConverter  
4： 在routing.py中存在一个放置路由转换器的字典。键是转换器的名称，值是转换器类名。

> \#: the default converter mapping for the map.  
> DEFAULT\_CONVERTERS = \{  
> “default”: UnicodeConverter,  
> “string”: UnicodeConverter,  
> “any”: AnyConverter,  
> “path”: PathConverter,  
> “int”: IntegerConverter,  
> “float”: FloatConverter,  
> “uuid”: UUIDConverter,  
> \}

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 2]

#### 2.3：自定义路由转换器： ####

FLASK怎么做的？：  
flask自己的路由转换器都是继承BaseConverter,然后自己有一个路由列表专门存储转换器名称和转换器的类名。  
思路：  
**1： 自定义转换器，继承于BaseConverter。  
2： 重写regex属性，自定义正则表达式。  
3：将自定义转换器添加到路由列表中（DEFAULT\_CONVERTERS）  
4： 使用自定义路由转换器完成url路径参数的匹配。**

from flask import Flask
    from werkzeug.routing import BaseConverter
    
    app = Flask(__name__)
    
    # 1：自定义转换器，继承于BaseConverter
    class MobileConverter(BaseConverter):
        # 2: 重写父类的regex属性，自定义正则表达式。
        # 注意：不能使用^符号
        regex = r'1[3-9]\d{9}$'
    
    # 3: 将自定义路由转换器添加到默认的转换器字典中
    # 注意converters属性的本质就是DREFAULT_CONVERTERS的拷贝。
    app.url_map.converters['mob'] = MobileConverter
    
    
    # 4:使用自定义路由转换器完成转换。
    @app.route('/mobile/<mob:mobile_num>')
    def hello_word(mobile_num):
        print(mobile_num)
        print(type(mobile_num))
        return "hello word"
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

注意两点:  
**1: regex属性在书写的时候，没有^。  
2：converters属性的本质就是DREFAULT\_CONVERTERS的拷贝。**

## 二：请求： ##

### 1: 了解request: ###

*  1： flask的request和django不同，他是直接在所在的模块导入一个包就可以了。
 *  2： flask中的request相当于给了一个request全局变量，但是不同的视图都需要request,flask是如何区分哪个request对应的是哪个视图的呢？ 答： **request的线程隔离。**

### 2：request的基础属性： ###

#### 2.1：request获取请求路径： ####

注意：  
**1： 返回的url类型是字符串类型。  
2： 使用的方法是request.url。**

from flask import Flask, request
    
    app = Flask(__name__)
    
    @app.route('/')
    def get_url():
        print("request.url的类型是 ", type(request.url)) #<class 'str'>
        print("得到的request:", request.url) # 得到的request: http://127.0.0.1:8000/
        return "get_url"
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

#### 2.2：request获取访问的用户和地址： ####

注意：  
1： 使用的场景是id封号  
2：获取访问的用户：request.remote\_user  
3： 获取访问的地址：request.remote\_addr

from flask import Flask, request
    app = Flask(__name__)
    
    @app.route('/')
    def get_remote():
        print("获取访问的用户：", request.remote_user) # 获取访问的用户： None
        print(type(request.remote_user))  # <class 'NoneType'>
        print("获取访问的ip地址：", request.remote_addr) # 获取访问的地址： 127.0.0.1
        print(type(request.remote_addr))  #<class 'str'>
        return "get_remote"
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

#### 2.3: 获取请求头： ####

*  1：获取全部请求头： request.headers
 *  2：获取到的请求头类型： 字典对象：EnvironHeaders
 *  3：获取请求头中的某项信息：request.headers.get(‘host’)与request.headers\[‘host’\]
 *  4：两种方式区别： get方式不报错。
 *  5：传入的键不区分大小写：request.headers\[‘host’\]与request.headers\[‘Host’\]都可以。

from flask import Flask, request
    app = Flask(__name__)
    
    @app.route('/')
    def get_headers():
        print("获取到的请求头是：", request.headers)
        print("获取到的请求头类型是", type(request.headers)) # 字典对象：获取到的请求头类型是 <class 'werkzeug.datastructures.EnvironHeaders'>
        print("获取请求头中的单个信息", request.headers.get('host')) # 找不到返回空
        print("获取请求头中的单个信息", request.headers['host']) # 找不到报错
    
        return "get_headers"
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

#### 2.4： 获取请求方式和cookies： ####

*  request.method返回值类型是str，并且是大写字母。
 *  request.cookies返回值是字典类型：ImmutableMultiDict

from flask import Flask, request
    app = Flask(__name__)
    
    @app.route('/')
    def get_methods_cookies():
        # 注意获取到的是大写的，如果以后要判断方式一定要考虑大写。
        print("获取到的method是: ", request.method) # 获取到的method是:  GET
        print(type(request.method)) # <class 'str'>
        print("获取到的cookies是：", request.cookies) # 获取到的cookies是： ImmutableMultiDict([])
        print(type(request.cookies)) # <class 'werkzeug.datastructures.ImmutableMultiDict'>
        return "get_methods_cookies"
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

### 3： request的参数属性： ###

*  请求路径参数： 转换器语法
 *  查询字符串参数： request.args（）获取到的是多值字典。
 *  表单数据：request.form() 获取到的是多值字典
 *  前端发送的是json数据: request.json() : 得到的数据是字典(flask自己封装了json转换成字典的方法)
 *  文件数据： request.files().get() : 获取到的是文件对象FileStorage
 *  `# type : FileStorage`变量进行类型声明。
 *  图片保存：图片对象.save(‘路径和名称’)
 *  图片保存：图片对象.read() 读取图片二进制数据  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 3]

## 三：响应： ##

### 1：返回静态资源（了解） ###

*  1：将静态资源放入到 项目的 static 文件夹中。
 *  2：通过内置的静态资源的访问路由, URL路径格式为 `/static/<filename>`  
    案例：如 static目录放入文件 123.jpg, 则访问URL为 http://127.0.0.1:5000/static/123.jpg

from flask import Flask
    
    app = Flask(__name__,  # 导入名称, flask会根据该参数查询静态文件的存储路径
                # 官方建议直接使用__name__, 表示从当前目录中查询静态文件存储路径
                static_folder="static1",  # 设置静态文件的存储目录
                static_url_path='/res/img',  # 设置静态文件的URL访问路径 如 127.0.0.1:5000/res/img/123.jpg
                )
    
    
    if __name__ == '__main__':
        app.run(debug=True)

### 2：返回元组作为响应（了解） ###

*  三者的顺序是：响应体（字符串），状态码（数字），响应头(字典)
 *  返回时，flsk会自己封装成元组。

from flask import Flask
    
    app = Flask(__name__)
    
    @app.route('/')
    def demo_01():
        # 返回多个值，python会封装成元组，然后返回
        return "我是响应体信息", 200, {
        'name':'renshanwen'}
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 4]

### 3：自定义响应对象返回 ###

*  1: 使用make\_response()函数创建响应对象。
 *  2：请求头的不能使用中文，不然报错。
 *  3：状态码只能是数字，不能是字符串。

from flask import Flask, make_response, Response
    
    app = Flask(__name__)
    
    @app.route('/')
    def demo_01():
        # 1： 创建响应对象
        response = make_response('我是响应体') # type: Response
        # 2:自定义状态码
        response.status_code = 201
        # 201表示新建资源
        # 3:自定义响应头
        response.headers['name'] = 'renshanwen'
        # 4： 设置cookie
        # 5: 返回响应对象
        return response
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

响应头使用中文报错。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 5]  
状态码是字符串报错：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 6]

### 4：返回JSON数据 ###

*  1：如果使用json模块返回出现两个问题：1：返回的中文是编码之后的。2：返回的不是json格式，而是文本格式。
 *  2： 使用json模块解决中文编码问题：`json_str = json.dumps(my_dict, ensure_ascii=False, indent=4)`, `ensure_ascii`如果是True,就会将中文转换成ascii码。indent是间隔的空格。
 *  3：使用jsonnify模块，flask做了什么？ 1： 将字典转换成json字符串 2将json字符串包装成响应对象，然后在响应头中设置了响应类型：`Content-Type`。
 *  4：jsonnify模块中文编码问题：增加配置：`app.config['JSON_AS_ASCII'] = False`

#### <方案一>： 使用json模块完成 ####

import json
    from flask import Flask
    
    app = Flask(__name__)
    
    @app.route('/')
    def demo_func():
        # 1: 准备数据
        my_dict = {
        
            'name': '任善文',
            'age': 23
        }
        # 2：将字典转换成json
        json_str = json.dumps(my_dict)
        return json_str
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

返回的格式：  
![在这里插入图片描述][2020103019251834.png_pic_center]  
![在这里插入图片描述][2020103019271135.png_pic_center]

#### <方案二>： 使用flask封装的jsonnify模块： ####

def demo_func():
        # 1: 准备数据
        my_dict = {
        
            'name': '任善文',
            'age': 23
        }
        # 1： 将字典转换成json字符串
        # 2： 将json字符串包装成响应对象，然后在响应头中设置了响应类型：Content-Type: application/json
        json_str = jsonify(my_dict)
        return json_str
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

![在这里插入图片描述][20201030193838190.png_pic_center]  
![在这里插入图片描述][20201030193851905.png_pic_center]  
如果取消转换ASCII编码：增加这个配置。

app.config['JSON_AS_ASCII'] = False

### 5：重定向 ###

*  1：redirect()函数：重定向函数。
 *  2：url\_for()函数：路由反转函数。根据视图名，得到url路径。  
    案例一：重定向到百度

from flask import Flask, redirect
    
    app = Flask(__name__)
    
    @app.route('/')
    def demo_redirect():
        url = 'https://www.baidu.com'
        return redirect(url)
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

案例二：重定向到自己的视图：

from flask import Flask, redirect, url_for
    
    app = Flask(__name__)
    
    @app.route('/')
    def demo_redirect():
        url = 'https://www.baidu.com'
        return redirect(url)
    
    @app.route('/demo')
    def demo_redirect2():
        # 路由反转： 根据路由名称获取url地址
        url = url_for('demo_redirect')
        return redirect(url)
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

## 四：状态保持： ##

### 1：cookie实现 ###

*  注意设置cookie和删除cookie都是response对象的方法。
 *  删除cookie的本质是将时间值修改成0，删除cookie后键值对还是存在的，只不过时间到期了。
 *  1: 设置cookie： response.set\_cookie(‘name’, ‘renshanwen’, max\_age=3600)
 *  2: 删除cookie：response.delete\_cookie(‘name’)
 *  3：获取cookie： request.cookies.get(‘name’)

from flask import Flask, make_response, Response, request
    
    app = Flask(__name__)
    
    @app.route('/login')
    def login():
        response = make_response('返回的响应数据') # type: Response
    
        # 1: 设置cookie，set_cookie参数： 键， 值， 有效期
        response.set_cookie('name', 'renshanwen', max_age=3600)
        # 2: 删除cookie
        # response.delete_cookie('name')
        return response
    
    @app.route('/index')
    def index():
        # 1; 获取cookie
        name = request.cookies.get('name')
        return '登录的用户名是：{}'.format(name)

### 2：session实现 ###

*  1： session的使用直接导入session的包即可。session本质就是一个字典。
 *  2： session的使用步骤：
 *  2.1: 导入session包
 *  2.2： session\[‘username’\] = ‘renshanwen’, 设置session。
 *  2.3： 设置加密密钥： app.secret\_key = ‘renshanwenjiami’ 或者 app.config\[‘SECRET\_KEY’\] = ‘pythonxxxxx’
 *  3: 设置session的有效期：
 *  3.1: app.permanent\_session\_lifetime = datetime.timedelta(hours=2)
 *  3.2: session.permanent = True

from flask import Flask, make_response, Response, request, session
    import datetime
    
    app = Flask(__name__)
    # 方案一
    # app.secret_key = 'renshanwenjiami'
    # 方案二：
    app.config['SECRET_KEY'] = 'pythonxxxxx'
    
    # session设置有效时间
    app.permanent_session_lifetime = datetime.timedelta(hours=2)
    
    @app.route('/login')
    def login():
        session['username'] = 'renshanwen'
        session.permanent = True
        return "正在登录"
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

### 3：JWT tocken实现： ###

*  1： 安装jwt模块： pip3 install Pyjwt  
    注意：不能使用pip装，装的会是python2版本的jwt，很多东西不能用，最好也不要用pycharm装。
 *  2：准备载荷和密钥和过期时间（expire名字固定）
 *  3：根据载荷和密钥，加密生成tocken。

from flask import Flask, make_response, Response, request
    from datetime import datetime, timedelta
    import jwt
    app = Flask(__name__)
    @app.route('/login')
    def login():
        # 准备一个过期时间
        expire = datetime.utcnow() + timedelta(hours=2)
        # 准备载荷：
        payload = {
        
            "user_id": 6,
            "suer_name": "renshanwen",
            "exp": expire
        }
        # 准备密钥
        key = "renshanwen"
    
        # 生成tocken
        tocken =jwt.encode(payload=payload, key=key, algorithm="HS256")
        print(tocken)
        return "JWT登录"
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

@app.route('/profile')
    def profile():
    
        # 1: 在请求头获取tocken
        tocken = request.headers['Authorization']
        # 2: 检验yocken是否过期
        try:
            payload = jwt.decode(tocken, key='renshanwen', algorithms='HS256')
        except Exception as e:
            print(e)
            payload = None
        if payload:
            user_id = payload.get("user_id")
            user_name = payload.get("user_name")
            return "profile: {}, {}".format(user_id, user_name)
        else:
            # 401表示权限认证失败
            return "invalid tocken", 401

## 五：异常处理： ##

*  主动抛出异常： abort(错误状态码)
 *  捕获某种异常统一处理：@app.errorhandler(code\_or\_exception=404)
 *  传入状态码或者异常类名都可以。
 *  处理异常的类必须传入一个值，e或者\_。\_表示内部不使用异常信息。

from flask import Flask, make_response, Response, request, redirect,abort
    
    # 需求主动捕获项目中的404的异常信息，统一到一个页面返回。
    
    app = Flask(__name__)
    
    @app.route('/login')
    def login():
        # 主动抛出异常
        # 参数：必须是http标准的错误状态码（200不可以）
        abort(404)
        return "主动抛出异常"
    
    # 传入状态码或者异常类：
    @app.errorhandler(code_or_exception=404)
    def error_404_handler(e):
        print(e)
        return redirect("http://err.www.mi.com/04.html")
    
    
    @app.errorhandler(code_or_exception=ZeroDivisionError)
    def errror_handler(_):
        # _表示不打印信息
        return "除零错误"
        
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8000, debug=True)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/12a7a3e1ed904e7da8eccceca2cf40ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201029220418105.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201029221406456.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20201030180212899.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20201030190138347.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20201030191301789.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/20201030191435962.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3,size_16,color_FFFFFF,t_70#pic_center
[2020103019251834.png_pic_center]: https://img-blog.csdnimg.cn/2020103019251834.png#pic_center
[2020103019271135.png_pic_center]: https://img-blog.csdnimg.cn/2020103019271135.png#pic_center
[20201030193838190.png_pic_center]: https://img-blog.csdnimg.cn/20201030193838190.png#pic_center
[20201030193851905.png_pic_center]: https://img-blog.csdnimg.cn/20201030193851905.png#pic_center