小程序开发定制python--flask框架基础知识

1. 第一个 程序

  1. """
  2. 1.导入flask 类
  3. 2. 创建app对象
  4. 3.小程序开发定制自定义视图函数，小程序开发定制使用装饰器路由和视图函数绑定
  5. 4.使用app对象运行flask项目
  6. """
  7.  
  8. from flask import Flask
  9.  
  10. app = Flask(__name__)
  11.  
  12.  
  13. @app.route('/')
  14. def index():
  15.     return 'hello world'
  16.  
  17. if __name__ == '__main__':
  18.     print(app.url_map)     # 用于查询 url 路由路径--全部信息
  19.     app.run()     # http://127.0.0.1:5000/  默认端口：5000

2. 程序加载配置

在 Flask 小程序开发定制程序运行的时候，可以给 Flask 小程序开发定制设置相关配置，比如：配置 Debug 模式，小程序开发定制配置数据库连接地址等等，设置 Flask 小程序开发定制配置有以下三种方式：

  • 小程序开发定制小程序开发定制从配置对象中加载(常用)
    • app.config.from_object()
  • 小程序开发定制从配置文件中加载
    • app.config.from_pyfile()
  • 小程序开发定制从环境变量中加载(了解)
    • app.config.from_envvar()
  1. ## 从配置对象中加载，小程序开发定制创建配置的类 ##<小程序开发定制只介绍第一种>
  2. # 配置对象，小程序开发定制里面定义需要给 APP 添加的一系列配置
  3. class Config(object):
  4.     DEBUG = True
  5.  
  6.  
  7. # 创建 Flask 类的对象,指向程序所在的包的名称
  8. app = Flask(__name__)
  9.  
  10. # 从配置对象中加载配置
  11. app.config.from_object(Config)

读取配置：

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

注：Flask 应用程序将一些常用的配置设置成了应用程序对象的属性，也可以通过属性直接设置/获取某些配置：app.debug = True

app.run的参数

  • 可以指定运行的主机IP地址，端口，是否开启调试模式
  1.  
  2. app.run(host="0.0.0.0", port=5000, debug = True)

3. 路由基本定义

    修改@app.route()的参数达到修改访问url：
    目的：不同的url引导到对应的视图函数

     1. 指定路由地址：

  1. # 指定访问路径为 demo1
  2. @app.route('/demo1')
  3. def demo1():
  4.     return 'demo1'

      2. 给路由传参示例

  1. # 路由传递参数 -- 尖括号里面代表传递的参数
  2. (url:http://127.0.0.1:5000/user/zhangsan)
  3.  
  4. @app.route('/user/<user_id>')
  5. def user_info(user_id):
  6.     return 'hello %s' % user_id
  7.  
  8. # 指定参数的类型
  9. @app.route('/user/<int:user_id>')
  10. def user_info(user_id):
  11.     return 'hello %d' % user_id
  12.  
  13. # 指定请求方法 -- 注意：methods是一个列表。请求方法大小写均可。
  14. @app.route('/demo2', methods=['GET', 'POST'])
  15. def demo2():
  16.     # 直接从请求中取到请求方式并返回
  17.     return request.method

4. 获取请求参数

  • request：flask中代表当前请求的 request 对象
  • 作用：在视图函数中取出本次请求数据
  • 导入：from flask import request

常用的属性如下：

属性说明类型

data

request.json

request.get_json()

记录请求的数据，并转换为字符串

记录json 数据 -- post请求（字典）

*

dict

form记录请求中的表单数据-- post请求（表单数据）MultiDict

args

values

记录请求中的查询参数 -- get 请求参数MultiDict
cookies记录请求中的cookie信息Dict
headers记录请求中的报文头EnvironHeaders
method记录请求使用的HTTP方法GET/POST
url记录请求的URL地址string
files记录请求上传的文件*
  1. # 指定访问路径为 demo1
  2. @app.route('/demo1')
  3. def demo1():
  4.     a = request.args.get('a')
  5.     return 'demo1 %s' % a
  6.  
  7.  
  8. 获取请求中查询字符串
  9.  url:  http://127.0.0.1:5000/demo1?a=10

5. 返回响应

 当需要给客户端返回json类型的数据的时候，可以借助jsonify函数将python字典转换成json字符串(序列化)
语法格式：
    jsonify(字典)
作用：
    1.将字典转换成json字符串
    2.将返回值包装成resonse对象
    3.将数据类型设置成application/json格式

    扩展:  序列化:将python对象转换成json对象
            方法一:json_response = jsonify(my_dict)
            方法二:json_str = json.dumps(my_dict)

           反序列化:将json字符串数据转换成python对象
                   json.loads(json_str)

重定向
    概念：当你访问某一url路由的时候，不是给你引导到当前url对应的网页而是跳转到了另一个url对应的网页。
重定向语法：
    redirect(url地址)
拓展：
    1.一般先通过反向解析函数获取某一视图函数对应的url：url_for(视图函数名称,函数参数)
    2.然后再使用redirect(url)进行重定向


 状态码返回:  302 重定向
                      405 服务器请求错误

6. Cookie 与

cookie作用：
    状态保持，以键值对方式保存用户信息到`浏览器`。
    
特点：
    1.Cookie是由服务器端生成，发送给客户端浏览器。
    2.浏览器会将Cookie的key/value保存。
    3.下次请求同一网站时就发送该Cookie给服务器（前提是浏览器设置为启用cookie）
    4.Cookie基于域名安全，不同域名的Cookie是不能互相访问的

1.设置cookie:
 response.set_cookie(key, value, max_age=过期时长)
2.获取cookie:
 request.cookies.get(key, "")
3.删除cookie:
 response.delete_cookie(key)

  1. from flask import request, make_response, session
  2.  
  3. # cookie 的设置
  4. @app.route("/login")
  5. def set_cookie():
  6.     # 登陆成功，借助cookie 保存用户登陆信息
  7.     #1. 初始化响应对象，将字符串通过 make_response方法包装成响应对象
  8.     response = make_response("set cookie success")
  9.     #2. 借助响应对象，设置cookie键值对信息
  10.     response.set_cookie("username", "zhangsan", max_age=3600)
  11.     # 返回响应对象
  12.     return response
  13.     # return "set cookie success"

Session作用：
    状态保持，以键值对方式保存用户信息到`服务器`。

特点：
    1.在服务器端进行状态保持的方案就是Session
    2.以字典的方式将数据保存到服务器端。
    3.Session依赖于Cookie。(最终会返回session_id,需要借助cookie告知浏览器)

1.设置session:
 session["key"] = "value"
2.获取Session:
 session.get("key", "")
3.删除Session:
 session.pop("key", "")
注意点：使用session的时候要设置secret_key加密字符串，到时候session_id需要进行混淆加密处理;

 可以在 app.config 配置类中设置；
  或者直接      app.secret_key ="djfsjdfklj"

7. 请求勾子

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

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

  • before_first_request
    • 在处理第一个请求前执行
  • before_request
    • 在每次请求前执行
    • 如果在某修饰的函数中返回了一个响应，视图函数将不再被调用
  • after_request
    • 如果没有抛出错误，在每次请求后执行
    • 接受一个参数：视图函数作出的响应
    • 在此函数中可以对响应值在返回之前做最后一步修改处理
    • 需要将参数中的响应在此参数中进行返回
  • teardown_request：
    • 在每次请求后执行
    • 接受一个参数：错误信息，如果有相关错误抛出
  1. from flask import Flask
  2. from flask import abort
  3.  
  4. app = Flask(__name__)
  5.  
  6.  
  7. # 在第一次请求之前调用，可以在此方法内部做一些初始化操作
  8. @app.before_first_request
  9. def before_first_request():
  10.     print("before_first_request")
  11.  
  12.  
  13. # 在每一次请求之前调用，这时候已经有请求了，可能在这个方法里面做请求的校验
  14. # 如果请求的校验不成功，可以直接在此方法中进行响应，直接return之后那么就不会执行视图函数
  15. @app.before_request
  16. def before_request():
  17.     print("before_request")
  18.     # if 请求不符合条件:
  19.     #     return "laowang"
  20.  
  21.  
  22. # 在执行完视图函数之后会调用，并且会把视图函数所生成的响应传入,可以在此方法中对响应做最后一步统一的处理
  23. @app.after_request
  24. def after_request(response):
  25.     print("after_request")
  26.     response.headers["Content-Type"] = "application/json"
  27.     return response
  28.  
  29.  
  30. # 请每一次请求之后都会调用，会接受一个参数，参数是服务器出现的错误信息
  31. @app.teardown_request
  32. def teardown_request(e):
  33.     print("teardown_request")
  34.  
  35.  
  36. @app.route('/')
  37. def index():
  38.     return 'index'
  39.  
  40. if __name__ == '__main__':
  41.     app.run(debug=True)
  42.  
  43.  
  44. ==========================
  45. 在第1次请求时的打印：
  46. before_first_request
  47. before_request
  48. after_request
  49. teardown_request
  50. ==========================
  51. 在第2次请求时的打印：
  52. before_request
  53. after_request
  54. teardown_request

7. 上下文概念与Flask-Script扩展

上下文定义：
根据之前代码所做的操作以及下文即将要执行的逻辑，可以决定在当前时刻下可以使用到的变量，或者可以完成的事情。

Flask中有两种上下文：

from flask import Flask, request, session, current_app, g

1.请求上下文： request，session
2.应用上下文： current_app(app的别名)，g(全局的一个临时变量)
注意：不同的请求，会有不同的g对象全局变量，超出请求超出范围不能使用

Flask-Script：

作用：通过命令行的方式传入参数，启动Flask服务器,取代app.run()动态指明ip和端口。

  1. from flask import Flask
  2. from flask_script import Manager
  3.  
  4. app = Flask(__name__)
  5. # 把 Manager 类和应用程序实例进行关联
  6. manager = Manager(app)
  7.  
  8. @app.route('/')
  9. def index():
  10.     return '床前明月光'
  11.  
  12. if __name__ == "__main__":
  13.     manager.run()

集成 Flask-Script步骤:
    1.将app对象使用管理起来：
        manager = Manager(app)
    2.使用manager启动项目：
        manager.run()

命令：（本地pycharm 配置在 Paramenters 参数里）
    python 文件名称 runserver -h 127.0.0.1  -p 5000   -d
                              指明ip地址    指明端口号  开启debug模式

8. Blueprint

      blueprint蓝图作用：分模块开发

蓝图的基本使用：

1.导入蓝图类

2.创建蓝图对象

3.使用蓝图对象装饰视图函数

4.将蓝图对象注册到app上

app作用： 整个项目

蓝图作用：整个模块

缺点：如果在应用创建后，你撤销注册一个蓝图，那么就必须销毁整个应用对象。

  1. ============= admin.py 文件 ======================
  2. # 导入蓝图类
  3. from flask import Blueprint
  4.  
  5. # 创建蓝图对象。
  6. # 参数1：蓝图名称    参数2：__name__
  7. admin_bule=Blueprint('admin_blue',__name__)
  8.  
  9. # 使用蓝图对象装饰视图函数
  10. @admin_bule.route('/admin_url')
  11. def admin_home():
  12.     return 'admin_home'
  13.  
  14. ============ profile.py 文件 =====================
  15. # 导入蓝图类
  16. from flask import Blueprint
  17.  
  18. # 创建蓝图对象。
  19. # 参数1：蓝图名称    参数2：__name__
  20. profile_bp = Blueprint("profiles", __name__)
  21.  
  22. # 使用蓝图对象装饰视图函数
  23. @profile_bp.route('/profile/info')
  24. def profile():
  25.     return "profile"
  26.  
  27.  
  28.  
  29. ============= app.py 文件 ========================
  30. # 导入蓝图对象
  31. from admin import admin_bule
  32. from profile import profile_bp
  33. from flask import Flask
  34.  
  35. app = Flask(__name__)
  36.  
  37. @app.route('/')
  38. def hello_world():
  39.     return 'Hello World!'
  40.  
  41. # 在应用对象上注册这个蓝图对象
  42. # 注册蓝图使用 register_blueprint 方法 ，url_prefix表示访问此蓝图的 url 前缀；
  43. # 默认为：/
  44. app.register_blueprint(admin_bule,url_prefix='/admin')
  45. app.register_blueprint(profile_bp)
  46.  
  47. if __name__ == '__main__':
  48.     print(app.url_map)
  49.     app.run()
  50.  
  51. ===========================
  52. 请求url:  http://127.0.0.1:5000/admin/admin_url
  53.           http://127.0.0.1:5000/profile/info
  54.           http://127.0.0.1:5000/

blueprint蓝图(目录结构)

总结:
    web开发都需要分模块开发，每一个模块就是一个单独的目录。
    
实现蓝图目录结构步骤：
    1.模块的__init__.py文件中创建 `蓝图对象`。
    2.views.py文件使用蓝图对象装饰视图函数。
    3.在回到__init__.py文件中导入views文件中内容，与模块产生关联。
    4.调用app的register_blueprint方法注册蓝图

循环导入问题：
    解决方案：延迟导入

网站建设定制开发 软件系统开发定制 定制软件开发 软件开发定制 定制app开发 app开发定制 app开发定制公司 电商商城定制开发 定制小程序开发 定制开发小程序 客户管理系统开发定制 定制网站 定制开发 crm开发定制 开发公司 小程序开发定制 定制软件 收款定制开发 企业网站定制开发 定制化开发 android系统定制开发 定制小程序开发费用 定制设计 专注app软件定制开发 软件开发定制定制 知名网站建设定制 软件定制开发供应商 应用系统定制开发 软件系统定制开发 企业管理系统定制开发 系统定制开发