• 测试开发：10分钟Flask快速入门【建议收藏】

    一、Flask介绍

    Flask是一个基于Python开发并且依赖jinja2模板和Werkzeug WSGI服务的一个微型框架，对于Werkzeug本质是Socket服务端，其用于接收http请求并对请求进行预处理，然后触发Flask框架，开发人员基于Flask框架提供的功能对请求进行相应的处理，并返回给用户，如果要返回给用户复杂的内容时，需要借助jinja2模板来实现对模板的处理，即：将模板和数据进行渲染，将渲染后的字符串返回给用户浏览器。

    “微”(micro) 并不表示你需要把整个 Web 应用塞进单个 Python 文件（虽然确实可以 ），也不意味着 Flask 在功能上有所欠缺。微框架中的“微”意味着 Flask 旨在保持核心简单而易于扩展。Flask 不会替你做出太多决策——比如使用何种数据库。而那些 Flask 所选择的——比如使用何种模板引擎——则很容易替换。除此之外的一切都由可由你掌握。如此，Flask 可以与您珠联璧合。

    默认情况下，Flask 不包含数据库抽象层、表单验证，或是其它任何已有多种库可以胜任的功能。然而，Flask 支持用扩展来给应用添加这些功能，如同是 Flask 本身实现的一样。众多的扩展提供了数据库集成、表单验证、上传处理、各种各样的开放认证技术等功能。Flask 也许是“微小”的，但它已准备好在需求繁杂的生产环境中投入使用。

    pip3 install flask

    二、基本使用

    示例：

    1. from flask import Flask
    2. app = Flask(__name__)
    3.  
    4. @app.route('/')
    5. def hello_world():
    6.     return 'Hello World!'
    7.  
    8. if __name__ == '__main__':
    9.     app.run()

    1.实例化Flask对象

    1. app = Flask(__name__)    # 这是实例化一个Flask对象，最基本的写法
    2.  
    3. # 但是Flask中还有其他参数，以下是可填的参数，及其默认值
    4. def __init__(self, import_name, static_path=None, static_url_path=None,
    5.                  static_folder='static', template_folder='templates',
    6.                  instance_path=None, instance_relative_config=False,
    7.                  root_path=None):

    • template_folder：模板所在文件夹的名字

    • root_path：可以不用填，会自动找到，当前执行文件，所在目录地址

    • 在return render_template时会将上面两个进行拼接，找到对应的模板地址

    • static_folder：静态文件所在文件的名字，默认是static，可以不用填

    • static_url_path：静态文件的地址前缀，写成什么，访问静态文件时，就要在前面加上这个

    app = Flask(__name__,template_folder='templates',static_url_path='/xxxxxx')

    • instance_path和instance_relative_config是配合来用的,这两个参数是用来找配置文件的，当用app.config.from_pyfile('settings.py')这种方式导入配置文件的时候会用到。

    • instance_relative_config：默认为False，当设置为True时，from_pyfile会从instance_path指定的地址下查找文件。

    • instsnce_path：指定from_pyfile查询文件的路径，不设置时，默认寻找和app.run()的执行文件同级目录下的instance文件夹；如果配置了instance_path（注意需要是绝对路径），就会从指定的地址下里面的文件。

    2、绑定路由关系的两种方式

    1. #方式一
    2.     @app.route('/index.html',methods=['GET','POST'],endpoint='index')
    3.     def index():
    4.         return 'Index'
    5.         
    6. #方式二
    7. def index():
    8.     return "Index"
    9.  
    10. self.add_url_rule(rule='/index.html', endpoint="index", view_func=index, methods=["GET","POST"])    #endpoint是别名
    11. or
    12. app.add_url_rule(rule='/index.html', endpoint="index", view_func=index, methods=["GET","POST"])
    13. app.view_functions['index'] = index
    14.

    添加路由关系的本质：将url和视图函数封装成一个Rule对象，添加到Flask的url_map字段中。

    3、Flask中装饰器应用

    1. from flask import Flask,render_template,request,redirect,session
    2. app = Flask(__name__)
    3. app.secret_key = "mikezhou_talk"   # 设置session时，必须要加盐，否则报错
    4.  
    5. def wrapper(func):
    6.     def inner(*args,**kwargs):
    7.         if not session.get("user_info"):
    8.             return redirect("/login")
    9.         ret = func(*args,**kwargs)
    10.         return ret
    11.     return inner
    12.  
    13. @app.route("/login",methods=["GET","POST"])  # 指定该路由可接收的请求方式，默认为GET
    14. def login():
    15.     if request.method=="GET":
    16.         return render_template("login.html")
    17.     else:
    18.         # print(request.values)   #这个里面什么都有，相当于body
    19.         username = request.form.get("username")
    20.         password = request.form.get("password")
    21.         if username=="haiyan" and password=="123":
    22.             session["user_info"] = username
    23.             # session.pop("user_info")  #删除session
    24.             return redirect("/index")
    25.         else:
    26.             # return render_template("login.html",**{"msg":"用户名或密码错误"})
    27.             return render_template("login.html",msg="用户名或者密码错误")
    28.  
    29. @app.route("/index",methods=["GET","POST"])
    30. @wrapper    #自己定义装饰器时，必须放在路由的装饰器下面
    31. def index():
    32.     # if not session.get("user_info"):
    33.     #     return redirect("/login")
    34.     return render_template("index.html")
    35.  
    36.  
    37. if __name__ == '__main__':
    38.     app.run(debug=True) 

    debug = True 是指进入调试模式，服务器会在 我们的代码修改后， 自动重新载入，有错误的话会提醒，每次修改代码后就不需要再手动重启。

    三、配置文件

    flask中的配置文件是一个flask.config.Config对象（继承字典）,默认配置为：

    1.  {
    2.         'DEBUG':                                get_debug_flag(default=False),  是否开启Debug模式
    3.         'TESTING':                              False,                          是否开启测试模式
    4.         'PROPAGATE_EXCEPTIONS':                 None,                          
    5.         'PRESERVE_CONTEXT_ON_EXCEPTION':        None,
    6.         'SECRET_KEY':                           None,
    7.         'PERMANENT_SESSION_LIFETIME':           timedelta(days=31),
    8.         'USE_X_SENDFILE':                       False,
    9.         'LOGGER_NAME':                          None,
    10.         'LOGGER_HANDLER_POLICY':               'always',
    11.         'SERVER_NAME':                          None,
    12.         'APPLICATION_ROOT':                     None,
    13.         'SESSION_COOKIE_NAME':                  'session',
    14.         'SESSION_COOKIE_DOMAIN':                None,
    15.         'SESSION_COOKIE_PATH':                  None,
    16.         'SESSION_COOKIE_HTTPONLY':              True,
    17.         'SESSION_COOKIE_SECURE':                False,
    18.         'SESSION_REFRESH_EACH_REQUEST':         True,
    19.         'MAX_CONTENT_LENGTH':                   None,
    20.         'SEND_FILE_MAX_AGE_DEFAULT':            timedelta(hours=12),
    21.         'TRAP_BAD_REQUEST_ERRORS':              False,
    22.         'TRAP_HTTP_EXCEPTIONS':                 False,
    23.         'EXPLAIN_TEMPLATE_LOADING':             False,
    24.         'PREFERRED_URL_SCHEME':                 'http',
    25.         'JSON_AS_ASCII':                        True,
    26.         'JSON_SORT_KEYS':                       True,
    27.         'JSONIFY_PRETTYPRINT_REGULAR':          True,
    28.         'JSONIFY_MIMETYPE':                     'application/json',
    29.         'TEMPLATES_AUTO_RELOAD':                None,
    30.     }

    方式一：

    app.config['DEBUG'] = True

    由于Config对象本质上是字典，所以还可以使用app.config.update(...)

    方式二：

    1. app.config.from_pyfile("python文件名称")
    2. # 如：python文件名称为：settings.py，内容为DEBUG = True
    3. app.config.from_pyfile("settings.py")
    4.  
    5. # 或者
    6. app.config.from_object("python类或类的路径")
    7. app.config.from_object('pro_flask.settings.TestingConfig')
    8.  
    9. # settings.py文件中的内容为：
    10. class Config(object):
    11.        DEBUG = False
    12.        TESTING = False
    13.        DATABASE_URI = 'sqlite://:memory:'
    14.  
    15. class ProductionConfig(Config):
    16.       DATABASE_URI = 'mysql://user@localhost/foo'
    17.  
    18. class DevelopmentConfig(Config):
    19.       DEBUG = True
    20.  
    21. class TestingConfig(Config):
    22.       TESTING = True

    四、路由系统

    1.可传入参数：

    1. @app.route('/user/')   #常用的,不加参数的时候默认是字符串形式
    2. @app.route('/post/')  #常用的,指定int，说明是整型的
    3. @app.route('/post/')
    4. @app.route('/post/')
    5. @app.route('/login', methods=['GET', 'POST'])

    2.反向生成URL：url_for

    1. from flask import Flask, url_for
    2.  
    3. @app.route('/index',endpoint="index")  #endpoint是别名,相当于django中的name
    4. def index():
    5.     v = url_for("index")
    6.     print(v)
    7.     return "index"
    8.  
    9. @app.route('/test/',endpoint="test")  #endpoint是别名
    10. def test(nid):
    11.     v = url_for("test",nid=nid)
    12.     print(v)
    13.     return "index2"

    3.自定制正则路由匹配

    扩展Flask的路由系统，让他支持正则,这个类必须这样写，必须去继承BaseConverter

    1.     from flask import Flask,url_for
    2.     from werkzeug.routing import BaseConverter
    3.     app = Flask(__name__)
    4.  
    5.     # 定义转换的类  
    6.     class RegexConverter(BaseConverter):
    7.         """
    8.         自定义URL匹配正则表达式
    9.         """
    10.  
    11.         def __init__(self, map, regex):
    12.             super(RegexConverter, self).__init__(map)
    13.             self.regex = regex
    14.  
    15.         def to_python(self, value):
    16.             """
    17.             路由匹配时，匹配成功后传递给视图函数中参数的值
    18.             :param value: 
    19.             :return: 
    20.             """
    21.             return int(value)
    22.  
    23.         def to_url(self, value):
    24.             """
    25.             使用url_for反向生成URL时，传递的参数经过该方法处理，返回的值用于生成URL中的参数
    26.             :param value: 
    27.             :return: 
    28.             """
    29.             val = super(RegexConverter, self).to_url(value)
    30.             return val
    31.  
    32.     # 添加到converts中
    33.     app.url_map.converters['regex'] = RegexConverter
    34.  
    35.     # 进行使用
    36.     @app.route('/index/',endpoint='xx')
    37.     def index(nid):
    38.         url_for('xx',nid=123) 
    39.         return "Index"
    40.  
    41.     if __name__ == '__main__':
    42.         app.run()

    五、视图函数

    1、方法视图及其使用

    利用视图函数实现不同的请求执行不同的逻辑时比较复杂，需要在视图函数函数中进行判断；如果利用方法视图实现就比较简单

    1. @app.route('/test/', methods=['GET', 'POST'])
    2. def test():
    3.     if request.method == 'GET':
    4.         # 做GET的事情
    5.         pass
    6.     elif request.method == 'POST':
    7.         # 做POST的事情
    8.         pass
    9.     return '测试'

    2、Flask中的CBV和FBV

    1. def auth(func):
    2.     def inner(*args, **kwargs):
    3.         result = func(*args, **kwargs)
    4.         return result
    5.     return inner
    6.  
    7. class IndexView(views.MethodView):
    8.     # methods = ['POST']  #只允许POST请求访问
    9.     decorators = [auth,]  # 如果想给所有的get,post请求加装饰器，就可以这样来写，也可以单个指定
    10.  
    11.     def get(self):   #如果是get请求需要执行的代码
    12.         v = url_for('index')
    13.         print(v)
    14.         return "GET"
    15.  
    16.     def post(self):  #如果是post请求执行的代码
    17.         return "POST"
    18.  
    19. app.add_url_rule('/index', view_func=IndexView.as_view(name='index'))  #name即FBV中的endpoint，指别名
    20.  
    21. if __name__ == '__main__':
    22.     app.run()

    六、模板语法

    Flask使用的是Jinja2模板，所以其语法和Django无太大差别，Flask中模板里面，执行函数时，需要带（）才执行。

    1.为了防止xss攻击，加了验证，所以页面上显示字符串的形式，解决办法，有两种方法

    方法一：在后端使用Markup，等价于Django里的mark_safe。

     v = Markup("<input type='text' />")

    方法二：在前端使用safe

    1. {{ v1|safe }}
    2.

    2.flask中模板语法不提示，解决办法

    七、Session

    除请求对象之外，还有一个 session 对象。它允许你在不同请求间存储特定用户的信息。它是在 Cookies 的基础上实现的，并且对 Cookies 进行密钥签名要使用会话，你需要设置一个密钥。

    • 设置：session['username'] ＝ 'xxx'

    • 删除：session.pop('username', None)

    1. from flask import Flask,url_for,session
    2.  
    3. app = Flask(__name__)
    4. app.secret_key = "mikezhou_talk"
    5. app.config['SESSION_COOKIE_NAME'] = 'session_lvning'  #设置session的名字
    6.  
    7. @app.route('/index/')
    8. def index(nid):
    9.     #session本质上操作的是字典， 所有对session操作的方法与字典方法相同
    10.     #session的原理：如果下一次访问的时候带着随机字符串，会把session里面对应的
    11.     # 值拿到内存，假设session保存在数据库，每执行一次链接一次数据库，每次都要时时更新的话，会非常损耗数据库的效率
    12.     session["xxx"] = 123
    13.     session["xxx2"] = 123
    14.     session["xxx3"] = 123
    15.     session["xxx4"] = 123
    16.     del session["xxx2"]  #在这删除了，真正存储的时候是没有xxx2的
    17.     return "ddsf"
    18.  
    19. if __name__ == '__main__':
    20.     app.run()

    八、蓝图（flask中多py文件拆分都要用到蓝图）

    如果代码非常多，要进行归类。不同的功能放在不同的文件，吧相关的视图函数也放进去。蓝图也就是对flask的目录结构进行分配（应用于小，中型的程序）

    蓝图用于为应用提供目录划分(小中型项目)：

    manage.py

    1. import fcrm
    2. if __name__ == '__main__':
    3.     fcrm.app.run()

    init.py(只要一导入fcrm就会执行__init__.py文件)

    1. from flask import Flask
    2. #导入accout 和order
    3. from fcrm.views import accout
    4. from fcrm.views import order
    5. app = Flask(__name__)
    6. print(app.root_path)  #根目录
    7.  
    8. app.register_blueprint(accout.accout)  #把蓝图注册到app里面，accout.accout是创建的蓝图对象
    9. app.register_blueprint(order.order)

    accout.py

    1. from flask import  Blueprint,render_template
    2. accout = Blueprint("accout",__name__)
    3.  
    4. @accout.route('/accout')
    5. def xx():
    6.     return "accout"
    7.  
    8. @accout.route("/login")
    9. def login():
    10.     return render_template("login.html")

    order.py

    1. from flask import Blueprint
    2. order = Blueprint("order",__name__)
    3.  
    4. @order.route('/order')
    5. def register():   
    6.     return "order

    中大型项目结构：

    注意：蓝图中的视图函数的名字不能和蓝图对象的名字一样！！！

    其他：

    • 蓝图URL前缀：xxx = Blueprint('account', name,url_prefix='/xxx')

    • 蓝图子域名：xxx = Blueprint('account', name,subdomain='admin')

      学习资源分享

      最后感谢每一个认真阅读我文章的人，看着粉丝一路的上涨和关注，礼尚往来总是要有的，虽然不是什么很值钱的东西，如果你用得到的话可以直接拿走

      这些资料，对于做【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴我走过了最艰难的路程，希望也能帮助到你！凡事要趁早，特别是技术行业，一定要提升技术功底。希望对大家有所帮助…….【下方】

  • 相关阅读:
    基于tensorflow的ResNet50V2网络识别动物
    【前端笔记】HBuilderX通过微信开发者工具预览打开不了探索过程
    ES6 入门教程 15 Proxy 15.2 Proxy 实例的方法 15.2.10 ownKeys() ~ 15.2.12 setPrototypeOf()
    C++ Tutorials: C++ Language: Classes: Polymorphism
    【华为OD机试真题 JS】猜密码
    消息机制篇——初识消息与消息队列
    EDUCoder编程练习题解（编辑与调试）
    华秋电子众多代理线的车规级新品亮相汽车电子研讨会现场
    MySQL的锁
    针对舆情分析近五年参考文献的分析报告
  • 原文地址：https://blog.csdn.net/m0_58026506/article/details/126405965