Flask框架学习笔记_1

虚拟环境说明

• 想在另一台电脑同步该虚拟环境中所安装的包

  • 首先把该电脑的虚拟环境中的包指定到一个文件中

    pip freeze > requirements.txt
    

  • 把该文件给需要同步的电脑，在那太电脑中先创建好一个虚拟环境

  • 同步

    pip install -r requirements.txt
    

Flask框架

简介 官方文档

• 它是一个轻量级的框架，只提供web框架的核心功能，比较的自由、灵活、高度定制
• 它本身相当于一个内核，其他几乎所有功能都要用到扩展，都需要第三方的扩展来实现
• Flask框架的核心：Werkzeug和Jinja2

Flask扩展包

• Flask-SQLalchemy：操作数据库
• Flask-migrate：管理迁移数据库
• Flask-Mail：邮件
• Flask-WTF：表单
• Flask-script：插入脚本
• Flask-Login：认证用户状态
• Flask-RESTful：开发REST API的工具
• Flask-Bootstrap：集成前端Twitter Bootstrap框架
• Flask-Moment：本地化日期和时间

安装

pip install flask==0.10.1

一个简单的Flask程序

# 导入Flask类
from flask import Flask

#创建flask的应用对象
app = Flask(__name__)

# 装饰器的作用是将路由映射到视图函数index
@app.route('/')
def index():
    '''定义视图函数'''
    return 'Hello World'

# Flask应用程序实例的run方法启动WEB服务器
if __name__ == '__main__':
    app.run()

• __name__：表示当前的模块的名字
• @app.route('/')：用装是器来实现路由的映射
• app.run()的参数，可以传递host、port和debug

创建APP对象

• 初始化参数：
  • static_url_path:
  • static_folder: 默认‘static’
  • template_folder: 默认‘templates’

Flask配置参数设置

• 法1：创建一个文件 config.cfg (文件名随意指定)，在里面设置配置，然后使用配置文件

  app.config.from_pyfile(“yourconfig.cfg”)
  

• 法2：使用对象配置参数，在程序里用一个类来定义配置参数

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

• 法3：直接操作config的字典对象

  app.config["DEBUG"] = True
  

在视图中读取配置参数

• 法1：app.config['xxx']、app.config.get('xxx') (前提是配置信息在同一程序中，还有尽量用get，不然若取不到的话会报错)

• 法2：若在模块中无法直接拿到app，可以用current_app，其用法与app 的用法一样

  from flask import aurrent_app
  aurrent_app.config.get("DEBUG")
  

视图函数的路由规则

• @app.route('/post', methods=['POST'])

  methods可以指定该url可以由什么方式请求，列表，可以写多个

• 查看flask中路由的信息：app.url_map，显示形式为下

  Map([<Rule '/' (HEAD, OPTIONS, GET) -> index>,
   <Rule '/python/<filename>' (HEAD, OPTIONS, GET) -> static>])
  
  

• 几种情况

  • ①同样的url，访问不同的视图函数

    当url和请求方式一样，谁在前面就访问哪个视图函数

  • 不同的url，访问相同的视图函数

    装饰器是可以叠加的，在同一视图函数上用不同的@app.route配置

• Flask中的反向解析

  from flask import redirect
  @app.route('/login')
  def login():
  	url = url_for('index')
      return redirect(url)   # 重定向
  
  

  url_for('index') 可以进行反向解析，index 是通过视图函数的名字找到视图对应的url路径

• 动态路由

  @app.route('/goods/<int:goods_id>')
  def goods_detail(goods_id)
  	pass
  
  

  int 是一个转换器，意思就是如127.0.0.1:5000/goods/12匹配到int类型就符合规则，就把匹配到的值赋值自己定义的goods_id这个变量，然后在定义视图函数时需传参goods_id来接受数据

  • 几种转换器
    • int：接受整数
    • float：同int，但接受的是浮点数
    • path：和默认的相似，但也接受斜线（默认就是普通的字符串规则，除了斜线）

• 自定义转换器

  • 1.用类的方法定义

    from werkzeug.routing import BaseConverter
    class RegexConverter(BaseConverter):
        """"""
        def __init__(self, url_map, regex):
            # 调用父类的初始化方法
            super(RegexConverter, self).__init__(url_map)
            # 将正则表达式的参数保存到对象的属性中，flask会去使用这个属性来进行路由的正则匹配
            self.regex = regex
    
    

  • 2.将自定义的转换器添加到flask的应用中

    app.url_map.converters["re"] = RegexConverter  # re为你给转换器定义的名字
    
    

  • 3.使用

    @app.route("/send/<re(r'1[34578]\d{9}'):mobile_num>")  # 因为自定义的是re的万用转换器，直接在里面写正则就好
    
    

    这种情况下，使用url_for()不仅需要传递视图函数的名字，还需mobile_num

    url = url_for("send_sms", mobile_num="18922222222")

获取请求参数

• request 中包含了前端发送过来的所有请求数据，是 Flask 中表示当前请求的 request 对象，request对象中保存了一次HTTP请求的一切信息

• request.form可以直接提取请求体中的表单格式的数据，是一个类字典的对象

  通过get方法只能拿到多个同名参数的第一个，getlist获取全部

  name = request.form.get("name")
  name_li = request.form.getlist("name")
  
  

• 如果是请求体的数据不是表单格式的（如json格式），可以通过request.data获取

• args是用来提取url中的参数（查询字符串）

• request 常用的属性

  属性	说明	类型
  data	记录请求的数据，并转为字符串
  form	记录请求中的表单数据	MultiDict
  args	记录请求中的查询参数	MultiDict
  cookies	记录请求中的cookie信息	Dict
  headers	记录请求中的报文头	EnvironHeaders
  method	记录请求中的HTTP请求方法	GET/POST
  url	记录请求的URL地址	string
  files	记录请求上传的文件

• 在视图函数中，可能对不同的请求方式会有不同的处理，这时就可以用

  if request.method == 'GET':
  	pass
  elif request.method == 'POST':
      pass
  
  

• 上传文件

  • 已上传的文件存储在内存或是文件系统中一个临时的位置，你可以通过请求对象的 files 属性访问它们。每个上传的文件都会存储在这个字典里。

  • request.files.get()可以接受前端上传的文件

    @app.route("/upload", methods=["POST"])
    def upload():
        """接受前端传送过来的文件"""
        file_obj = request.files.get("pic")
        if file_obj is None:
            # 表示没有发送文件
            return "未上传文件"
    
        # 直接使用上传的文件对象保存
        file_obj.save("./demo1.png")
        return "上传成功"
    
    

  自定义异常处理

  • abort()函数

    • 使用abort函数可以立即终止视图函数的执行，并可以返回给前端特定的信息

      from flask import Flask, request, abort, Response
      app = Flask(__name__)
      
      @app.route("/login", methods=["GET"])
      def login():
          # name = request.form.get()
          # pwd = request.form.get()
          name = ""
          pwd = ""
          if name != "zhangsan" or pwd != "admin":
              # 1 传递状态码信息, 必须是标准的http状态码
              abort(404)
              # # 2. 传递响应体信息
              # resp = Response("login failed")
              # abort(resp)
          return "login success"
      
      

  • 自定义异常处理

    # 定义错误处理的方法
    @app.errorhandler(404)
    def handle_404_error(err):
        """自定义的处理错误方法"""
        # 这个函数的返回值会是前端用户看到的最终结果
        return u"出现了404错误， 错误信息：%s" % err
    
    if __name__ == '__main__':
        app.run(debug=True)
    
    

    即这个函数回去处理404页面错误，这个函数的返回值会返回给前端

设置响应信息

• 使用元组返回自定义的响应信息，也可以使用字典

  @app.route("/index")
  def index():
      return "index page", 400, [("Name", "Fxh"), ("Age", "21")]
  
  

  index page：响应体

  400：状态码

  [("Name", "Fxh"), ("Age", "21")]：响应头

• 使用make_response 来构造响应信息

  @app.route("/index")
  def index():
  	resp = make_response("index page 2")
      resp.status = "999 说明信息"  # 设置状态码，后面为你对该状态码的说明信息
      resp.headers["Name"] = "Fxh"  # 设置响应头
      return resp
  
  

返回json数据的方法

• json就是字符串

• 法1：直接操控json模块

  import json
  @app.route("/index")
  def index():
      data = {'name':'fxh','age':21}
      json_str = json.dumps(data)
      return json_str, 200, {"Content-Type": "application/json"}
  
  

  • json.dumps(字典)------->Python字典转换为json字符串
  • json.loads(字符串)------>字符串转为Python字典

• 法2：使用 jsonify 返回 json 数据

  • jsonify帮助转为json数据，并设置响应头 Content-Type 为application/json

  • 可以把data当成参数传递给jsonify ，也可以传参时直接写

    return jsonify(data)
    #####
    return jsonify(name="sz", age=21)
    
    

cookie的使用

• 设置cookie

  from flask import Flask, make_response, request
  
  app = Flask(__name__)
  
  @app.route("/set_cookie")
  def set_cookie():
      resp = make_response("success")
      # 设置cookie, 默认有效期是临时cookie，浏览器关闭就失效
      resp.set_cookie("name", "fxh")
      # max_age设置有效期，单位：秒
      resp.set_cookie("name", "fxh", max_age=3600)
      # cookie的添加实则就是在响应头里添加字段，所以也可以直接写进响应头里
      resp.headers["Set-Cookie"] = "name=fxh; Expires=Sat, 18-Nov-2019 04:36:04 GMT; Max-Age=3600; Path=/"
      return resp
  
  

• 获取cookie

  @app.route("/get_cookie")
  def get_cookie():
      c = request.cookies.get("name")
      return c
  
  

• 删除cookie

  @app.route("/delete_cookie")
  def delete_cookie():
      resp = make_response("del success")
      # 删除cookie
      resp.delete_cookie("name")
      return resp
  
  

session

• 机制[外链图片转存失败(img-GXxqbQFo-1568046046739)((https://FXHao.github.io/images/posts/Flask/session机制.png)]

• session设置

  from flask import Flask, session, current_app
  app = Flask(__name__)
  
  # flask的session需要用到的秘钥字符串
  app.config["SECRET_KEY"] = "dhsodfhisfhosdhf29fy989"
  
  @app.route("/login")
  def login():
      # 设置session数据
      session["name"] = "fxh"
      session["mobile"] = "18611111111"
      return "login success"
  
  @app.route("/index")
  def index():
      # 获取session数据
      name = session.get("name")
      return "hello %s" % name
  
  

• session默认是储存在cookie里面的，也可以存在数据库、redis、文件、程序内存里，但如果存在程序内存中（在程序中定义一个全局变量存储），最后部署服务器时，在多个服务器之间，用户有可能在1号服务器登录，然后过了会又在2号服务器登录，而两个服务器的全局变量不是同步的，这时2号服务器就没有该用户刚登录时设置的session数据，当然这种情况也可以适当的解决，比如在nginx调度时可以给它一个规则，某个地区的用户分配到哪个服务器

上下文

• 相当于一个容器，保存了Flask程序运行过程中的一些信息

• 请求上下文：request和session都属于请求上下文对象

  • request：封装了HTTP请求的内容，针对的是http请求。如：user = request.args.get('user')，获取的是get请求的参数

  • session：用来记录请求会话中的信息，针对的是用户信息。如：session['name'] = user.id，可以记录用户信息，还可以通过session.get('name')获取用户信息

  • 在Django中，request是局部变量，所以每个对象请求时都是不同的，而在Flask中，request则是全局变量，它是如何区分request对象是哪个用户的呢？

    • 其实在Flask中，全局变量使用起来相当于线程局部变量，它会把建立一个request字典，然后用户A请求时，就建立一个线程A放进request中，然后线程A中保存着用户A请求发送的数据，这时如果又有一个用户B来请求时，就又会建立一个线程B来服务用户B

      request = {
          '线程A':{
              from:{'name':'xxx'}
              args:xxx
          }
          '线程B':{
              xxxx
          }
      }
      
      

• 应用上下文：current_app和g都属于应用上下文对象

  • current_app：表示当前运行程序文件的程序实例
  • g：处理请求时，用于临时存储的对象，每次请求都会重设这个变量

请求钩子

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

  装饰器	功能
  @app.before_first_request	在处理第一个请求前运行
  @app.before_request	在每次请求前运行
  @app.after_request	如果没有未处理的异常抛出，在每次请求后运行
  @app.teardown_request	在每次请求后运行，即使有未处理的异常抛出

• 请求钩子在每个视图函数被请求时都会执行（类似于Django中的中间件），也可以让钩子所装饰的函数根据不同的视图函数而执行不同的程序

  @app.teardown_request
  def handle_teardown_request(response):
      """在每次请求 (视图函数处理)之后都被执行， 无论视图函数是否出现异常，都被执行, 工作在非调试模式时 debug=False"""
      path = request.path
      if path == url_for("index"):
          print("在请求钩子中判断请求的视图逻辑: index")
      elif path == url_for("hello"):
          print("在请求钩子中判断请求的视图逻辑: hello")
      print("handle_teardown_request 被执行")
      return response
  
  

Flask-Script 扩展命令行

• 通过使用Flask-Script扩展，我们可以在Flask服务器启动的时候，通过命令行的方式传入参数。而不仅仅通过app.run()方法中传参

• 安装：pip install Flask-Script

• 使用：

  from flask import Flask
  from flask_script import Manager
  
  app = Flask(__name__)
  #创建Manger管理类对象
  manager = Manager(app)
  
  @app.route('/')
  def index():
      pass
  
  if __name__ == "__main__":
      manager.run()
  ###############
  # 这时启动就可以在终端中用下面命令启动
  python 该程序所在的文件名 runserver  # 后面可以加--help来查看参数
  
  

---

• 先写这么多吧，剩下的学完在继续写
• 加油吧，每天积累一点！！！！