您的位置: 首页  >  IT文章  >  Flask介绍

Flask介绍

分类: IT文章 • 2024-04-22 16:56:58

原文地址:http://www.cnblogs.com/wupeiqi/articles/5341480.html

Flask是一个基于Python开发并且依赖jinja2模板和Werkzeug WSGI服务的一个微型框架.

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

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

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

另外的介绍:

Flask诞生于2010年，是Armin ronacher（人名）用 Python 语言基于 Werkzeug 工具箱编写的轻量级Web开发框架。

Flask 本身相当于一个内核，其他几乎所有的功能都要用到扩展（邮件扩展Flask-Mail，用户认证Flask-Login，数据库Flask-SQLAlchemy），都需要用第三方的扩展来实现。比如可以用 Flask 扩展加入ORM、窗体验证工具，文件上传、身份验证等。Flask 没有默认使用的数据库，你可以选择 MySQL，也可以用 NoSQL。

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

Flask常用扩展包：

  • Flask-SQLalchemy：操作数据库；
  • Flask-script：插入脚本；
  • Flask-migrate：管理迁移数据库；
  • Flask-Session：Session存储方式指定；
  • Flask-WTF：表单；
  • Flask-Mail：邮件；
  • Flask-Bable：提供国际化和本地化支持，翻译；
  • Flask-Login：认证用户状态；
  • Flask-OpenID：认证；
  • Flask-RESTful：开发REST API的工具；
  • Flask-Bootstrap：集成前端Twitter Bootstrap框架；
  • Flask-Moment：本地化日期和时间；
  • Flask-Admin：简单而可扩展的管理接口的框架

安装:pip install flask

简单示例:

 1 from flask import Flask
 2 
 3 # 创建一个flask的应用程序,名字叫app
 4 # flask对象的名字 = Flask(__name__)
 5 # app可以随意起名字
 6 # __name__:表示模块名
 7 
 8 app = Flask(__name__)
 9 
10 """
11 通过装饰器,设置请求的路由
12 路由:就是一个url的地址,或者在java中也叫做接口
13 语法:@flask对象的名字.route("路径")
14 注意:app是对象的名字,名字可以随意取
15 @app.route('/aaa'):参数必须以/开头,否则会报错  ValueError: urls must start with a leading slash
16 def index():def表示定义一个函数,index是函数名字 函数名字随意取
17 """
18 @app.route('/')
19 def index():
20     """写我们的业务逻辑"""
21     # return表示展示页面,渲染页面,渲染就是展示的意思
22     return "我是第一个flask应用程序"
23 
24 
25 # 判断是否是入口
26 # 表示入口函数,固定语法
27 if __name__ == '__main__':
28     # 启动应用程序
29     app.run()

初始化参数介绍:

 1 from flask import Flask
 2 
 3 """
 4 查看参数的快捷键:ctrl + p
 5 static_path='xxx':静态路径,为了向下兼容,有些低版本使用的是这个
 6 static_url_path='xxx':url路径.表示的也是静态路径,
 7 表示的是一个意思,目的是为了向下兼容,表示静态文件
 8 static_folder='static',表示静态文件夹,系统默认叫static,里面存放静态文件,比如图片等等
 9 template_folder='teplates':模板文件夹,里面存放HTML文件
10 """
11 app = Flask(__name__, static_path=None, static_url_path=None, static_folder='static',template_folder='templates')
12 
13 
14 @app.route("/")  # 千万注意:是/    不是.是斜杠/
15 def index():
16     return "index page"
17 
18 
19 if __name__ == '__main__':
20     app.run()
21 """
22 lsof -i 5000:监听5000端口
23 kill -9 4728: 杀死5000端口的应用PID
24 
25 PID是进程id
26 
27 加载方式:
28 from_object   对象
29 from_pyfile   文件
30 from_envvar   环境变量
31 """
View Code

 对象方式加载配置文件:

 1 """
 2 起名字不要用中文
 3 """
 4 from flask import Flask
 5 
 6 app = Flask(__name__)
 7 
 8 
 9 class Config(object):
10     """创建一个配置类,名字叫Config,名字随便取"""
11     # 开启调试模式,调试模式为True
12     # 自下而上找错误
13     # 加载配置文件的好处:可以看到具体的错误信息,自动定位到错误的位置
14     DEBUG = True
15     # 自定义参数,参数不可以小写.只能是大写
16     # 大小写切换快捷键:ctrl + shift +u
17     ITCAST = "python"
18 
19 
20 # flask程序 从对象加载配置文件,配置文件来自Config这个对象
21 app.config.from_object(Config)
22 
23 
24 @app.route("/")
25 def index():
26     # a = 1 / 0
27     # 如果是自定义的参数,就需要自己取
28     # 如果从对象中取自定义的值,必须从对象读取,不能从文件读取
29     print(app.config.get('ITCAST'))
30     return 'index page'
31 
32 
33 if __name__ == '__main__':
34     app.run()
View Code

文件方式加载配置文件:

注意:先要在同级目录下创建一个config.cfg文件

 1 from flask import Flask
 2 
 3 app = Flask(__name__)
 4 
 5 
 6 class Config(object):
 7     """创建一个配置类,名字叫Config,名字随便取"""
 8     # 开启调试模式,调试模式为True
 9     # 自下而上找错误
10     # 加载配置文件的好处:可以看到具体的错误信息,自动定位
11     DEBUG = True
12 
13 
14 # flask程序 从文件加载配置文件
15 # 从对象加载必须 掌握,文件加载也得会
16 # 从对象加载的参数里面传入的是对象
17 # 从文件加载的参数里面传入的是文件名,是字符串类型,有引号
18 app.config.from_pyfile("config.cfg")
19 
20 
21 @app.route("/")
22 def index():
23     a = 1 / 0
24     return 'index page'
25 
26 
27 if __name__ == '__main__':
28     app.run()
View Code

run()参数:

 1 from flask import Flask
 2 
 3 app = Flask(__name__)
 4 
 5 
 6 @app.route('/')
 7 def index():
 8     a = 1/0
 9     return 'index page'
10 
11 
12 if __name__ == '__main__':
13     """
14     修改ip地址:
15     第一个参数是ip地址,
16     第二个是端口号,
17     第三个是开启调试模式(和之前的DEBUG是一样的功能,
18     这里是系统为了方便写在这里的.开发的时候需要自己写)
19     
20     一般不建议修改,就使用这个默认的值就好
21     """
22     app.run(host='192.168.14.27', port=9000, debug=True)
View Code

开启debug=True模式后,详细的报错信息就会展示在控制台.

 路由系统:

常用路由系统有以上五种，所有的路由系统都是基于下面的对应关系来处理：

 1 #: the default converter mapping for the map.
 2 DEFAULT_CONVERTERS = {
 3     'default':          UnicodeConverter,
 4     'string':           UnicodeConverter,
 5     'any':              AnyConverter,
 6     'path':             PathConverter,
 7     'int':              IntegerConverter,
 8     'float':            FloatConverter,
 9     'uuid':             UUIDConverter,
10 }

自定义转换器进行正则匹配:

 1 """
 2 之前只是限制数据类型,今天限制更多了.
 3 限制位数,每一位的数据类型等
 4 """
 5 from flask import Flask
 6 
 7 # routing 和路由相关的都在这里  第一步:
 8 from werkzeug.routing import BaseConverter
 9 """
10 转换器:converter
11 """
12 
13 app = Flask(__name__)
14 
15 
16 # 需要自定义转换器,通过正则方式进行自定义转换器,
17 # alt+enter快捷键就是进行导包  第二步:继承
18 class RegBaseConverter(BaseConverter):
19     # 表示限制的数据类型是数字,并且只能是5位,regex不能随便取,只能是regex,父类中定义好了
20     regex = 'd{5}'
21 
22 
23 # app.url_map得到所有的url地址(也就是路由)
24 # converters 表示转换器
25 # 自定义转换器,那么需要给自定义转换器起一个名字.注意:自己取的名字不能和系统的重名
26 # 把我们自定义的转换器放到converters这个转换器的集合里面  第三步:添加到转换器字典中
27 app.url_map.converters['aaaaaa'] = RegBaseConverter
28 
29 
30 # 限制数据类型是整型,只能限制数据类型.不能限制参数的位数.不好用.
31 # <aaaaaa:index_id>:进行替换,aaaaaa在这里就代表上面的正则表达式  第四步:使用
32 @app.route('/index/<aaaaaa:index_id>')
33 def index(index_id):
34     return 'index=%s' % index_id
35 
36 
37 if __name__ == '__main__':
38     app.run()
39 """
40 DEFAULT_CONVERTERS = {
41     'default':          UnicodeConverter,
42     'string':           UnicodeConverter,
43     'any':              AnyConverter,
44     'path':             PathConverter,
45     'int':              IntegerConverter,
46     'float':            FloatConverter,
47     'uuid':             UUIDConverter,
48 }
49 
50 一共6种转换器,前面两种是一样的.默认的是接收所有的和字符型一样
51 """
View Code

更专业的解答:https://segmentfault.com/q/1010000000125259

模板:

1、模板的使用

Flask使用的是Jinja2模板，所以其语法和Django无差别

2、自定义模板方法

Flask中自定义模板方法的方式和Bottle相似，创建一个函数并通过参数的形式传入render_template，如：

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>模板</title>
 6 </head>
 7 <body>
 8 <h1>获取到后台传来的数据:</h1>
 9 {#    {{ 变量名 }} 表示模板文件的语法,用来获取后端传来的变量   #}
10 {#    变量.键 的方式获取键对应的值 只要是字典格式的数据,获取key对应的value
11 都是采用对象/变量 .key的方式
12 #}
13 {#使用p标签之后,输出显示就是一行一行的显示#}
14 <p>名字:{{ data_obj.name }}</p>
15 <p>年龄{{ data_obj.age }}</p>
16 <p>地址:{{ data_obj.address }}</p>
17 <p>列表数据:{{ data_obj.my_list }}</p>
18 <p>字典中的城市数据:{{ data_obj.my_dict.city }}</p>
19 </body>
20 </html>

对应的后台.py文件:

 1 from flask import Flask, render_template
 2 
 3 app = Flask(__name__)
 4 
 5 """
 6 模板传递数据:
 7 注意:
 8 模板其实是一个包含响应文本的文件.
 9 本质就是一个响应的文件.记住:是文件,文件
10 误区:模板就是HTML.  
11 
12 作用:
13 1.降低耦合度,更好的控制代码
14 """
15 
16 
17 @app.route('/login')
18 def index():
19     # 业务逻辑已实现
20     # 处理用户名,密码
21     data = {
22         'name': 'libin',
23         'age': 56,
24         'address': 'USA',
25         'my_list': [1, 2, '45'],
26         'my_dict': {'city': 'sz'}
27     }
28     # 第一个参数是模板文件的名字,
29     # 第二个参数是需要传递到文件上面的数据,前面参数是占位符,后面的是变量的名字
30     return render_template('demo1.html', data_obj=data)
31 
32 
33 if __name__ == '__main__':
34     app.run()
View Code

公共组件:

1、请求

对于Http请求，Flask会讲请求信息封装在request中(werkzeug.wrappers.BaseRequest)，提供的如下常用方法和字段以供使用：

 1 request.method
 2 request.args
 3 request.form
 4 request.values
 5 request.files
 6 request.cookies
 7 request.headers
 8 request.path
 9 request.full_path
10 request.script_root
11 request.url
12 request.base_url
13 request.url_root
14 request.host_url
15 request.host

常用的介绍:

Flask介绍

args参数:

 1 # ------------------------------args参数-------------------
 2 """
 3 args:就是get请求时url后面加?的后面的数据
 4 """
 5 from flask import Flask, request
 6 
 7 app = Flask(__name__)
 8 
 9 
10 @app.route('/index', methods=['GET', 'POST'])
11 def index():
12     # ?号后面的数据
13     # request.args :获取到?后面的数据
14     city = request.args.get('city')
15     print(city)
16     return 'index'
17 
18 
19 if __name__ == '__main__':
20     app.run()

form表单数据:

 1 """
 2 request获取数据
 3 """
 4 # -------------------form表单-------------------------
 5 from flask import Flask, request
 6 
 7 app = Flask(__name__)
 8 
 9 
10 @app.route('/index', methods=['GET', 'POST'])
11 def index():
12     print('前端请求的url地址:', request.url)
13     """所有的请求数据都是封装在request里面"""
14     # request.form:获取到表单数据
15     # request.form.get():获取到表单里面具体的某一个数据
16     name = request.form.get('name')
17     pwd = request.form.get('pwd')
18     return 'name=%s,pwd=%s' % (name, pwd)
19 
20 
21 if __name__ == '__main__':
22     app.run()

files多媒体数据:

 1 # -----------------------files多媒体-------------------
 2 from flask import Flask, request
 3 
 4 app = Flask(__name__)
 5 
 6 
 7 # 上传图片,只能选POST方式
 8 @app.route('/', methods=['POST'])
 9 def index():
10     # request.files 获取多媒体数据,比如拿到图片
11     pic = request.files.get('pic')
12     # pic.save('./bb.png') :保存图片,上传图片
13     pic.save('./bb.png')
14     return '上传成功!'
15 
16 
17 if __name__ == '__main__':
18     app.run()

返回JSON格式数据:

from flask import Flask, jsonify

app = Flask(__name__)


# -------------------就是返回给客户端呈现的数据是json格式的-----------
@app.route('/')
def index():
    data = {
        "name": "python",
        "age": 29
    }
    # -------------jsonify方式-------------------------------------------
    return jsonify(data)


if __name__ == '__main__':
    app.run()

原生方式返回JSON:

# ------------------------原生方式:json.dumps()----------------------------
from flask import Flask
import json

app = Flask(__name__)


@app.route('/')
def index():
    data = {
        "name": "python",
        "age": 29
    }

    # -------------原生方式json.dumps()--------
    # 直接返回报错,需要进行包装一下,告诉系统这是个json数据.python默认会识别为字典
    # json.dumps()字典数据转成json数据
    res = json.dumps(data)
    # 第一个参数表示内容,第二个参数表示状态码,第三个表示数据类型
    return res, 200, {'Content-Type': 'application/json'}


if __name__ == '__main__':
    app.run()

重定向:

 1 """
 2 重定向:请求页面的时候,请求页面不存在,返回的是另外一个页面.
 3 一般在双11的活动的时候,活动页面...
 4 京东原来的域名www.360.buy.com,如果访问原来的就需要跳转到现在的域名www.jd.com
 5 
 6 """
 7 from flask import Flask, redirect, url_for  #  redirect, url_for 这两个是重定向模块
 8 
 9 app = Flask(__name__)
10 
11 
12 @app.route('/360buy')
13 def index():
14     # redirect 重定向
15     """
16 17 　　 url_for会根据传入的路由函数名,返回该路由对应的URL,在模板中始终使用url_for()就可以安全的修改路由绑定的URL,则不必担心模板中渲染url链接出错:
18    19     """
20     return redirect(url_for('jd'))
21 
22 
23 @app.route('/jd')
24 def jd():
25     return '进入到京东商城页面'
26 
27 
28 if __name__ == '__main__':
29     app.run()

自定义状态码:

 1 from flask import Flask
 2 
 3 app = Flask(__name__)
 4 
 5 """
 6 自定义状态码:
 7 使用场景:
 8     错误代码的对照表.可以自己定义相关的错误.比如实际开发中的具体错误:10004表示注册成功后未登录等等
 9 
10 在交互成功之后要求交互成功的内容再具体一点,是交互的哪些内容成功?
11 """
12 
13 
14 @app.route('/')
15 def index():
16     # 999 是请求状态码,是自定义的状态码
17     return 'index', 999  # 返回客户端给用户看的,999表示...错误
18 
19 
20 if __name__ == '__main__':
21     app.run()

abort异常捕获:

 1 """
 2 abort的作用:
 3 1.捕获HTTP的异常(之前是try...exception抓取),这里flask重新进行了封装.
 4 2.终止程序
 5 3.抛出异常
 6 
 7 细节-注意:在abort(500)函数中和@app.errorhandler(500)中,
 8 参数必须是http协议标准的状态码.
 9 
10 abort(状态码)和@app.errorhandler(状态码)中的参数都是状态码,这两个状态码必须一致.即这两个参数必须一致.
11 
12 abort(参数1)和@app.errorhandler(参数2):注意,参数1和参数2必须一致
13 
14 
15 在开发中实际应用:
16 1.一般用来展示404的页面(资源没找到,请求页面不存在)
17 
18 19 """
20 from flask import Flask, abort
21 
22 app = Flask(__name__)
23 
24 
25 @app.route('/')
26 def index():
27     name = ''
28     pwd = ''
29 
30     if name != 'admin' and pwd != '123':
31         print('进入了函数')
32         # 把程序终止掉,后面的业务逻辑就不需要执行了,因为即使执行也没有实际意义
33         abort(500)
34         # 进入到数据库,进行数据库查询
35         print('看看我进入数据库了没')
36     return 'index page'
37 
38 
39 @app.errorhandler(500)  # 抛出捕获到的异常信息
40 def error_500_handler(error):
41     # return '程序报错了:%s' % error
42     return '替换为一个html页面'
43 
44 
45 if __name__ == '__main__':
46     app.run()

内置过滤器filter:

 1 from flask import Flask, render_template
 2 
 3 app = Flask(__name__)
 4 
 5 """
 6 过滤器本质就是一个函数.
 7 作用:
 8 1.不仅仅只是输出值
 9 2.还希望更改值
10 
11 """
12 
13 
14 @app.route('/')
15 def index():
16     return render_template('demo2.html')
17 
18 
19 if __name__ == '__main__':
20     app.run()

对应的HTML:

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>过滤器</title>
 6 </head>
 7 <body>
 8 <h1>过滤器的使用</h1>
 9 {#{{ 需要修改的值|过滤器的名字 }}#}
10 {# capitalize: 首字母大写#}
11 <p>首字母大写:{{ 'hello'|capitalize }}</p>
12 {# 模板中处于安全考虑,默认情况下,会把标签进行转义,即把<>这个转成 &lt;&gt; #}
13 {# 但是在 开发中,我们有时候需要使用标签展示 ,需要禁止转义 #}
14 <p>禁止转义:{{ '<h1>黑马程序员</h1>'|safe }}</p>
15 <p>单词大写:{{ 'hello'|upper }}</p>
16 <p>单词小写:{{ 'HELLO'|lower }}</p>
17 <p>单词反转:{{ 'hello'|reverse }}</p>
18 <p>每个单词的首字母大写:{{ 'hello world!'|title }}</p>
19 <hr>
20 
21 <h1>列表操作:</h1>
22 <p>获取列表中的第一个元素:{{ [1,2,3,4,5,6]|first }}</p>
23 <p>获取列表中的最后一个元素:{{ [1,2,3,4,5,6]|last }}</p>
24 <p>列表求和:{{ [1,2,3,4,5,6]|sum }}</p>
25 <p>列表排序:{{ [11,21,3,4,5,6]|sort }}</p>
26 <hr>
27 
28 
29 
30 </body>
31 </html>

自定义过滤器:

 1 from flask import Flask, render_template
 2 
 3 app = Flask(__name__)
 4 
 5 """
 6 过滤器本质就是一个函数.
 7 内置的无法满足需求
 8 自定义过滤器实际上就是写自定义函数
 9 
10 app.add_template_filter(do_setup2, 'xx'):
11 1.先定义一个函数
12 2.添加函数名do_setup2到flask的app对象里面,把过滤器函数名字'xx'传给模板文件
13 3.在模板文件中取出过滤器函数名字 'xx'
14 
15 注意:在模板中只是使用过滤器,并不能自定义过滤器,自定义是在.py文件中进行
16 """
17 
18 
19 # pycharm原生格式化代码:ctrl + alt + l
20 # 目前自己使用的:shift + alt + f
21 
22 @app.route('/')
23 def index():
24     return render_template('demo3.html')
25 
26 
27 # 自定义filter,每隔一个切割一次
28 def do_setup2(my_list):
29     # my_list是前端传来的数据 [11,21,3,4,5,6,9]
30     return my_list[::2]
31 
32 
33 # 在模板里面添加一个过滤器
34 # 第一个参数:表示自定义函数的名字,
35 # 第二个参数:表示在模板里面使用的过滤器的名字
36 app.add_template_filter(do_setup2, 'xx')
37 
38 if __name__ == '__main__':
39     app.run()

对应的HTML:

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>自定义filter</title>
 6 </head>
 7 <body>
 8 {#{{ xx:自定义 }}#}
 9 <p>对列表进行切片:{{ [11,21,3,4,5,6,9]|xx }}</p>
10 </body>
11 </html>

控制代码块:

 1 from flask import Flask, render_template
 2 
 3 app = Flask(__name__)
 4 
 5 """
 6 控制代码块主要包含两个：
 7 - if/else if /else / endif
 8 - for / endfor
 9 """
10 
11 
12 @app.route('/')
13 def index():
14     my_list = [
15         {
16             "id": 1,
17             "value": "我爱工作"
18         },
19         {
20             "id": 2,
21             "value": "工作使人快乐"
22         },
23         {
24             "id": 3,
25             "value": "沉迷于工作无法自拔"
26         },
27         {
28             "id": 4,
29             "value": "日渐消瘦"
30         },
31         {
32             "id": 5,
33             "value": "以梦为马，越骑越傻"
34         }
35     ]
36     return render_template('demo4.html', my_list=my_list)
37 
38 
39 if __name__ == '__main__':
40     app.run(debug=True)

对应的HTML:

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>控制代码块</title>
 6 </head>
 7 <body>
 8 <h1>控制语句</h1>
 9 {# 专门给for循环使用 loop.....#}
10 {% for item in my_list %}
11     {% if loop.index==1 %}
12         <li style="background-color: deeppink">{{ item.value }}</li>
13     {% elif loop.index==2 %}
14         <li style="background-color:greenyellow">{{ item.value }}</li>
15         {# 注意: else loop.index==3 这样是错误的写法,jinja2模板语法会报错: jinja2.exceptions.TemplateSyntaxError: expected token 'end of statement block', got 'loop'
16 正确写法: {% else %} else就是表示最后一个了,不再需要加loop.index进行判断
17 #}
18     {% else %}
19         <li style="background-color:red">{{ item.value }}</li>
20     {% endif %}
21 {% endfor %}
22 
23 
24 </body>
25 </html>

Flask介绍

Flask介绍

发送消息flash:

 1 from flask import Flask, flash, render_template
 2 
 3 """
 4 flash:作用:表示发送消息,往队列里面发送
 5 flash是闪电的意思
 6 
 7 类似前端里面的提示消息
 8 
 9 使用场景:
10 在页面需要展示后端发送过来的消息的时候,进行使用,提示用户
11 
12 
13 扩展:
14 1.因为在发送消息的时候使用session,会存储一些隐私数据,比如购物车,为了安全起见,
15 在flask中如果使用到session,都必须加密,使用secret_key进行加密
16 """
17 
18 app = Flask(__name__)
19 
20 # 加密口令,config['SECRET_KEY'] 注意:config里面的key必须大写
21 # ['SECRET_KEY'] 必须遵循config配置文件中默认的写法
22 # RuntimeError: the session is unavailable because no secret key was set.
23 # Set the secret_key on the application to something unique and secret.
24 # 设置秘钥不能为空,否则报错
25 # app.config['SECRET_KEY'] = ''
26 # 专业术语叫salt加盐
27 app.config['SECRET_KEY'] = 'shdfsjk'
28 
29 # 加密之后再加密,再加密,至少十几次。银行密码6位数字的情况下。
30 # 专业术语叫做：加盐salt 加密
31 """
32 常用的加密算法:MD5,SHA1,BASE64等等
33 注意:MD5是不可逆的,即MD5加密之后,不会反向破解出来
34 
35 撞库:
36 
37 """
38 
39 
40 @app.route('/')
41 def index():
42     # 内置对象,不需要传递
43     flash("用户名不正确")
44     flash("用户名不正确")
45     flash("用户名不正确")
46     flash("用户名不正确")
47     return render_template('demo6.html')
48 
49 
50 if __name__ == '__main__':
51     app.run(debug=True)

对应的HTML:

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8 {# get_flashed_messages 这是一个函数地址,加()才是一个函数,返回值是flashes
 9 
10 具体作用:Pulls all flashed messages from the session and returns them.
11 #}
12 {% for msg in get_flashed_messages() %}
13 <p>{{ msg }}</p>
14 {% endfor %}
15 
16 </body>
17 </html>

message消息:

 1 from flask import Flask, flash,render_template, request, get_flashed_messages
 2 
 3 """
 4 get_flashed_messages():
 5 
 6 message是一个基于Session实现的用于保存数据的集合，其特点是：使用一次就删除
 7 用来存放临时值
 8 """
 9 app = Flask(__name__)
10 app.secret_key = 'some_secret'
11 
12 
13 @app.route('/')
14 def index1():
15     # 12.获取消息
16     v = get_flashed_messages()
17     print(v)
18     return render_template('index1.html')
19 
20 
21 # 设置完之后,只能通过浏览器访问一次刚刚设置的值,访问完之后就不能再第二次访问了
22 @app.route('/set')
23 def index2():
24     v = request.args.get('p')
25     # 设置设置消息
26     flash(v)
27     return 'ok'
28 
29 
30 if __name__ == "__main__":
31     app.run()

对应的HTML:

 1 <!DOCTYPE html>
 2 <html>
 3 <head lang="en">
 4     <meta charset="UTF-8">
 5     <title></title>
 6 </head>
 7 <body>
 8     <h1>这是index1页面</h1>
 9     {% with messages = get_flashed_messages() %}
10         {% if messages %}
11         <ul class=flashes>
12             {% for message in messages %}
13             <li>{{ message }}</li>
14             {% endfor %}
15         </ul>
16         {% endif %}
17     {% endwith %}
18 </body>
19 </html>

模板继承:

 1 from flask import Flask,render_template
 2 
 3 """
 4 模板继承:复用
 5 
 6 如果子类需要继承父类,就在父类加一个block
 7 
 8 {% block content %}
 9 
10 {% endblock %}
11 
12 
13 子类需要继承父类:
14 
15 {% block content %}
16 <h1>子类的内容</h1>
17 {% endblock %}
18 
19 
20 需要注意:block里面的内容,子类和父类必须保证一样,用来识别是哪一个内容被修改
21 
22 
23 
24 在子类中写{% extends "demo8_father.html" %},
25 如果子类和父类数据不一样,添加block ...
26 """
27 
28 app = Flask(__name__)
29 
30 
31 @app.route('/')
32 def index():
33     return render_template('demo7_son.html')
34 
35 
36 if __name__ == '__main__':
37     app.run()

对应的HTML:

demo7_son:

1 {% extends "demo8_father.html" %}
2 
3 {% block content %}
4 <h1>子类的内容页面</h1>
5 {% endblock %}

demo8_father:

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8 <h1>父类的顶部</h1>
 9 
10 {% block content %}
11 <h1>父类的内容</h1>
12 {% endblock %}
13 
14 <h1>父类的底部</h1>
15 </body>
16 </html>

命令行方式执行程序:

 1 from flask import Flask
 2 from flask_script import Manager
 3 
 4 # Manager可以用来管理我们的应用程序
 5 app = Flask(__name__)
 6 # 创建一个flask的脚本,传输一个flask对象,把app对象交给manager管理  注意:需要传参数app
 7 manager = Manager(app)
 8 """
 9 因为公司里面都是脚本命令行操作
10 """
11 
12 
13 @app.route('/')
14 def index():
15     # index是视图函数
16     return 'index'
17 
18 
19 if __name__ == '__main__':
20     manager.run()
21

内置对象:

 1 from flask import Flask, render_template, g, url_for
 2 
 3 app = Flask(__name__)
 4 
 5 """
 6 g变量就是一个容器,内置对象,不需要手动传
 7 
 8 内置对象:
 9 作用:如果使用内置对象,就不需要手动传递值,直接在页面上面使用即可
10 只是为了方便取值.
11 因为在模板页面里面已经把这些变量定义好了
12 
13 g表示一个容器,里面可以存储值
14 格式: g.变量名   其中变量名可以随便取
15 """
16 
17 
18 @app.route('/')
19 def index():
20     g.name = 'heima'
21     return render_template('demo5.html')
22 
23 
24 if __name__ == '__main__':
25     app.run()

对应的HTML:

 1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8 <h1>特有内置对象</h1>
 9 <p>获取内置的debug对象:{{ config.DEBUG }}</p>
10 <p>获取内置的请求的url:{{ request.url }}</p>
11 <p>获取内置的url_for对象:{{ url_for.url }}</p>
12 <p>获取内置的g变量里面的数据:{{ g.name }}</p>
13 </body>
14 </html>

内置的config默认信息:

Flask介绍

相关推荐