标签：return value Django 12.0 tag 模板 django def

【零】Django模板系统

模板 | Django 文档 | Django (djangoproject.com)

【一】模板语法的传值

{{}} : 变量相关
{%%} : 逻辑相关

【0】变量

（1）传值

在Django的模板语言中按此语法使用：
- {{ 变量名 }}。
当模版引擎遇到一个变量，它将计算这个变量，然后用结果替换掉它本身。
变量的命名包括任何字母数字以及下划线 ("_")的组合。
变量名称中不能有空格或标点符号。

（2）取值

点（.）在模板语言中有特殊的含义。
- 当模版系统遇到点(".")，它将以这样的顺序查询：
  - 字典查询（Dictionary lookup）
  - 属性或方法查询（Attribute or method lookup）
  - 数字索引查询（Numeric index lookup）

（3）注意事项

如果计算结果的值是可调用的，它将被无参数的调用。调用的结果将成为模版的值。
如果使用的变量不存在，模版系统将插入 string_if_invalid 选项的值，它被默认设置为'' (空字符串) 。

【1】路由

# 模板语法传值
from django.urls import path
from app02 import views
urlpatterns = [
    path("index/",views.index)
]

【2】基本数据类型

（1）视图

from django.shortcuts import render, HttpResponse

def index(request):
    # 模板语法可以传递的后端Python数据类型
    # 整型
    a = 123
    # 浮点型
    b = 11.11
    # 字符串
    c = "这是一个示例"
    # 列表
    d = ["你好", "我好", "大家好"]
    # 字典
    e = {"username": "dream", "password": 1223, "host": "localhost"}
    # 布尔
    f = True
    # 元祖
    g = (11, 22, 33)
    # 集合
    h = {"阳阳", "可可"}

    # 将所有数据打包发送给前端
    return render(request, 'index.html', locals())

（2）前端

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
    <link href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
    <script src="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.7/js/bootstrap.min.js"></script>

</head>
<body>
<p>整型 {{ a }}</p>
<p>浮点型 {{ b }}</p>
<p>字符串 {{ c }}</p>
<p>列表 {{ d }}</p>
<p>字典 {{ e }}</p>
<p>布尔 {{ f }}</p>
<p>元祖 {{ g }}</p>
<p>集合 {{ h }}</p>
</body>
</html>

（3）页面展示

整型 123

浮点型 11.11

字符串 这是一个示例

列表 ['你好', '我好', '大家好']

字典 {'username': 'dream', 'password': 1223, 'host': 'localhost'}

布尔 True

元祖 (11, 22, 33)

集合 {'可可', '阳阳'}

【3】函数

（1）无返回值

后端

from django.shortcuts import render, HttpResponse

# Create your views here.
from django.views import View

def index(request):
    # 模板语法可以传递的后端Python数据类型
    # 整型
    a = 123
    # 浮点型
    b = 11.11
    # 字符串
    c = "这是一个示例"
    # 列表
    d = ["你好", "我好", "大家好"]
    # 字典
    e = {"username": "dream", "password": 1223, "host": "localhost"}
    # 布尔
    f = True
    # 元祖
    g = (11, 22, 33)
    # 集合
    h = {"阳阳", "可可"}
    # 函数
    def func():
        pass

    # 将所有数据打包发送给前端
    return render(request, 'index.html', locals())

前端

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
    <link href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
    <script src="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.7/js/bootstrap.min.js"></script>

</head>
<body>
<p>整型 {{ a }}</p>
<p>浮点型 {{ b }}</p>
<p>字符串 {{ c }}</p>
<p>列表 {{ d }}</p>
<p>字典 {{ e }}</p>
<p>布尔 {{ f }}</p>
<p>元祖 {{ g }}</p>
<p>集合 {{ h }}</p>
<p>函数 {{ func }}</p>
</body>
</html>

页面展示

整型 123

浮点型 11.11

字符串 这是一个示例

列表 ['你好', '我好', '大家好']

字典 {'username': 'dream', 'password': 1223, 'host': 'localhost'}

布尔 True

元祖 (11, 22, 33)

集合 {'阳阳', '可可'}

函数func None

（2）有返回值

后端

from django.shortcuts import render


# Create your views here.
def index(request):
    # 模板语法可以传递的后端Python数据类型
    # 整型
    a = 123
    # 浮点型
    b = 11.11
    # 字符串
    c = "这是一个示例"
    # 列表
    d = ["你好", "我好", "大家好"]
    # 字典
    e = {"username": "dream", "password": 1223, "host": "localhost"}
    # 布尔
    f = True
    # 元祖
    g = (11, 22, 33)
    # 集合
    h = {"阳阳", "可可"}

    # 无返回值函数
    def func():
        pass

    # 有返回值函数
    def foo():
        print("正在执行中....")
        return '执行完成....'

    # 将所有数据打包发送给前端
    return render(request, 'index.html', locals())

前端

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
    <link href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
    <script src="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.7/js/bootstrap.min.js"></script>

</head>
<body>
<p>整型 {{ a }}</p>
<p>浮点型 {{ b }}</p>
<p>字符串 {{ c }}</p>
<p>列表 {{ d }}</p>
<p>字典 {{ e }}</p>
<p>布尔 {{ f }}</p>
<p>元祖 {{ g }}</p>
<p>集合 {{ h }}</p>
<p>函数func {{ func }}</p>
<p>函数foo {{ foo }}</p>
</body>
</html>

页面展示
- 终端打印 正在执行中....
- 页面展示 执行完成....

整型 123

浮点型 11.11

字符串 这是一个示例

列表 ['你好', '我好', '大家好']

字典 {'username': 'dream', 'password': 1223, 'host': 'localhost'}

布尔 True

元祖 (11, 22, 33)

集合 {'阳阳', '可可'}

函数func None

函数foo 执行完成....

（3）总结

函数放到模版语法中会自动调用
- 但是模版语法不支持给函数添加其他的参数

【4】类与对象

（1）类与对象

后端

from django.shortcuts import render


# Create your views here.
def index(request):
    # 模板语法可以传递的后端Python数据类型
    # 整型
    a = 123
    # 浮点型
    b = 11.11
    # 字符串
    c = "这是一个示例"
    # 列表
    d = ["你好", "我好", "大家好"]
    # 字典
    e = {"username": "dream", "password": 1223, "host": "localhost"}
    # 布尔
    f = True
    # 元祖
    g = (11, 22, 33)
    # 集合
    h = {"阳阳", "可可"}

    # 无返回值函数
    def func():
        pass

    # 有返回值函数
    def foo():
        print("正在执行中....")
        return '执行完成....'

    # 类
    class MyClass(object):
        # 普通方法
        def get_self(self):
            return 'my_self'

        # 静态方法
        @staticmethod
        def get_func():
            return 'my_func'

        # 绑定给类的静态方法
        @classmethod
        def get_class(cls):
            return 'my_class'

    # 实例化对象
    obj = MyClass()
    
    # 将所有数据打包发送给前端
    return render(request, 'index.html', locals())

前端

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
    <link href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
    <script src="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.7/js/bootstrap.min.js"></script>

</head>
<body>
<p>整型 {{ a }}</p>
<p>浮点型 {{ b }}</p>
<p>字符串 {{ c }}</p>
<p>列表 {{ d }}</p>
<p>字典 {{ e }}</p>
<p>布尔 {{ f }}</p>
<p>元祖 {{ g }}</p>
<p>集合 {{ h }}</p>
<p>函数func {{ func }}</p>
<p>函数foo {{ foo }}</p>
<p>自定义类 {{ MyClass }}</p>
<p>实例化对象 {{ obj }}</p>
</body>
</html>

页面展示

整型 123

浮点型 11.11

字符串 这是一个示例

列表 ['你好', '我好', '大家好']

字典 {'username': 'dream', 'password': 1223, 'host': 'localhost'}

布尔 True

元祖 (11, 22, 33)

集合 {'阳阳', '可可'}

函数func None

函数foo 执行完成....

自定义类 <app02.views.index.<locals>.MyClass object at 0x169134130>

实例化对象 <app02.views.index.<locals>.MyClass object at 0x16910c0a0>

传类的时候也会自动调用类实例化出对象
- 对象就是原来的对象

（2）对象调用方法

前端

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
    <link href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
    <script src="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.7/js/bootstrap.min.js"></script>

</head>
<body>
<p>整型 {{ a }}</p>
<p>浮点型 {{ b }}</p>
<p>字符串 {{ c }}</p>
<p>列表 {{ d }}</p>
<p>字典 {{ e }}</p>
<p>布尔 {{ f }}</p>
<p>元祖 {{ g }}</p>
<p>集合 {{ h }}</p>
<p>函数func {{ func }}</p>
<p>函数foo {{ foo }}</p>
<p>自定义类 {{ MyClass }}</p>
<p>实例化对象 {{ obj }}</p>
<p>对象调用绑定给对象的方法 {{ obj.get_self }}</p>
<p>对象调用绑定给类的方法 {{ obj.get_class }}</p>
<p>对象调用静态方法 {{ obj.get_func }}</p>
</body>
</html>

页面展示

整型 123

浮点型 11.11

字符串 这是一个示例

列表 ['你好', '我好', '大家好']

字典 {'username': 'dream', 'password': 1223, 'host': 'localhost'}

布尔 True

元祖 (11, 22, 33)

集合 {'阳阳', '可可'}

函数func None

函数foo 执行完成....

自定义类 <app02.views.index.<locals>.MyClass object at 0x16909d990>

实例化对象 <app02.views.index.<locals>.MyClass object at 0x16906b9d0>

对象调用绑定给对象的方法 my_self

对象调用绑定给类的方法 my_class

对象调用静态方法 my_func

可以调用对象的方法并拿到对应的返回值!

（3）类对象内部的 `str`方法

后端

from django.shortcuts import render


# Create your views here.
def index(request):
    # 模板语法可以传递的后端Python数据类型
    # 整型
    a = 123
    # 浮点型
    b = 11.11
    # 字符串
    c = "这是一个示例"
    # 列表
    d = ["你好", "我好", "大家好"]
    # 字典
    e = {"username": "dream", "password": 1223, "host": "localhost"}
    # 布尔
    f = True
    # 元祖
    g = (11, 22, 33)
    # 集合
    h = {"阳阳", "可可"}

    # 无返回值函数
    def func():
        pass

    # 有返回值函数
    def foo():
        print("正在执行中....")
        return '执行完成....'

    # 类
    class MyClass(object):
        # 普通方法
        def get_self(self):
            return 'my_self'

        # 静态方法
        @staticmethod
        def get_func():
            return 'my_func'

        # 绑定给类的静态方法
        @classmethod
        def get_class(cls):
            return 'my_class'

        # 类被调用时一定会触发该方法
        # 对象被展示到页面上时，就类似于执行了打印操作，也会触发__str__方法
        def __str__(self):
            return "我被调用啦!"

    # 实例化对象
    obj = MyClass()

    # 将所有数据打包发送给前端
    return render(request, 'index.html', locals())

前端

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
    <link href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
    <script src="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.7/js/bootstrap.min.js"></script>

</head>
<body>
<p>整型 {{ a }}</p>
<p>浮点型 {{ b }}</p>
<p>字符串 {{ c }}</p>
<p>列表 {{ d }}</p>
<p>字典 {{ e }}</p>
<p>布尔 {{ f }}</p>
<p>元祖 {{ g }}</p>
<p>集合 {{ h }}</p>
<p>函数func {{ func }}</p>
<p>函数foo {{ foo }}</p>
<p>自定义类 {{ MyClass }}</p>
<p>实例化对象 {{ obj }}</p>
<p>对象调用绑定给对象的方法 {{ obj.get_self }}</p>
<p>对象调用绑定给类的方法 {{ obj.get_class }}</p>
<p>对象调用静态方法 {{ obj.get_func }}</p>
</body>
</html>

页面展示

整型 123

浮点型 11.11

字符串 这是一个示例

列表 ['你好', '我好', '大家好']

字典 {'username': 'dream', 'password': 1223, 'host': 'localhost'}

布尔 True

元祖 (11, 22, 33)

集合 {'可可', '阳阳'}

函数func None

函数foo 执行完成....

自定义类 我被调用啦!

实例化对象 我被调用啦!

对象调用绑定给对象的方法 my_self

对象调用绑定给类的方法 my_class

对象调用静态方法 my_func

类被调用时一定会触发该方法
对象被展示到页面上时，就类似于执行了打印操作，也会触发__str__方法

【小结】

模版语法会自动判断当前位置的变量名是否可以加括号调用
- 如果可以就会自执行
- 如果不能执行就会忽略
一般针对的是对象和类

【二】模版语法的取值

【1】概述

Django模版语法的取值，是固定的格式，只能采用“句点符”取值

可以通过 .键 取值
也可以通过 .索引 取值

【2】后端

from django.shortcuts import render


# Create your views here.
def index(request):
    # 模板语法可以传递的后端Python数据类型
    # 列表
    d = ["你好", "我好", "大家好"]
    # 字典
    e = {"username": "dream", "password": 1223, "host": "localhost"}

    # 将所有数据打包发送给前端
    return render(request, 'index.html', locals())

【3】前端

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
    <link href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
    <script src="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.3.7/js/bootstrap.min.js"></script>

</head>
<body>
<p>取值{{ e.username }}</p>
<p>取值{{ d.0 }}</p>
</body>
</html>

【4】页面展示

取值dream

取值你好

【三】过滤器

【1】过滤器

在Django的模板语言中，通过使用过滤器来改变变量的显示。

（1）过滤器的语法

{{ value|filter_name:参数 }}
使用管道符"|"来应用过滤器。
例如：
- {{ name|lower }}会将name变量应用lower过滤器之后再显示它的值。
- lower在这里的作用是将文本全都变成小写。

（2）注意事项

过滤器支持“链式”操作。即一个过滤器的输出作为另一个过滤器的输入。
过滤器可以接受参数，例如：{{ sss|truncatewords:30 }}，这将显示sss的前30个词。
过滤器参数包含空格的话，必须用引号包裹起来。比如使用逗号和空格去连接一个列表中的元素，如：{{ list|join:', ' }}
|左右没有空格!没有空格!没有空格!

Django的模板语言中提供了大约六十个内置过滤器。

【2】语法

{{数据|过滤器:参数}}

【3】计算长度(length)

（0）语法

返回值的长度，作用于字符串和列表。
- {{ value|length }}
返回value的长度
- 如 value=['a', 'b', 'c', 'd']的话，就显示4.

（1）后端

from django.shortcuts import render


# Create your views here.
def index(request):
    # 模板语法可以传递的后端Python数据类型
    # 字符串
    c = "这是一个示例"

    # 将所有数据打包发送给前端
    return render(request, 'index.html', locals())

（2）前端

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>

</head>
<body>
<p>{{ c|length }}</p>
</body>
</html>

（3）页面展示

（4）源码

from django.template.defaultfilters import length

@register.filter(is_safe=False)
def length(value):
    """Return the length of the value - useful for lists."""
    try:
        return len(value)
    except (ValueError, TypeError):
        return 0

【4】默认值(default)

（0）语法

**如果一个变量是false或者为空，使用给定的默认值。 **
否则，使用变量的值。

{{ value|default:"nothing"}}

如果value没有传值或者值为空的话就显示nothing

（1）后端

from django.shortcuts import render


# Create your views here.
def index(request):
    # 模板语法可以传递的后端Python数据类型
    # 布尔
    f = True

    # 将所有数据打包发送给前端
    return render(request, 'index.html', locals())

（2）前端

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>

</head>
<body>
<p>默认值 {{ f|default:"这是默认值" }}</p>
</body>
</html>

（3）页面展示

默认值 True

（4）原理

类似于 get 方法
- 第一个参数如果是True，就会展示第一个值
- 如果第一个参数取不到，就会展示第二个值

（5）源码

from django.template.defaultfilters import default_if_none

@register.filter(is_safe=False)
def default_if_none(value, arg):
    """If value is None, use given default."""
    if value is None:
        return arg
    return value

【5】文件大小(filesizeformat)

（1）语法

将值格式化为一个 “人类可读的” 文件尺寸（例如 '13 KB', '4.1 MB', '102 bytes', 等等）。例如：

{{ value|filesizeformat }}

如果 value 是 123456789，输出将会是 117.7 MB。

（2）前端

<p>文件大小 {{ file|filesizeformat }}</p>

（3）源码

def filesizeformat(bytes_):
    """
    Formats the value like a 'human-readable' file size (i.e. 13 KB, 4.1 MB,
    102 bytes, etc.).
    """
    try:
        bytes_ = float(bytes_)
    except (TypeError, ValueError, UnicodeDecodeError):
        value = ungettext("%(size)d byte", "%(size)d bytes", 0) % {'size': 0}
        return avoid_wrapping(value)

    def filesize_number_format(value):
        return formats.number_format(round(value, 1), 1)

    KB = 1 << 10
    MB = 1 << 20
    GB = 1 << 30
    TB = 1 << 40
    PB = 1 << 50

    negative = bytes_ < 0
    if negative:
        bytes_ = -bytes_  # Allow formatting of negative numbers.

    if bytes_ < KB:
        value = ungettext("%(size)d byte", "%(size)d bytes", bytes_) % {'size': bytes_}
    elif bytes_ < MB:
        value = ugettext("%s KB") % filesize_number_format(bytes_ / KB)
    elif bytes_ < GB:
        value = ugettext("%s MB") % filesize_number_format(bytes_ / MB)
    elif bytes_ < TB:
        value = ugettext("%s GB") % filesize_number_format(bytes_ / GB)
    elif bytes_ < PB:
        value = ugettext("%s TB") % filesize_number_format(bytes_ / TB)
    else:
        value = ugettext("%s PB") % filesize_number_format(bytes_ / PB)

    if negative:
        value = "-%s" % value
    return avoid_wrapping(value)

【6】日期格式化(date)

（）语法

格式化

{{ value|date:"Y-m-d H:i:s"}}

可用的参数：

格式化字符	描述	示例输出
a	`'a.m.'`或`'p.m.'`（请注意，这与PHP的输出略有不同，因为这包括符合Associated Press风格的期间）	`'a.m.'`
A	`'AM'`或`'PM'`。	`'AM'`
b	月，文字，3个字母，小写。	`'jan'`
B	未实现。
c	ISO 8601格式。（注意：与其他格式化程序不同，例如“Z”，“O”或“r”，如果值为naive datetime，则“c”格式化程序不会添加时区偏移量（请参阅`datetime.tzinfo`）。	`2008-01-02T10:30:00.000123+02:00`或`2008-01-02T10:30:00.000123`如果datetime是天真的
d	月的日子，带前导零的2位数字。	`'01'`到`'31'`
D	一周中的文字，3个字母。	`“星期五”`
e	时区名称可能是任何格式，或者可能返回一个空字符串，具体取决于datetime。	`''`、`'GMT'`、`'-500'`、`'US/Eastern'`等
E	月份，特定地区的替代表示通常用于长日期表示。	`'listopada'`（对于波兰语区域，而不是`'Listopad'`）
f	时间，在12小时的小时和分钟内，如果它们为零，则分钟停留。专有扩展。	`'1'`，`'1:30'`
F	月，文，长。	`'一月'`
g	小时，12小时格式，无前导零。	`'1'`到`'12'`
G	小时，24小时格式，无前导零。	`'0'`到`'23'`
h	小时，12小时格式。	`'01'`到`'12'`
H	小时，24小时格式。	`'00'`到`'23'`
i	分钟。	`'00'`到`'59'`
I	夏令时间，无论是否生效。	`'1'`或`'0'`
j	没有前导零的月份的日子。	`'1'`到`'31'`
l	星期几，文字长。	`'星期五'`
L	布尔值是否是一个闰年。	`True`或`False`
m	月，2位数字带前导零。	`'01'`到`'12'`
M	月，文字，3个字母。	`“扬”`
n	月无前导零。	`'1'`到`'12'`
N	美联社风格的月份缩写。专有扩展。	`'Jan.'`，`'Feb.'`，`'March'`，`'May'`
o	ISO-8601周编号，对应于使用闰年的ISO-8601周数（W）。对于更常见的年份格式，请参见Y。	`'1999年'`
O	与格林威治时间的差异在几小时内。	`'+0200'`
P	时间为12小时，分钟和'a.m。'/'p.m。'，如果为零，分钟停留，特殊情况下的字符串“午夜”和“中午”。专有扩展。	`'1 am'`，`'1:30 pm' / t3>，'midnight'，'noon'，'12：30 pm' / T10>`
r	RFC 5322格式化日期。	`'Thu, 21 Dec 2000 16:01:07 +0200'`
s	秒，带前导零的2位数字。	`'00'`到`'59'`
S	一个月的英文序数后缀，2个字符。	`'st'`，`'nd'`，`'rd'`或`'th'`
t	给定月份的天数。	`28` to `31`
T	本机的时区。	`'EST'`，`'MDT'`
u	微秒。	`000000` to `999999`
U	自Unix Epoch以来的二分之一（1970年1月1日00:00:00 UTC）。
w	星期几，数字无前导零。	`'0'`（星期日）至`'6'`（星期六）
W	ISO-8601周数，周数从星期一开始。	`1`，`53`
y	年份，2位数字。	`'99'`
Y	年，4位数。	`'1999年'`
z	一年中的日子	`0`到`365`
Z	时区偏移量，单位为秒。 UTC以西时区的偏移量总是为负数，对于UTC以东时，它们总是为正。	`-43200`到`43200`

（0）后端

import datetime

from django.shortcuts import render
from django.template.defaultfilters import default_if_none


# Create your views here.
def index(request):
    # 模板语法可以传递的后端Python数据类型
    current_time = datetime.datetime.now()
    
    # 将所有数据打包发送给前端
    return render(request, 'index.html', locals())

（1）原始格式

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>

</head>
<body>
<p>日期格式化 {{ current_time }}</p>
</body>
</html>

日期格式化 July 12, 2023, 3:57 p.m.

（2）格式化输出

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>

</head>
<body>
<p>日期格式化 {{ current_time|date:'Y-m-d H:m:s' }}</p>
</body>
</html>

日期格式化 2023-07-12 15:07:45

【7】切片操作(slice)

支持步长切片

c = "这是一个示例"

<p>切片操作 {{ c|slice:'0:4:2' }}</p>

切片操作 这一

【8】切取摘要(truncatechars)

（0）语法

如果字符串字符多于指定的字符数量，那么会被截断。
- 截断的字符串将以可翻译的省略号序列（“...”）结尾。
参数：截断的字符数

{{ value|truncatechars:9}}

（1）字符

会将 . 算进切取个数

# 一串长文本只想截取某段数据
    page = '# Nginx是什么？ Nginx (engine x) 是一个高性能的HTTP和反向代理web服务器 ，同时也提供了IMAP/POP3/SMTP服务。Nginx是由伊戈尔·赛索耶夫为俄罗斯访问量第二的Rambler.ru站点开发的，因它的稳定性、丰富的功能集、简单的配置文件和低系统资源的消耗而闻名 ...'

<p>切取字符 {{ page|truncatechars:10 }}</p>

切取字符 # Nginx...

（2）单词

不会将 . 算进切取个数

 # 切取单词
 sentence = 'I just need someone who will never abandon me'

<p>切取单词 {{ sentence|truncatewords:9 }}</p>

切取单词 I just need someone who will never abandon me

【9】移除指定字符(cut)

（1）语法

移除value中所有的与给出的变量相同的字符串

{{ value|cut:' ' }}

如果value为'i love you'，那么将输出'iloveyou'.

（2）后端

sentence = 'I just need someone who will never abandon me'

（3）前端

<p>移除指定字符,例空格 {{ sentence|cut:" " }}</p>

移除指定字符,例空格 Ijustneedsomeonewhowillneverabandonme

【10】拼接字符(join)

d = ["你好", "我好", "大家好"]

<p>拼接字符 {{ d|join:"$" }}</p>

拼接字符 你好$我好$大家好

【11】加法(add)

a = 123

<p>拼接字符(加法) {{ a|add:10 }}</p>

拼接字符(加法) 133

源码

def add(value, arg):
    """Adds the arg to the value."""
    try:
        return int(value) + int(arg)
    except (ValueError, TypeError):
        try:
            return value + arg
        except Exception:
            return ''

【12】取消转义(mark_safe和safe)

Django的模板中会对HTML标签和JS等语法标签进行自动转义，原因显而易见，这样是为了安全。
但是有的时候我们可能不希望这些HTML元素被转义
比如我们做一个内容管理系统，后台添加的文章中是经过修饰的，这些修饰可能是通过一个类似于FCKeditor编辑加注了HTML修饰符的文本，如果自动转义的话显示的就是保护HTML标签的源文件。
以后在写全栈项目时，前端代码不一定必须在前端页面书写
也可以选择先在后端写好，再传递给前端页面展示

（1）前端转义(safe)

msg = '<h1>斋藤</h1>'

<p>转义字符(不转义) {{ msg }}</p>

<p>转义字符(转义) {{ msg|safe }}</p>

转义字符(不转义) <h1>斋藤</h1>

转义字符(转义)

斋藤(已变成h1标题格式)

（2）后端转义(mark_safe)

from django.utils.safestring import mark_safe
res = mark_safe('<h1>飞鸟</h1>')

<p>转义字符(转义) {{ res }}</p>

转义字符(转义)

飞鸟(已变成h1标题格式)

【13】timesince

将日期格式设为自该日期起的时间（例如，“4天，6小时”）。
**采用一个可选参数，它是一个包含用作比较点的日期的变量（不带参数，比较点为现在）。 **
- 例如，如果blog_date是表示2006年6月1日午夜的日期实例，并且comment_date是2006年6月1日08:00的日期实例，则以下将返回“8小时”：

{{ blog_date|timesince:comment_date }}

分钟是所使用的最小单位，对于相对于比较点的未来的任何日期，将返回“0分钟”。

【14】timeuntil

似于timesince，除了它测量从现在开始直到给定日期或日期时间的时间。
- 例如，如果今天是2006年6月1日，而conference_date是保留2006年6月29日的日期实例，则{{ conference_date | timeuntil }}将返回“4周”。
使用可选参数，它是一个包含用作比较点的日期（而不是现在）的变量。
- 如果from_date包含2006年6月22日，则以下内容将返回“1周”：

{{ conference_date|timeuntil:from_date }}

【四】标签(Tags)

【1】for循环

（1）普通for循环

<ul>
{% for user in user_list %}
    <li>{{ user.name }}</li>
{% endfor %}
</ul>

（2）for循环可用的一些参数：

Variable	Description
`forloop.counter`	当前循环的索引值（从1开始）
`forloop.counter0`	当前循环的索引值（从0开始）
`forloop.revcounter`	当前循环的倒序索引值（从1开始）
`forloop.revcounter0`	当前循环的倒序索引值（从0开始）
`forloop.first`	当前循环是不是第一次循环（布尔值）
`forloop.last`	当前循环是不是最后一次循环（布尔值）
`forloop.parentloop`	本层循环的外层循环

（3）for ... empty

<ul>
{% for user in user_list %}
    <li>{{ user.name }}</li>
{% empty %}
    <li>空空如也</li>
{% endfor %}
</ul>

【2】if判断

（1）`if ~ elif ~ else`

{% if user_list %}
  用户人数：{{ user_list|length }}
{% elif black_list %}
  黑名单数：{{ black_list|length }}
{% else %}
  没有用户
{% endif %}

（2）只有if和else

{% if user_list|length > 5 %}
  七座豪华SUV
{% else %}
    黄包车
{% endif %}

if语句支持 and 、or、==、>、<、!=、<=、>=、in、not in、is、is not判断。

【3】with

定义一个中间变量，多用于给一个复杂的变量起别名。
注意等号左右不要加空格。

{% with total=business.employees.count %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}

{% with business.employees.count as total %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}

【4】csrf_token

这个标签用于跨站请求伪造保护。
在页面的form表单里面写上

【5】注释

{# ... #}

【6】注意事项

Django的模板语言不支持连续判断，即不支持以下写法：

{% if a > b > c %}
...
{% endif %}

Django的模板语言中属性的优先级大于方法

def xx(request):
    d = {"a": 1, "b": 2, "c": 3, "items": "100"}
    return render(request, "xx.html", {"data": d})

如上，我们在使用render方法渲染一个页面的时候
- 传的字典d有一个key是items并且还有默认的 d.items() 方法
- 此时在模板语言中:

{{ data.items }}

默认会取d的items key的值。

【7】forloop示例

d = ["你好", "我好", "大家好"]

{% for re in d %}

    <p>{{ forloop }}</p>

{% endfor %}

标签
{'parentloop': {}, 'counter0': 0, 'counter': 1, 'revcounter': 3, 'revcounter0': 2, 'first': True, 'last': False}

{'parentloop': {}, 'counter0': 1, 'counter': 2, 'revcounter': 2, 'revcounter0': 1, 'first': False, 'last': False}

{'parentloop': {}, 'counter0': 2, 'counter': 3, 'revcounter': 1, 'revcounter0': 0, 'first': False, 'last': True}

first
- 标识 for 循环是否是第一次
last
- 标识 for 循环是否是以后一次
counter0
- 类似索引
counter
- 计数
取值

d = ["你好", "我好", "大家好"]

{% for re in d %}

    <p>{{ re }}</p>

{% endfor %}

你好

我好

大家好

【8】if语句示例

f = True

{% if f %}
    <p>你好</p>
{% else %}
    <p>我好</p>
{% endif %}

你好

【9】混用 forloop + if 示例

d = ["你好", "我好", "大家好"]

{% for re in d %}
    {% if forloop.first %}
        <p>第一次循环</p>
    {% elif  forloop.last %}
        <p>最后一次循环</p>
    {% else %}
        <p>{{ re }}</p>
    {% endif %}
{% empty %}
    <p>for循环的对象是空，不支持for循环</p>

{% endfor %}

第一次循环

我好

最后一次循环

【五】自定义过滤器标签/inclusion_tag

三步走
- 要在应用下创建一个名字必须是templatetags文件夹
- 在该文件夹内创建任意名称的py文件
- 在该文件内必须写下面的话
```
from django import template

register = template.Library()
```

【1】自定义过滤器

过滤器只能最多两个参数

（1）templatetags/my_tag.py

from django import template

register = template.Library()


@register.filter(name='dream')
def my_sum(x, y):
    return x + y

（2）前端

import datetime

from django.shortcuts import render, HttpResponse
from django.utils.safestring import mark_safe

# Create your views here.
from django.views import View


class MyLogin(View):

    def get(self, request):
        return render(request, 'login.html')

    def post(self, request):
        return HttpResponse('POST OK')


def index(request):
    # 模板语法可以传递的后端Python数据类型
    # 整型
    a = 123
    # 浮点型
    b = 11.11
    # 字符串
    c = "这是一个示例"
    # 列表
    d = ["你好", "我好", "大家好"]
    # 字典
    e = {"username": "dream", "password": 1223, "host": "localhost"}
    # 布尔
    f = True
    # 元祖
    g = (11, 22, 33)
    # 集合
    h = {"阳阳", "可可"}

    # 函数
    def func():
        print("正在执行中....")
        return '执行完成....'

    # 类
    class MyClass(object):
        # 普通方法
        def get_self(self):
            return 'my_self'

        # 静态方法
        @staticmethod
        def get_func():
            return 'my_func'

        # 绑定给类的静态方法
        @classmethod
        def get_class(cls):
            return 'my_class'

        def __str__(self):
            return "我被调用啦!"

    # 实例化对象
    obj = MyClass()

    current_time = datetime.datetime.now()

    # 一串长文本只想截取某段数据
    page = '# Nginx是什么？ Nginx (engine x) 是一个高性能的HTTP和反向代理web服务器 ，同时也提供了IMAP/POP3/SMTP服务。Nginx是由伊戈尔·赛索耶夫为俄罗斯访问量第二的Rambler.ru站点开发的，因它的稳定性、丰富的功能集、简单的配置文件和低系统资源的消耗而闻名 ...'

    # 切取单词
    sentence = 'I just need someone who will never abandon me'

    # 转义
    msg = '<h1>斋藤</h1>'

    from django.utils.safestring import mark_safe
    res = mark_safe('<h1>飞鸟</h1>')

    # 将所有数据打包发送给前端
    return render(request, 'index.html', locals())

<h1>自定义标签的使用</h1>
{% load my_tag %}
<p>{{ a|dream:666 }}</p>

【2】自定义标签

from django import template

register = template.Library()


@register.simple_tag(name='plus')
def index(a, b, c, d):
    return f'{a}:{b}:{c}:{d}'

前端页面

<h1>自定义标签的使用</h1>
{% load my_tag %}

<p>{% plus 'dream' 521 369 789 %}</p>

dream:521:369:789

【3】自定义inclusion_tag

先定义一个方法
在页面上调用该方法，并且可以传值
该方法会生成一些数据然后传递给一个前端页面
再将渲染好的页面返回给前端

（1）templatetags/my_tag.py

# 自定义inclusion_tag
@register.inclusion_tag('left_menu.html')
def left(n):
    data = ['第 {} 项'.format(n) for n in range(n)]
    return locals()  # 将data传递给 left_menu

（2）left_menu.html

<ul>
    {% for datum in data %}
        <li>{{ datum }}</li>
    {% endfor %}

</ul>

（3）index.html

<h1>自定义标签的使用</h1>
{% load my_tag %}

{% left 10 %}

前端展示

第 0 项
第 1 项
第 2 项
第 3 项
第 4 项
第 5 项
第 6 项
第 7 项
第 8 项
第 9 项

（4）总结

当html页面的某一个地方的页面需要传参数才能动态的渲染出来，并且在多个页面上都需要使用到的局部，那么就考虑将该局部页面做成 inclusion_tag 形式

【六】模版的继承

某些页面的整体大差不差，但是某一些局部在做变化

【1】模板

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Title</title>
  {% block page-css %}
  
  {% endblock %}
</head>
<body>

<h1>这是母板的标题</h1>

{% block page-main %}

{% endblock %}
<h1>母板底部内容</h1>
{% block page-js %}

{% endblock %}
</body>
</html>

注意：我们通常会在母板中定义页面专用的CSS块和JS块，方便子页面替换。

【2】继承母板

在子页面中在页面最上方使用下面的语法来继承母板。

{% extends 'layouts.html' %}

【3】块（block）

通过在母板中使用{% block xxx %}来定义"块"。
在子页面中通过定义母板中的block名来对应替换母板中相应的内容。

{% block page-main %}
  <p>世情薄</p>
  <p>人情恶</p>
  <p>雨送黄昏花易落</p>
{% endblock %}

【4】组件

可以将常用的页面内容如导航条，页尾信息等组件保存在单独的文件中，然后在需要使用的地方按如下语法导入即可。

{% include 'navbar.html' %}

【七】静态文件加载

【1】

加载Django的静态文件

{% load static %}
<img src="{% static "images/hi.jpg" %}" alt="Hi!" />

引用JS文件时使用：

{% load static %}
<script src="{% static "mytest.js" %}"></script>

某个文件多处被用到可以存为一个变量

{% load static %}
{% static "images/hi.jpg" as myphoto %}
<img src="{{ myphoto }}"></img>

【2】

相当于获取到了 static 文件夹的文件夹绝对路径，从绝对路径再往下找静态文件

{% load static %}
<img src="{% get_static_prefix %}images/hi.jpg" alt="Hi!" />

或者

{% load static %}
{% get_static_prefix as STATIC_PREFIX %}

<img src="{{ STATIC_PREFIX }}images/hi.jpg" alt="Hi!" />
<img src="{{ STATIC_PREFIX }}images/hi2.jpg" alt="Hello!" />

【八】simple_tag

【1】介绍

许多模板标签接受多个参数——字符串或模板变量——并仅根据输入参数和一些额外信息进行某种处理，并返回结果。例如， current_time 标签可能接受一个格式字符串，并将时间按照字符串要求的格式返回。
为了简化创建标签类型的流程，Django 提供了一个助手函数， simple_tag。该函数实际是 django.template.Library 的一个方法，该函数接受任意个数的参数，将其封装在一个 render 函数以及上述其它必要的位置，并用模板系统注册它。
我们的 current_time 函数因此能这样写:

import datetime
from django import template

register = template.Library()

@register.simple_tag
def current_time(format_string):
    return datetime.datetime.now().strftime(format_string)

【2】 `simple_tag` 助手函数注意事项

检测要求参数的个数等在调用函数时就已完成，所以我们无需再做。
包裹参数（如果有的话）的引号已被删除，所以我们收到一个普通字符串。
如果参数是一个模板变量，函数将传递变量值，而不是变量本身。

【3】模板转义

若模板上下文处于自动转义模式，不像其它标签实体， simple_tag 通过 conditional_escape() 传递输出，为了确保输出正确的 HTML，避免 XSS 漏洞的威胁。
如果不需要额外转义，你可能需要在万分确定您的代码不会引入任何 XSS 漏洞的情况下使用 mark_safe()。如果只是构建小的 HTML 片段，强烈建议使用 format_html()，而不是 mark_safe()。

【4】访问上下文对象

若您的模板标签需要访问当前上下文，你可以在注册标签时传入 takes_context 参数:

@register.simple_tag(takes_context=True)
def current_time(context, format_string):
    timezone = context['timezone']
    return your_get_current_time_method(timezone, format_string)

注意，第一个参数必须是 context。
更多关于 takes_context 选项如何工作的信息，参见章节包含标签。

【5】重命名标签

若你需要重命名标签，你可以为其提供一个自定义名称:

register.simple_tag(lambda x: x - 1, name='minusone')

@register.simple_tag(name='minustwo')
def some_function(value):
    return value - 2

【6】接收参数

simple_tag 函数可以接受任意数量的位置或关键字参数。例如:

@register.simple_tag
def my_tag(a, b, *args, **kwargs):
    warning = kwargs['warning']
    profile = kwargs['profile']
    ...
    return ...

【7】在模板中使用

随后在模板中，任意数量的，以空格分隔的参数会被传递给模板标签。
与 Python 中类似，关键字参数的赋值使用等号（"="），且必须在位置参数后提供。例子：

{% my_tag 123 "abcd" book.title warning=message|lower profile=user.profile %}

将标签结果存入一个模板变量而不是直接将其输出是可能的。
这能通过使用 as 参数，后跟变量名实现。这样做能让你在期望的位置输出内容：

{% current_time "%Y-%m-%d %I:%M %p" as the_time %}
<p>The time is {{ the_time }}.</p>

【8】示例

（1）后端

新建一个文件存储自定义标签函数
app01/tags/my_tags.py

import datetime
from django import template

register = template.Library()


@register.simple_tag
def current_time(format_string):
    return datetime.datetime.now().strftime(format_string)


@register.simple_tag
def my_tag(a, b, *args, **kwargs):
    print(a)
    print(b)
    print(args)
    print(kwargs)
    warning = kwargs['warning']
    profile = kwargs['profile']
    print(warning)
    print(profile)
    ...
    return "OKK"

在Django中注册标签函数
settings.py

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'templates']
        ,
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
            # 新增一个配置项
            'libraries': {
                # 前端加载的标签名:标签函数所在的文件目录
                "my_tag": "app01.tags.my_tags",
            },
        },

    },
]

（2）前端

{% load my_tag %}
{% my_tag 123 "abcd" book.title warning=message|lower profile=user.profile %}
{% current_time "%Y-%m-%d %I:%M %p" as the_time %}
<p>The time is {{ the_time }}.</p>

OKK
The time is 2024-02-24 03:23 AM.

【九】inclusion_tag

多用于返回html代码片段
示例：
templatetags/my_inclusion.py

from django import template

register = template.Library()


@register.inclusion_tag('result.html')
def show_results(n):
    n = 1 if n < 1 else int(n)
    data = ["第{}项".format(i) for i in range(1, n+1)]
    return {"data": data}

templates/snippets/result.html

<ul>
  {% for choice in data %}
    <li>{{ choice }}</li>
  {% endfor %}
</ul>

templates/index.html

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>inclusion_tag test</title>
</head>
<body>

{% load inclusion_tag_test %}

{% show_results 10 %}
</body>
</html>

标签：return,value,Django,12.0,tag,模板,django,def
From： https://www.cnblogs.com/dream-ze/p/18081717

【12.0】Django框架之模板层

【零】Django模板系统

【一】模板语法的传值

【0】变量

（1）传值

（2）取值

（3）注意事项

【1】路由

【2】基本数据类型

（1）视图

（2）前端

（3）页面展示

【3】函数

（1）无返回值

（2）有返回值

（3）总结

【4】类与对象

（1）类与对象

（2）对象调用方法

（3）类对象内部的 __str__方法

【小结】

【二】模版语法的取值

【1】概述

【2】后端

【3】前端

【4】页面展示

【三】过滤器

【1】过滤器

（1）过滤器的语法

（2）注意事项

【2】语法

【3】计算长度(length)

（0）语法

（1）后端

（2）前端

（3）页面展示

（4）源码

【4】默认值(default)

（0）语法

（1）后端

（2）前端

（3）页面展示

（4）原理

（5）源码

【5】文件大小(filesizeformat)

（1）语法

（2）前端

（3）源码

【6】日期格式化(date)

（）语法

（0）后端

（1）原始格式

（2）格式化输出

【7】切片操作(slice)

【8】切取摘要(truncatechars)

（0）语法

（1）字符

（2）单词

【9】移除指定字符(cut)

（1）语法

（2）后端

（3）前端

【10】拼接字符(join)

【11】加法(add)

【12】取消转义(mark_safe和safe)

（1）前端转义(safe)

（2）后端转义(mark_safe)

【13】timesince

【14】timeuntil

【四】标签(Tags)

【1】for循环

（1）普通for循环

（2）for循环可用的一些参数：

（3）for ... empty

【2】if判断

（1）if ~ elif ~ else

（2）只有if和else

【3】with

【4】csrf_token

【5】注释

（3）类对象内部的 `str`方法

（1）`if ~ elif ~ else`

【2】 `simple_tag` 助手函数注意事项