一篇博客搞定flask基础（完结）

最新推荐文章于 2024-05-11 08:50:01 发布
最新推荐文章于 2024-05-11 08:50:01 发布
阅读量1.2k 收藏 8
点赞数 2
分类专栏： flask 文章标签： flask python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangfan741/article/details/109781347
版权

1.flask基础知识

1.1 flask框架介绍

Flask相比于django更加的轻量级，最核心的两个模块： Werkzeug（路由模块），模板引擎则使用 Jinja2。Flask不像django自带各种模块，用于一些小中型的项目开发。

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

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

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

官网: https://flask.palletsprojects.com/en/1.1.x/

官方文档: http://docs.jinkan.org/docs/flask/

Flask常用第三方扩展包：

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

可以通过 https://pypi.org/search/?c=Framework+%3A%3A+Flask 查看更多flask官方推荐的扩展

1.2 flask的安装与创建

创建一个虚拟环境

mkvirtualenv flask -p python3  # -p：指定python3

安装

pip install flask==0.12.5

创建一个目录，并在pycharm中打开

mkdir -r /home/wangfan/flask/flask_demo01

创建一个main.py，并设置依赖环境（pycharm：file->settings）

在这里插入图片描述

写flask框架的主程序

#导入Flask类
from flask import Flask

# 1.创建应用对象
app = Flask(__name__)


# 2.指定路由
@app.route('/')
def index():  # 3.视图函数
    return "<h1>hello,world<h1>"  # 4. 返回字符串


if __name__ == '__main__':
    # 5. 启动项目
    app.run(debug=True, port=8001, host='0.0.0.0')  # 可以指定参数，由wsgiref模块提供

代码分析：

  1. 创建应用对象时，传入参数的说明

  2. 额外加载配置的说明（1.自定义类2.通过app.config.from_object(类名)注册），也有其他方式如下：

在这里插入图片描述

# 导入Flask类
from flask import Flask

"""
import_name      Flask程序所在的包(模块)，传 __name__ 就可以
                 其可以决定 Flask 在访问静态文件时查找的路径
static_path      静态文件访问路径(不推荐使用，使用 static_url_path 代替)
static_url_path  静态文件访问路径，可以不传，默认为：/ + static_folder
static_folder    静态文件存储的文件夹，可以不传，默认为 static
template_folder  模板文件存储的文件夹，可以不传，默认为 templates
"""
app = Flask(import_name=__name__)


# 编写路由视图
# flask的路由是通过给视图添加装饰器的方式进行编写的。当然也可以分离到另一个文件中。
# flask的视图函数，flask中默认允许通过return返回html格式数据给客户端。
@app.route('/')
def index():
    return "<h1>hello world</h1>"

# 加载项目配置
class Config(object):
    # 开启调试模式
    DEBUG = True

# flask中支持多种配置方式，通过app.config来进行加载，我们会这里常用的是配置类
app.config.from_object( Config )


# 指定服务器IP和端口
if __name__ == '__main__':
    # 运行flask
    app.run(host="0.0.0.0", port=5000)

2.flask之路由

2.1 路由的基本知识

1.路由： 一种访问地址[url]和应用程序[视图]进行一对一绑定的映射关系

2.往往在开发中，我们所说的路由，其实通常指代完成路由绑定关系的路由类

3.路由和视图的名称必须全局唯一，不能出现重复，否则报错。

4.可以通过参数method指定请求方法

2.2 有名分组

指定参数进行传递

from flask import Flask

app = Flask(__name__)


# 指定参数进行传递-->django路由：有名分组
@app.route('/user/<user_name>', methods=['get'])  # 只能发送get请求
def index(user_name):
    return "hello,%s" % (user_name)


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

2.3 内置路由参数转换器

1.int：接受正整数

2.float：接受正浮点值

3.uuid：接受UUID（通用唯一识别码）字符串 xxxx-xxxx-xxxxx-xxxxx

4.string：默认类型，接受不带斜杠的任何文本

5.path：接收string但也接受斜线

from flask import Flask

app = Flask(__name__)


# 内置路由参数转换器
@app.route('/user2/<float:user_id>')
def user(user_id):
    return 'user_id:%s' % user_id


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

原码：(werkzeug.routing.py)

DEFAULT_CONVERTERS = {
   
   "default": UnicodeConverter,
   "string": UnicodeConverter,
   "any": AnyConverter,
   "path": PathConverter,
   "int": IntegerConverter,
   "float": FloatConverter,
   "uuid": UUIDConverter,
}

2.4 自定义路由参数转换器

也叫正则匹配路由参数.

  1. 引入BaseConverter路由参数转换器基类
  2. 自定义路由参数转换器（继承父类的构造方法）
  3. 注册路由参数转换器到app对象中（app.url_map.converters['别名']=自定义类名）
from flask import Flask

app = Flask(__name__)


# 1.引入BaseConverter路由参数转换器基类
from werkzeug.routing import BaseConverter

# 2.自定义路由参数转换器
class MobileConverter(BaseConverter):
    regex = r'1[3-9]\d{9}'

    def __init__(self, map, *args, **kwargs):
        super().__init__(map)                                            # map相当于django中的urlpatterns(所有路由的列表)

# 3.注册路由参数转换器到app对象中
app.url_map.converters['mob'] = MobileConverter    # 起别名为mob


@app.route(rule='/user3/<mob:user_mobile>')
def user3(user_mobile):
    return '%s' % user_mobile


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

2.5 在路径上直接写正则匹配

相当与django中的re_path()

与2.4中不同的是：正则规则，在路径上写直接当参数传至自定义类中

两种方法的本质为：改父类的regex属性

其中，注意传参时加上引号

from flask import Flask

app = Flask(__name__)

# 1.引入BaseConverter路由参数转换器基类
from werkzeug.routing import BaseConverter

# 自定义类
class MobileConverter2(BaseConverter):
    def __init__(self, map, *args, **kwargs):
        self.regex = args[0]
        super().__init__(map)


# 注册
app.url_map.converters['mob2'] = MobileConverter2


# 传参 (注意传参时加上引号)
@app.route(rule=r'/user4/<mob2("\d{6}"):user_id>')
def user4(user_id):
    return '%s' % user_id


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

2.6 路由注册和视图进行分离

通过app.add_url_rule(rule='路径',view_func=视图函数)实现

from flask import Flask

app = Flask(__name__)

def index():
    return "ok"

# 也可以让路由注册和视图进行分离
app.add_url_rule(rule="/",view_func=index)

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

3.flask之请求与响应

3.1 请求request

属性 说明 类型
data 记录请求体的数据，并转换为字符串
只要是通过其他属性无法识别转换的请求体数据
最终都是保留到data属性中		 bytes类型
form 记录请求中的html表单数据 MultiDict
args 记录请求中的查询字符串,也可以是query_string MultiDict
cookies 记录请求中的cookie信息 Dict
headers 记录请求中的请求头 EnvironHeaders
method 记录请求使用的HTTP方法 GET/POST
url 记录请求的URL地址 string
files 记录请求上传的文件列表 *
json 记录ajax请求的json数据 json

ImmutableMultiDict：这个类就是一个字典的子类，我们可以称之为类字典对象，所以可以通过字典的操作来使用（思路来源：from collection import OrderedDict）

文档: http://docs.jinkan.org/docs/flask/api.html#flask.request

原码位置：from flask.app import Request

引入：from flask import Flask,request

from flask import Flask,request

app = Flask(__name__)


@app.route(rule='/', methods=['get', 'post'])
def index():
    print('查询字符串', request.args)
    '''
    ImmutableMultiDict([
    ('name', 'xyw'), 
    ('hobby', '1'), 
    ('hobby', '2'), 
    ('hobby', '3')
    ])
    '''
    print(request.args.get('name'))   # xyw
    print(request.args.getlist('hobby'))  # ['1', '2', '3']
    print(request.args.to_dict(flat=False))  # 转成普通字典，列表 {'name': ['xyw'], 'hobby': ['1', '2', '3']}
    print(request.args.to_dict(flat=True))   # 转成普通字典，保留第一个 {'name': 'xyw', 'hobby': '1'}
    print('请求体数据（bytes类型）', request.data)
    print('请求中表单数据', request.form)  # ImmutableMultiDict([('name', 'xyw'), ('age', '48')])
    print('请求头', request.headers)
    '''
        请求头 Authorization: jwt eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyX2lkIjo2LCJ1c2VybmFtZSI6Inh5dyIsImV4cCI6MTYwNTI3NDU4MiwiZW1haWwiOiIifQ.rc0Sjezl_uAa836wUzExyNru1VEE3qtes6-sJPWCv-0
        User-Agent: PostmanRuntime/7.26.5
        Accept: */*
        Postman-Token: b636c222-ba16-4bae-95e3-1995b7344e5f
        Host: 127.0.0.1:5000
        Accept-Encoding: gzip, deflate, br
        Connection: keep-alive
        Content-Type: multipart/form-data; boundary=--------------------------145884211271048853446909
        Content-Length: 266
    '''
    print('请求方法', request.method)
    print('请求URL', request.url)
    print('上传的文件', request.files)
    print('请求的json数据', request.json)
    print('是否是ajax请求', request.is_json)  # True
    return "<h1>hello,world<h1>"


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

3.2 响应

flask默认支持2种响应方式:

​ 1.数据响应: 默认响应html文本,也可以返回 JSON格式,或其他格式

​ 2.页面响应: 重定向

​ url_for 视图之间的跳转

响应的时候,flask也支持自定义http响应状态码

3.2.1 响应html文本

make_response

from flask import Flask, make_response

app = Flask(__name__)


@app.route('/')
def index():
    # return "<h1>hello,world<h1>"
    return make_response("<h1>hello,world<h1>")  # 与直接返回相同


if __name__ == '__main__':
    app.run()
3.2.2 响应json数据

可以直接使用 jsonify 生成一个 JSON 的响应

from flask import Flask, make_response, jsonify

app = Flask(__name__)

@app.route('/')
def index():
    data = {
   
        'name': 'xyw',
        'age': 18
    }
    return jsonify(data)

if __name__ == '__main__':
    app.run()
3.2.3 重定向到外链接

redirect

from flask import Flask, make_response, jsonify, redirect

app = Flask(__name__)

@app.route('/user')
def user():
    return redirect('http://www.baidu.com')

if __name__ == '__main__':
    app.run()
3.2.4 重定向到其他视图

1.可以直接填写自己 url 路径

2.也可以使用 url_for 生成指定视图函数所对应的 url

from flask import url_for

from flask import Flask, make_response, jsonify, redirect, url_for

app = Flask(__name__)

@app.route('/')
def index():
    data = {
   
        'name': 'xyw',
        'age': 18
    }
    return jsonify(data)

@app.route('/user')
def user():
    return redirect(url_for("index"))

if __name__ == '__main__':
    app.run()
3.2.5 重定向到其他视图时携带参数

url_for()中加上endpoint='视图名', 参数=xx

from flask import Flask, make_response, jsonify, redirect, url_for

app = Flask(__name__)


@app.route('/<userid>')
def index(userid):
    return 'userid:%s' % userid


@app.route('/user')
def user():
    return redirect(url_for(endpoint="index", userid=1))


if __name__ == '__main__':
    app.run()
3.2.6 响应时添加响应头

添加响应头，支持文件上传

from flask import Flask

app = Flask(__name__)

from flask import make_response,jsonify,request
@app.route(rule="/user", methods=["get","post"])
def user():
    # 识别身份
    if request.args.get("user") == "abc":
        # 也可以返回图片,压缩包 等其他在浏览器能支持的数据，既可以支持显示图片，也可以支持显示
        with open("2.jpg","rb") as f:
            content = f.read()
            response = make_response(content)
            response.headers["Content-Type"] = "image/jpeg"
            return response
    else:
        return "没有权限"
    # 支持下载
    # with open("123.zip", "rb") as f:
    #     response.headers["Content-Type"] = "application/zip"
    #     return response

@app.route("/")
def index():
    return "<img src='/user?user=abc'>"

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

添加自定义响应头，实现页面转跳

from flask import Flask,make_response

app = Flask(__name__)

@app.route("/user1")
def index1():
    # 页面跳转
    # return redirect("http://www.baidu.com") # 跳转到站外
    # return redirect("/user") # 跳转到站内
    # return redirect(url_for("user",user_id=100)) # 通过url_for指定视图名称，直接找到对应路由进行跳转

    # 跳转的原理，实际就是利用HTML文档中的元信息
    response = make_response()
    response.headers["Location"] = "http://www.baidu.com"  # 实现页面转跳
    response.headers["Company"] = "oldboy"  # 自定义响应头
    response.status_code = 302 # 自定义响应状态吗
    return response


if __name__ == '__main__':
    app.run(port=8000)
3.2.7 Response的参数说明
  1. 上面make_response本质上就是Response
  2. Response(response=“内容”, status=“http响应状态码”,headers=自定义响应头,mimetype=“数据格式”)
from flask import Flask,request,make_response,Response,jsonify

app = Flask(__name__)

@app.route("/")
def index():
    """返回html数据"""

    # return "ok"
    # return make_response("ok") # 上面的代码是这段代码的简写
    # return Response("ok") # 上面make_response本质上就是Response

    """返回json格式数据"""
    # data = {"name":"xiaoming","age":13}
    # return jsonify(data)

    """返回其他类型数据"""
    # 关于Response常用的参数
    # Response(response="内容", status="http响应状态码",headers=自定义响应头,mimetype="数据格式")
    # return Response(response="ok",status=201,headers={"company":"hello"})
    # 返回图片信息
    with open('./1.zip',"rb") as f:
        content=f.read()
    # 判断权限，身份...
    return Response(response=content,mimetype="application/zip")

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

4.cooike和session

4.1 cookie

4.1.1 cookie基本知识回顾

产生原因:
http协议(基于tcp)的特点:1 无连接(短连接);2 无状态.
http协议不会记录客户端和服务端的任何信息,导致服务端和客户端不能维持会话
正是由于http无状态的特性,所以出现了cookie(一种浏览器技术).请求头健值对.

工作原理:
浏览器访问服务端，带着一个空的cookie，然后由服务器产生内容，浏览器收到相应后保存在本地；
当浏览器再次访问时，浏览器会自动带上Cookie，这样服务器就能通过Cookie的内容来判断这个是“谁”了。

4.1.2 操作cookie
from flask import Flask, request, make_response, session

app = Flask(__name__)

@app.route('/set_cookie')
def set_cookie():
    # 设置cookie
    response = make_response('ok')
    response.set_cookie('username', 'xyw', 30)  # key=键，value=值，max_age=有效时间(秒)
    response.set_cookie('age', '108')  # 如果cookie没有设置过期时间，则默认过期为会话结束过期
    # 会话结束：浏览器关闭;意味着下一个站点下同变量名的cookie会被覆盖
    return response

@app.route('/get_cookie')
def get_cookie():
    # 获取cookie
    print(request.cookies)
    print(request.cookies.get('username'))
    return 'ok'

@app.route('/del_cookie')
def del_cookie():
    # 删除cookie
    response = make_response('ok')
    response.set_cookie('age', '', 0)  # 设置有效时间覆盖原有的cookie达到删除的目的
    return response

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

4.2 session

4.2.1 session知识回顾
产生原因:
    1.cookie是明文存储的
    2.大小限制:
        Cookie大小上限为4KB； 
         一个服务器最多在客户端浏览器上保存20个Cookie； 
         一个浏览器最多保存300个Cookie，因为一个浏览器可以访问多个服务器。
特点:
    cookie中放的数据是密文的
    数据存在服务端,没有大小上限
    一个浏览器对应一个服务端,就是一个session
4.2.2 操作session
from flask import Flask, request, make_response, session

app = Flask(__name__)

# 需要配置一个secret_key用于session加密
class Config():
    SECRET_KEY = '123456'
app.config.from_object(Config)

@app.route('/set_session')
def set_session():
    # 设置session
    # session 存在服务器的缓存中，支持python基本数据类型作为值
    session['username'] = 'xyw'
    session['info'] = {
   
        'age': 11,
        'sex': False
    }
    '''
    浏览器中cookies中：
    session:eyJpbmZvIjp7ImFnZSI6MTEsInNleCI6ZmFsc2V9LCJ1c2VybmFtZSI6Inh5dyJ9.X7YptA.J4GTqRRgsnt2ijZJLIhV5X-3pq8
    '''
    return 'ok'

@app.route('/get_session')
def get_session():
    # 获取session
    ret1 = session.get('username')
    ret2 = session.get('info')
    return '%s+%s' % (ret1, ret2)

@app.route('/del_session')
def del_session():
    # 删除session
    try:
        del session['username']
        # session.clear()  # 删除所有
    except:
        pass
    '''
    删除了之后在获取得到：
    None+{'age': 11, 'sex': False}
    '''
    return 'ok'

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

5.视图请求钩子

5.1 请求钩子作用

在客户端和服务器交互的过程中，有些准备工作或扫尾工作需要处理，比如：

  • 在请求开始时，建立数据库连接；
  • 在请求开始时，根据需求进行权限校验；
  • 在请求结束时，指定数据的交互格式；

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

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

  • before_first_request
    • 在处理第一个请求前执行[项目初始化时的钩子]
  • before_request
    • 在每次请求前执行
    • 如果在某修饰的函数中返回了一个响应，视图函数将不再被调用
  • after_request
    • 如果没有抛出错误，在每次请求后执行
    • 接受一个参数：视图函数作出的响应
    • 在此函数中可以对响应值在返回之前做最后一步修改处理
    • 需要将参数中的响应在此参数中进行返回
  • teardown_request：
    • 在每次请求后执行
    • 接受一个参数：错误信息，如果有相关错误抛出
    • 需要设置flask的配置DEBUG=False，teardown_request才会接受到异常对象。

5.2 实例

from flask import Flask
app = Flask(__name__)

@app.before_first_request
def first_request():
    print('1.项目启动以后，首次请求后执行')

@app.before_request
def before_request():
    print('2.每次请求时，执行')

@app.after_request
def after_request(response):
    # 会将响应结果传递进来
    print('4.视图执行之后，执行')
    return response

@app.teardown_request
def have_error(exc):
    # 用来接收异常
    print('5.在after_request执行后，执行')
    '''
    1. 在debug=False时，才能接收错误被执行，在debug=True时，只执行到有错误的那一行
    2. 没有异常时，在after_request执行后，执行
    3. 在有异常时，在有异常的那一行执行后，立即执行，（视图函数，after_request不在执行）
    '''
    print(exc)

@app.route('/')
def index():
    1 / 0
    print('3.视图函数执行了')

    return 'ok'

if __name__=='__main__':
    app.run(debug=False, port=8000)

代码执行效果：

在这里插入图片描述

有异常时：

在这里插入图片描述

6.执行上下文

执行上下文：
    1.请求上下文 ： request;session（来自于客户端）
    2.应用上下文 ： current_app;g（flask 应用程序运行过程中，保存的一些配置信息）
两者区别：
	请求上下文：保存了客户端和服务器交互的数据，一般来自于客户端。
	应用上下文：flask 应用程序运行过程中，保存的一些配置信息，比如路由列表，程序名、数据库连接、应用信息等

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

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

from flask import Flask, current_app, g
'''
执行上下文：
    1.请求上下文 ： request;session（来自于客户端）
    2.应用上下文 ： current_app;g（flask 应用程序运行过程中，保存的一些配置信息）
'''
app = Flask(__name__)

@app.route('/')
def index():
    print(current_app.config)  # 获取当前项目的所有配置信息
    print(current_app.url_map)  # 获取当前项目的所有路由信息
    func()
    print(g.name)
    return 'ok'

@app.before_request
def before_request():
    g.name = 'xyw'

7.Flask-Script

文档: https://flask-script.readthedocs.io/en/latest/

这个模块的作用可以让我们通过终端来控制flask项目的运行，类似于django的manage.py

安装：

pip install flask-script

7.1 manager 自带两个命令：runserver/shell

from flask import Flask
from flask_script import Manager, Command, Option

app = Flask(__name__)
# 使用flask_script启动项目
manage = Manager(app)

if __name__ == '__main__':
    '''
    manager 自带两个命令：runserver/shell
    端口和域名不写，默认为127.0.0.1:5000
    python 04Flask-Script.py runserver

    通过-h设置启动域名，-p设置启动端口
    python 04Flask-Script.py runserver -h127.0.0.1 -p8888
    '''
    manage.run()

7.2 自定义命令

1.定义一个类 继承Command
2.添加参数option_list
3.添加run方法
4.将自定义的类加到终端脚本工具中（add_command）

from flask import Flask
from flask_script import Manager, Command, Option

app = Flask(__name__)


@app.route('/')
def index():
    return 'ok'

# 1.定义一个类 继承Command
class HelloCommand(Command):
    """a simple example"""
    option_list = [  # 2.添加参数
        Option('--name', '-n', help='名称'),
        Option('--num', '-m', help='数量')
    ]

    # 3.添加run方法
    def run(self, name, num):   # 输入命令时，执行
        print('name=%s' % name)
        print(num)
        print('hello,world')

# 使用flask_script启动项目
manage = Manager(app)
# 4.将自定义的类加到终端脚本工具中（add_command）
manage.add_command('hello', HelloCommand)

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

7.3 用自定义命令生成项目目录

from flask import Flask
from flask_script import Manager, Command, Option

app = Flask(__name__)

@app.route('/')
def index():
    return 'ok'

# 使用命令生成目录
import os
class BluePrintCommand(Command):
    option_list = [
        Option('--name', '-n', help='蓝图名称')
    ]
    def run(self, name=None):
        if name is None:
            print('蓝图名称不能为空')
            return
        if not os.path.isdir(name):
            os.mkdir(name)
        open('%s/views.py' % name, 'w')
        open('%s/models.py' % name, 'w')
        with open('%s/urls.py' % name, 'w') as f :
            f.write('''from . import views
urlpatterns = [

]
            ''')

manage.add_command('bule', BluePrintCommand)

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

8.Jinja2模板引擎

使用Flask提供的render_template函数，该函数封装了该模板引擎

它的第一个参数为页面的文件名，后面的参数为模板中变量对应的真实值（键值对）

8.1 模板的基本使用

1.创建应用对象的时候，添加template_folder参数（存放页面的目录位置）

2.使用Flask提供的render_template函数

main.py:

from flask import Flask, render_template
# 1.创建应用对象的时候，添加template_folder参数（存放页面的目录位置）
app = Flask(__name__,
            template_folder='templates',  # html页面
            static_folder='static',       # 静态资源
            static_url_path='/static'     # 提供给外界的访问路径
            )

# 基本使用
@app.route('/')
def index():
    data = {
   }
    data['title'] = 'hello,world'
    data['num'] = 100
    #2.使用Flask提供的render_template函数
    return render_template('index1.html', **data)

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

在项目目录下创建static目录，index1.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{
  {title}}</title>
</head>
<body>
<h1>{
  {num}}</h1>
<a href='/show_info'>信息展示</a>
<a href='/show_contain'>内置变量展示</a>
<a href='/filter'>过滤器</a>
<a href='/jicheng'>继承</a>
</body>
</html>

8.2 各种数据的模板渲染及if语句和for语句的使用

Jinja2 模版中的变量代码块可以是任意 Python 类型或者对象，只要它能够被 Python 的 __str__ 方法或者str()转换为一个字符串就可以。

main.py:

from flask import Flask, render_template, session, g

app = Flask(__name__,
            template_folder='templates',  # html页面
            static_folder='static',       # 静态资源
            static_url_path='/static'     # 提供给外界的访问路径
            )

# 各种数据类型的模板渲染
@app.route('/show_info')
def show_info():
    data = {
   }
    data['info'] = {
   
        'name': 'xyw',
        'age': 18,
        'sex': True,
    }
    data['student_list'] = ['xyw1', 'xyw2', 'xyw3', 'xyw4', 'xyw5']
    data['goods_list'] = [
        {
   "id": 10, "name": "Python7天入门到放弃", "price": 99.9
最低0.47元/天 解锁文章
wangfan741
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
为什么在flask项目中使用__nam__ == "__main__"
weixin_42927647的博客
04-10 768
__name__ == "__main__"是什么意思? 为什么要在flask项目后面加上这一段 1. 什么是__name__ == "__main__" 基本上在每个python文件的入口都会加上这一句, 表示这是程序的执行入口 __name__ == "__main__"下的程序, 表示只能在入口文件中执行 如果当前模块(带有__name__ == "__main__"), 是被导入执行的,...
FLASK博客系列1——Hello,myblog
工控世界
07-12 490
最近有好友说让我用flask出个博客教程，于是乎便有了这篇文章的开始。 一、何为FLASK ？ Flask是一个轻量级的可定制框架，使用Python语言编写，较其他同类型框架更为灵活、轻便、安全且容易上手。它可以很好地结合MVC模式进行开发，开发人员分工合作，小型团队在短时间内就可以完成功能丰富的中小型网站或Web服务的实现。另外，Flask还有很强的定制性，用户可以根据自己的需求来添加相应的功能，在保持核心功能简单的同时实现功能的丰富与扩展，其强大的插件库可以让用户...
使用Flask-Admin创建强大的后台管理系统
最新发布
Code掘金的博客
05-11 1531
Flask-Admin允许开发者自定义视图，以满足特定需求。通过自定义视图，可以实现更复杂的数据展示和操作逻辑。比如，可以创建一个自定义视图来展示统计信息、图表数据或者复杂的数据关联关系。id通过上述扩展功能，我们可以更加灵活地定制后台管理系统，满足不同应用的需求。无论是简单的数据管理还是复杂的业务逻辑，Flask-Admin都能够提供强大的支持，让开发者可以更专注于业务逻辑的实现，而不用过多关注管理界面的实现细节。
【Flask】Flask开发实战：个人博客（一）
书山有路，学海无涯。记录成长，追逐梦想
11-13 3536
本文要学习的示例程序是一个个人博客程序：Bluelog。博客是典型的 CMS（Content Management System，内容管理系统），通常由两部分组成：一部分是博客前台，用来展示开放给所有用户的博客内容；另一部分是博客后台，这部分内容仅开放给博客管理员，用来对博客资源进行添加、修改和删除等操作。
Flask搭建个人博客部分记录（一）
SimpleZihao的博客
06-15 372
1.蓝图： 蓝图：用于实现单个应用的视图、模板、静态文件的集合 蓝图是Flask框架应用程序组件化的方法，可以在一个应用内或跨越多个项目共用蓝图，使用蓝图可以极大地简化大型应用的开发难度，也为Flask扩展提供了一种在应用中注册服务的集中化机制 步骤：创建蓝图对象 ；使用蓝图对象注册路由；使用应用注册蓝图对象 通常蓝图文件放在名为handlers目录下，模板文件放到templates目录下 基础模板文件：templates/base.html 配置文件：通常 Flask Web 项目的配置文件是 co
Flask源码阅读-第一篇(flask包下的__main__.py)
weixin_30905133的博客
11-21 248
源码：# -*- coding: utf-8 -*-""" flask.__main__ ~~~~~~~~~~~~~~ Alias for flask.run for the command line. :copyright: © 2010 by the Pallets team. :license: BSD, see LICENSE for more details...
flask基础之一
01-27
为什么要开启DEBUG模式？ 如果开启了debug模式，name代码在...如果flask开启了debug模式，name以后再python中修改任何代码，只要在pycharm中使用ctrl+s即可保存重载，不需要手动去重载程序 如何配置debug模式：app.run
基于Flask框架的开源Python博客系统源码
03-25
本项目是一款基于Python的Flask Web框架开发的博客系统，源代码开放，可供学习和二次开发。技术栈涉及多种编程语言，包括Python、HTML、CSS、JavaScript及PHP，确保了系统的前端展示与后端逻辑的丰富性和高效性。 ...
基于Flask框架的简易博客系统源码
03-25
项目概述：本项目是一个基于Flask框架开发的简易博客系统，共包含42个文件，其中： - HTML文件：14个，构成了博客的前端页面； - Python编译文件（pyc）：8个，存储了编译后的Python代码，提高了执行效率； - ...
Python基于Flask框架个人博客网站设计
10-24
## 一个注重创作的轻博客系统，选用python语言flask框架开发，前端采用bootstrap4轻量模板，注重内容创作与工具开发 ## 用到的技术：python，flask，flask-wtf，flask-sqlalchemy，markdown，bootstrap4，mysql ...
基于Python的Flask基础项目设计源码
04-09
Flask基础项目 - 基于Python...该项目为用户提供了一个基于Python的Flask基础项目，通过界面交互和功能模块，为用户提供了一个高效、易用的开发平台。该项目是fork自https://github.com/hack4impact/flask-base.git。
flask不运行主函数解决方法
爱问西瓜爱大树的博客
11-29 1370
问题：如下代码所示，在pyacharm里用flask框架搭建了一个服务，在主函数中定义了一个全局变量s，但是运行服务后，给服务发送post消息，在test_connection函数中居然不认识这个s变量。 最开始以为是变量作用域的问题，但是测试后发现不是。 app = Flask("服务") #app = Flask(__name__) @app.route("/extract_keywords"...
Flask框架
weixin_68531269的博客
12-09 2389
Flask是一个基于Python开发并且依赖jinja2模板（模板语言）和Werkzeug WSGI服务的一个微型框架，对于Werkzeug本质是Socket服务端，其用于接收http请求并对请求进行预处理，然后触发Flask框架，开发人员基于Flask框架提供的功能对请求进行相应的处理，并返回给用户，如果要返回给用户复杂的内容时，需要借助jinja2模板来实现对模板的处理，即：将模板和数据进行渲染，将渲染后的字符串返回给用户浏览器。
Flask基础：框架介绍与环境搭建
Ben_boba的博客
09-16 6094
Flask 框架
Yietong的博客
12-09 1674
python web框架Django：大而全(3.x以后支持异步)flask：小而精，插件的支持异步框架：Sanic、FastAPIflask介绍。
Flask入门教程(非常详细)，从零基础入门到精通，看完这一篇就够了
热门推荐
Javachichi的博客
07-20 1万+
创建Responsereturn Response("你好，少年")make_response方式resp = make_response('make response测试')思考 : 网站如何向客户端返回一个漂亮的页面呢？提示漂亮的页面需要 html 、 css 、 js .可以把这一堆字段串全都写到视图中, 作为 HttpResponse() 的参数,响应给客户端问题视图部分代码臃肿, 耦合度高这样定义的字符串是不会出任何效果和错误的效果无法及时查看.有错也不容易及时发现解决问题。
Python学习十二：Flask框架
huiguo_的博客
11-13 9087
Flask 依赖两个外部库：WerkZeug 和 Jinja2。WerkZeug 是一个WSGI(在web应用和多种服务器之间的标准Python 接口)工具集。Jinja2负责渲染模板。所以在安装Flask之前，需要安装这两个外部库，而最简单的方法就是使用 Virtualenv 创建虚拟环境。
Flask框架：用Python打造精巧而强大的Web应用
m0_70911440的博客
02-22 1229
在当今数字化时代，Web应用的需求不断增长，而对于开发者来说，选择一个适合的框架来构建Web应用是至关重要的。Flask框架作为一个简洁而灵活的Python微型框架，以其优雅的设计和丰富的可扩展性，为开发者提供了一个强大而精巧的构建Web应用程序的解决方案。在上述示例中，我们首先导入Flask模块，并创建了一个Flask应用实例。Flask拥有丰富的可选插件，如Flask-SQLAlchemy、Flask-WTF等，这些插件可帮助开发者高效地处理常见的Web开发任务。
用flask写一个博客蓝图
09-20
好的，以下是一个使用 Flask 实现博客蓝图的示例： ```python from flask import Blueprint, render_template, request, redirect, url_for blog = Blueprint("blog", __name__, template_folder="templates") @...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值