Django模板

模板

在之前的章节中，视图函数只是直接返回文本，而在实际生产环境中其实很少这样用，因为实际的页面大多是带有样式的HTML代码，这可以让浏览器渲染出非常漂亮的页面。目前市面上有非常多的模板系统，其中最知名最好用的就是DTL和Jinja2。DTL是Django Template Language三个单词的缩写，也就是Django自带的模板语言。当然也可以配置Django支持Jinja2等其他模板引擎，但是作为Django内置的模板语言，和Django可以达到无缝衔接而不会产生一些不兼容的情况。因此建议大家学习好DTL。

DTL与普通的HTML文件的区别：

DTL模板是一种带有特殊语法的HTML文件，这个HTML文件可以被Django编译，可以传递参数进去，实现数据动态化。在编译完成后，生成一个普通的HTML文件，然后发送给客户端。

渲染模板

渲染模板有多种方式。这里讲下两种常用的方式。

1、render_to_string：找到模板，然后将模板编译后渲染成Python的字符串格式。最后再通过HttpResponse类包装成一个HttpResponse对象返回回去。

from django.template.loader import render_to_string
from django.http import HttpResponse
def book_detail(request, book_id):
	html = render_to_string("detail.html")
	return HttpResponse(html)

2、以上方式虽然已经很方便了。但是django还提供了一个更加简便的方式，直接将模板渲染成字符串和包装成HttpResponse对象一步到位完成。

from django.shortcuts import render
def book_list(request):
	return render(request, 'list.html')

注意：在较老的版本中有render_to_response()方法，此方法和render()类似，但已经被render()取代。

模板查找路径配置

在项目的settings.py文件中。有一个TEMPLATES配置，这个配置包含了模板引擎的配置，模板查找路径的配置，模板上下文的配置等。模板路径可以在两个地方配置。

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(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',
            ],
        },
    },
]

1、DIRS：这是一个列表，在这个列表中可以存放所有的模板路径，以后在视图中使用render或者render_to_string渲染模板的时候，会在这个列表的路径中查找模板。

2、APP_DIRS：默认为True，这个设置为True后，会在INSTALLED_APPS的安装了的APP下的templates文件加中查找模板。所以新建app之后别忘记将其添加到INSTALLED_APPS列表中。

3、查找顺序：比如代码render('list.html') 。先会在DIRS这个列表中依次查找路径下有没有这个模板，如果有就返回。如果DIRS列表中所有的路径都没有找到，那么会先检查当前这个视图所处的app是否已经安装，如果已经安装了，那么就先在当前这个app下的templates文件夹中查找模板，如果没有找到，那么会在其他已经安装了的app中查找。如果所有路径下都没有找到，那么会抛出一个TemplateDoesNotExist异常。

---

DTL模板语法

变量：

模板中可以包含变量，Django在渲染模板的时候，可以传递变量对应的值过去进行替换。变量的命名规范和Python非常类似，只能是阿拉伯数字和英文字符以及下划线的组合，不能出现标点符号等特殊字符。变量需要通过视图函数渲染，视图函数在使用render或者render_to_string的时候可以传递一个context的参数，这个参数是一个字典类型。以后在模板中的变量就从这个字典中读取值的。

# views.py代码
def profile(request):
	return render(request,'profile.html',context={'username':'onefine'})

在模版中使用变量，需要将变量放到{{ 变量 }}中。

# profile.html模板代码
<p>{{ username }}</p>

模板中的变量同样也支持点(.) 的形式。在出现了点的情况，比如person.username，模板是按照以下方式进行解析的：

1、如果 person 是一个字典，那么就会查找这个字典的 username 这个 key 对应的值。
2、如果 person 是一个对象，那么就会查找这个对象的 username 属性，或者是 username 这个方法。
3、如果出现的是 person.1 ，会判断 persons 是否是一个列表或者元组或者任意的可以通过下标访问的对象，如果是的话就取这个列表的第1个值。如果不是就获取到的是一个空的字符串。不能通过中括号的形式访问字典和列表中的值，比如dict[‘key’]和list[1]是不支持的！另外，使用点（.）语法获取对象值的时候，可以获取这个对象的属性，但如果这个对象是一个字典，也可以获取这个字典的值，这样就造成了歧义。所以在给这个字典添加key的时候，千万不能和字典中的一些属性重复。比如items， items是字典的方法，那么如果给这个字典添加一个items作为key，那么以后就不能再通过item来访问这个字典的键值对了。

如果想要访问对象的属性，那么可以通过对象.属性名来进行访问。

class Person(object):
	def __init__(self,username):
		self.username = username

	context = {
	   'person': p
	}

以后想要访问person的username，那么就是通过person.username来访问。

如果想要访问一个字典的key对应的value，那么只能通过字典.key的方式进行访问，不能通过中括号[]的形式进行访问。

context = {
	'person': {
		'username':'zhiliao'
	}
}

那么以后在模版中通过person.username访问username

因为在访问字典的key时候也是使用点.来访问，因此不能在字典中定义字典本身就有的属性名当作key，否则字典的那个属性将编程字典中的key了。

context = {
	'person': {
		'username':'zhiliao',
		'keys':'abc'
	}
}

以上因为将keys作为person这个字典的key了。因此以后在模版中访问person.keys的时候，返回的不是这个字典的所有key，而是对应的值。

如果想要访问列表或者元组，那么也是通过点.的方式进行访问，不能通过中括号[]的形式进行访问，这一点和python中是不一样的：

{{ persons.1 }}

---

常用的模板标签

from django.template import defaulttags包含这些默认标签的源码。

1、if标签：if标签相当于 Python 中的 if 语句，有 elif 和 else 相对应，但是所有的标签都需要用标签符号({% %})进行包裹。 if 标签中可以使用 ==、 !=、 <、 <=、 >、 >=、 in、 not in、 is、 is not 等判断运算符。

{% if "张三" in persons %}
	<p>张三</p>
{% else %}
	<p>李四</p>
{% endif %}

注意：if标签有闭合标签{% endif %}。

2、for...in...标签：for...in...类似于 Python 中的for...in...。可以遍历列表、元组、字符串、字典等一切可以遍历的对象。

<ul>
{% for book in books %}
	<li>{{ book }}li>
{% endfor %}
ul>

如果想要反向遍历，那么在遍历的时候就加上一个reversed：

{% for person in persons reversed %}
	<p>{{ person.name }}</p>
{% endfor %}

遍历字典的时候，需要使用items、keys和values等方法。在 DTL 中，执行一个方法不能使用圆括号的形式。
遍历字典示例代码如下：

{% for key, value in person.items %}
	<p>key： {{ key }}</p>
	<p>value： {{ value }}</p>
{% endfor %}

在 for 循环中， DTL 提供了一些变量可供使用。这些变量如下：

变量	说明
forloop.counter	当前循环的下标。以1作为起始值。
forloop.counter0	当前循环的下标。以0作为起始值。
forloop.revcounter	当前循环的反向下标值。比如列表有5个元素，那么第一次遍历这个属性是等于5，第二次是4，以此类推。并且是以1作为最后一个元素的下标。
forloop.revcounter0	类似于forloop.revcounter。不同的是最后一个元素的下标是从0开始。
forloop.first	是否是第一次遍历。
forloop.last	是否是最后一次遍历。
forloop.parentloop	如果有多个循环嵌套，那么这个属性代表的是上一级的for循环。

用法如下：

<table>
	<thead>
		<tr>
			<td>序号td>
			<td>书名td>
			<td>作者td>
			<td>价格td>
		tr>
	thead>
	<tbody>
	{% for book in books %}
		{% if forloop.first %}
			<tr style="background: red;">
		{% elif forloop.last %}
			<tr style="background: pink;">
		{% else %}
			<tr>
		{% endif %}
				
				<td>{{ forloop.counter }}td>
				<td>{{ book.name }}td>
				<td>{{ book.author }}td>
				<td>{{ book.price }}td>
			tr>
	{% endfor %}
	tbody>
table>

注意：DTL中没有break和continue语句！

3、for...in...empty标签：这个标签使用跟for...in...是一样的，只不过是在遍历的对象如果没有元素的情况下，会执行empty中的内容:

<ul>
	{% for comment in comments %}
		<li>{{ comment }}</li>
	{# 如果comment中没有值，则执行empty里面的内容，否则不执行 #}
	{% empty %}
		<li>没有任何评论</li>
	{% endfor %}
</ul>

4、with标签：在模版中定义变量。
有时候一个变量访问的时候比较复杂，那么可以先把这个复杂的变量缓存到一个变量上，以后就可以直接使用这个变量就可以了:

context = {
	"persons": ["张三","李四"]
}

{# 在模板中定义变量 #}
{% with lisi=persons.1 %}
	<p>{{ lisi }}</p>
{% endwith %}

注意：

• 在with语句中定义的变量，只能在{%with%}{%endwith%}中使用，不能在这个标签外面使用。
• 定义变量的时候，不能在等号左右两边留有空格。比如 {% with lisi = persons.1%} 是错误的。

还有另外一种写法同样也是支持的：

{% with persons.1 as lisi %}
	<p>{{ lisi }}</p>
{% endwith %}

5、url标签：在模版中，我们经常要写一些url，比如某个a标签中需要定义href属性。当然如果通过硬编码的方式直接将这个url写死在里面也是可以的，但是这样对于以后项目维护可能不是一件好事。因此建议使用这种反转的方式来实现，类似于django中的reverse一样:

<a href="{% url 'book:list' %}">图书列表页面</a>

如果 url 反转的时候需要传递参数，那么可以在后面传递。但是参数分位置参数和关键字参数。位置参数和关键字参数不能同时使用:

# path部分
path('detail//',views.book_detail,name='detail')

使用位置参数：

# url反转，使用位置参数
<a href="{% url 'book:detail' 1 %}">图书详情页面</a>

使用关键字参数：

# url反转，使用关键字参数
<a href="{% url 'book:detail' book_id=1 %}">图书详情页面</a>

如果想要在使用 url 标签反转的时候要传递查询字符串的参数，那么必须要手动在在后面添加:

<a href="{% url 'book:detail' book_id=1 %}?page=1">图书详情页面</a>

如果需要传递多个参数，那么通过空格的方式进行分隔。示例代码如下：

<a href="{% url 'book:detail' book_id=1 page=2 %}">图书详情页面</a>

一个栗子：

urls.py中：

from django.urls import path
from . import views

# 应用命名空间，url反转的时候有用——index.html文件中用到
app_name = 'app03'

urlpatterns = [
    path('', views.index, name='index'),
    path('book/', views.book, name='book'),
    path('movie/', views.movie, name='movie'),
    path('city/', views.city, name='city'),
    path('book/detail///', views.book_detail, name='detail'),
    path('login/', views.login, name='login')
]

views.py中：

from django.shortcuts import render
from django.http import HttpResponse


def index(request):
	# 这里加上appname
    return render(request, 'app03/index.html')


def login(request):
    next_page = request.GET.get('next')
    if next_page:
        text = '登录页面，登录完成后要跳转的url是：%s' % next_page
    else:
        text = '登录页面'
    return HttpResponse(text)


def book(request):
    return HttpResponse("读书页面")


def book_detail(request, book_id, category):
    text = '您的图书的id是：%s，分类是：%s' % (book_id, category)
    return HttpResponse(text)


def movie(request):
    return HttpResponse("电影页面")


def city(request):
    return HttpResponse('同城页面')

此外，在项目下urls.py中添加一条路由：

# 在使用实例命名空间之前，必须先指定一个应用命名空间——在子url.py中添加app_name变量。
# 这里实际上没必要用实例命名空间。也就是说可以省略。
path('app03/', include('apps.app03.urls', namespace='app03')),

接着：\apps\app03\templates\app03\index.html中：

<html lang="zh-cn">
<head>
    <meta charset="UTF-8">
    <title>app03/index.htmltitle>
    <style>
        .nav{
            overflow: hidden;
        }
        .nav li{
            float: left;
            list-style: none;
            margin: 0 20px;
        }
    style>
head>
<body>
    <ul class="nav">
        <li><a href="{% url 'app03:index' %}">首页a>li>
        <li><a href="{% url 'app03:book' %}">读书a>li>
        <li><a href="{% url 'app03:movie' %}">电影a>li>
        <li><a href="{% url 'app03:city' %}">同城a>li>
        <li><a href="{% url 'app03:detail' book_id='1' category=1 %}">最火的一篇文章a>li>
        <li><a href="{% url 'app03:login' %}?next=/">登录a>li>
    ul>
body>
html>

注意：DTL文件存放在templates下与app名同名的目录下。
详细原因见： https://blog.csdn.net/jiduochou963/article/details/87397560

6、spaceless标签：移除html标签中的空白字符。包括空格、 tab键、换行等：

{% spaceless %}
	<p>
		<a href="foo/">Foo</a>
	</p>
{% endspaceless %}

那么在渲染完成后，会变成以下的代码：

<p><a href="foo/">Foo</a></p>

spaceless只会移除html标签之间的空白字符，而不会移除标签与文本之间的空白字符：

{% spaceless %}
	<strong>
		  Hello
	strong>
{% endspaceless %}

这个将不会移除 strong 中的空白字符。

7、autoescape标签：开启和关闭这个标签内元素的自动转义功能。自动转义是可以将一些特殊的字符。比如<转义成 html 语法能识别的字符，比如<会被转义成<，而>会被自动转义成>。模板中默认是已经开启了自动转义的，避免XSS漏洞。

views.py中：

# 传递的上下文信息
context = {
	"info":"百度"
}
return render(request, 'index.html', context=context)

html中：

{{ info }}

在浏览器中显示的就是普通字符串：百度

在模板中关闭自动转义：

# 默认开启自动转义，模板中关闭自动转义使用off
{% autoescape off %}
	{{ info }}
{% endautoescape %}

那么就会显示百度的一个超链接。如果把off换成on，那么就会显示成一个普通的字符串:

{% autoescape on %}
	{{ info }}
{% endautoescape %}

8、verbatim标签：默认在 DTL 模板中是会去解析那些特殊字符的。比如 {% 和 %} 以及 {{ 等。如果你在某个代码片段中不想使用 DTL 的解析引擎，那么可以把这个代码片段放在verbatim标签中：

{% verbatim %}
	{{if dying}}Still alive.{{/if}}
{% endverbatim %}

浏览器中出现的就是普通字符串：{{if dying}}Still alive.{{/if}}

9、更多标签请参考官方文档： https://docs.djangoproject.com/en/2.0/ref/templates/builtins/

---

模版常用过滤器

在模版中，有时候需要对一些数据进行处理以后才能使用。在 Python 中一般是通过函数的形式来完成的，而在DTL模版中，则是通过过滤器来实现的。过滤器使用的是|来使用。比如使用add过滤器：

{{ value|add:"2" }}

为啥要使用过滤器呢？
首先在views.py中响应函数：

def say_hello():
    return "hello"

def index(request):
    context = {
        'say': say_hello
    }
    return render(request, 'index.html', context=context)

接着index.html中：

{{ say }}

我们尝试给此函数添加参数：

# views.py文件中
def say(word):
    return "you say: %s" % word

def index(request):
    context = {
        'say': say
    }
    return render(request, 'index.html', context=context)

index.html文件中尝试：

{{ say('hello onefine') }}

结果报错了，在DTL中，不支持函数调用形式()，因此不能给函数传递参数，这对函数的使用带来很大的局限性，使用引用过滤器。那么以下先介绍开发中几个开发中常用的过滤器，这些过滤器就像内置函数一样，可以对需要处理的参数进行处理，并且可以额外接收一个参数(也就是说最多只能有两个参数，至于上面的解决方法等到介绍完过滤器之后再讲)。

from django.template import defaultfilters包含这些默认过滤器的源码。

add过滤器：

将传进来的参数添加到原来的值上面：这个过滤器会尝试将值和参数转换成整形然后进行相加。如果转换成整形过程中失败了，那么会将值和参数进行拼接。如果是字符串，那么会拼接成字符串，如果是列表，那么会拼接成一个列表：

...
context = {
    'value': '4'
    # 'value': 4
    # 'value': abc
}
return render(request, 'index.html', context=context)

{{ value|add:"2" }}
# 类似于函数调用add(value, "2")

如果 value 是等于4，那么结果将是6。如果 value 是等于一个普通的字符串，比如 abc ，那么结果将是 abc2 。

add 过滤器的源代码如下：

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

如果是列表：
views.py中：

...
context = {
    'value1': ['1', '2', '3'],
    'value2': ['4', '5', 6],
}
return render(request, 'index.html', context=context)

index.html中：

{{ value1|add:value2}}

cut过滤器：

移除值中所有指定的字符串，类似于 python 中的replace(args, "")：

{{ value|cut:" " }}

以上示例将会移除 value 中所有的空格字符。

cut过滤器的源代码如下：

def cut(value, arg):
	"""Remove all values of arg from the given string."""
	safe = isinstance(value, SafeData)
	value = value.replace(arg, '')
	if safe and arg != ';':
		return mark_safe(value)
	return value

date过滤器

将一个日期按照指定的格式，格式化成字符串：

# 数据
from datetime import datetime
	...
	
	context = {
		# 获取系统当前日期
		"today": datetime.now()
	}
	return render(request, 'index.html', context=context)

index.html中

# 按照2018/02/15的格式输出，/也输出；换成'-', ' '等等
{{ today|date:"Y/m/d" }}

那么将会输出 2018/02/01 。其中 Y 代表的是四位数字的年份， m 代表的是两位数字的月份， d 代表的是两位数字的日。

还有更多常用时间格式化的方式，见下表：

格式字符	描述	示例
Y	四位数字的年份	2018
m	两位数字的月份	01-12
n	月份， 1-9前面没有0前缀	1-12
d	两位数字的天	01-31
j	天，但是1-9前面没有0前缀	1-31
g	小时， 12小时格式的， 1-9前面没有0前缀	1-12
h	小时， 12小时格式的， 1-9前面有0前缀	01-12
G	小时， 24小时格式的， 1-9前面没有0前缀	1-23
H	小时， 24小时格式的， 1-9前面有0前缀	01-23
i	分钟， 1-9前面有0前缀	00-59
s	秒， 1-9前面有0前缀	00-59

还有其他不常用的没有列出，请参阅官方文档： https://docs.djangoproject.com/en/2.0/ref/templates/builtins/#date

default过滤器

如果值被评估为False。比如 []、""、None、{} 等这些在 if 判断中为False的值，都会使用default过滤器提供的默认值：

{{ value|default:"nothing" }}

如果value是等于一个空的字符串。比如""，那么以上代码将会输出 nothing 。

default_if_none过滤器

如果值是None，那么将会使用default_if_none提供的默认值。这个和default有区别，default是所有被评估为False的都会使用默认值。而default_if_none则只有这个值是等于None的时候才会使用默认值：

{{ value|default_if_none:"nothing" }}

如果value是等于""也即空字符串，那么以上会输出空字符串。如果value是一个None值，以上代码才会输出nothing。

first过滤器

返回列表/元组/字符串中的第一个元素：

{{ value|first }}

如果 value 是等于['a','b','c']，那么输出将会是 a 。

last过滤器

返回列表/元组/字符串中的最后一个元素：

{{ value|last }}

如果 value 是等于['a','b','c']，那么输出将会是c。

floatformat过滤器

使用四舍五入的方式格式化一个浮点类型。如果这个过滤器没有传递任何参数，那么默认只会在小数点后保留一个小数，如果小数后面全是0，那么只会保留整数。当然也可以传递一个参数，标识具体要保留几个小数。

1、如果没有传递参数：

value	模版代码	输出
34.23234	{{ value|floatformat }}	34.2
34.000	{{ value|floatformat }}	34
34.260	{{ value|floatformat }}	34.3

2、如果传递参数：

value	模版代码	输出
34.23234	{{ value|floatformat:3 }}	34.232
34.0000	{{ value|floatformat:3 }}	34.000
34.26000	{{ value|floatformat:3 }}	34.260

join过滤器

类似与 Python 中的join，将列表/元组/字符串用指定的字符进行拼接：

# 可以自行制定分隔符，这里是'/'
{{ value|join:"/" }}

如果 value 是等于 [‘a’,‘b’,‘c’] ，那么以上代码将输出 a/b/c 。

length过滤器

获取一个列表/元组/字符串/字典的长度：

{{ value|length }}

如果 value 是等于['a','b','c']，那么以上代码将输出 3 。如果value为None，那么以上将返回 0 。

lower过滤器

将值中所有的字符全部转换成小写：

{{ value|lower }}

如果 value 是等于Hello World。那么以上代码将输出hello world。

upper过滤器

类似于lower，只不过是将指定的字符串全部转换成大写。

random过滤器

在被给的列表/字符串/元组中随机的选择一个值：

{{ value|random }}

如果value是等于['a','b','c']，那么以上代码会在列表中随机选择一个。

safe过滤器

标记一个字符串是安全的，也即会关掉这个字符串的自动转义：

{{value|safe}}

如果value是一个不包含任何特殊字符的字符串，比如（注意这里这是便签不成对）这种，那么以上代码就会把字符串正常的输入。如果value是一串html代码，那么以上代码将会把这个html代码渲染到浏览器中。

比如：

...
context = {
	'value': ""
}
return render(request, 'index.html', context=context)

index.html中：

{{ value|safe }}

然后弹出对话框。如果是{{ value}}，那就将输出一个普通字符串：。
{{ value|safe }}等价于：

{% autoescape off %}
    {{ value }}
{% endautoescape %}

slice过滤器

类似于 Python 中的切片操作：

{{ some_list|slice:"2:" }}

以上代码将会给 some_list 从 2 开始做切片操作。

In [1]: a = [1, 2, 3, 4, 5]

In [2]: a[0:2]
Out[2]: [1, 2]

In [3]: a[1,]
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-3-c7c5816a8048> in <module>
----> 1 a[1,]

TypeError: list indices must be integers or slices, not tuple

In [4]: a[1:]
Out[4]: [2, 3, 4, 5]

In [5]: a[:]
Out[5]: [1, 2, 3, 4, 5]

In [6]: a[:-1]
Out[6]: [1, 2, 3, 4]

In [7]: a[::2]
Out[7]: [1, 3, 5]

In [8]:

只要将[]里面的内容写进去{{ some_list|slice:"" }}就行

stringtags过滤器

删除字符串中所有的html标签：

{{ value|striptags }}

如果 value 是hello world，那么以上代码将会输出hello world。

truncatechars过滤器

如果给定的字符串长度超过了过滤器指定的长度。那么就会进行切割，并且会拼接三个点来作为省略号：

{{ value|truncatechars:5 }}

如果 value 是等于北京欢迎您~，那么输出的结果是北京...。可能你会想，为什么不是北京欢迎您...呢。因为三个点也占了三个字符，所以北京 +三个点的字符长度就是5。

truncatechars_html过滤器

类似于truncatechars，但它不会切割html标签：

{{ value|truncatechars:5 }}

如果 value 是等于

北京欢迎您~

，那么输出将是

北京...

。

更多过滤器请查阅官方文档： https://docs.djangoproject.com/zh-hans/2.0/ref/templates/builtins/

自定义模板过滤器

虽然DTL给我们内置了许多好用的过滤器，但是有时候还是不能满足我们的需求。因此Django给我们提供了自定义过滤器的接口，以方便满足自己的需求。

模板过滤器必须放置在app下(无论哪一个app，并且这个app必须在INSTALLED_APPS中进行安装)，然后再在这个app下面创建一个名为templatetags（此包名固定）的package，再在这个包下面创建一个python文件（这个文件名可以任意）存放自定义的模板过滤器。

过滤器实际上就是python中的一个函数，只不过是吧这个函数注册到模板库中，以后在模板中就可以使用这个函数(过滤器)了。作为过滤器，这个函数的参数有着特殊的限制，第一个参数必须是过滤器需要处理的值，第二个参数可以省略，如果有第二个参数，那么句意味着在这个模板过滤器中可以传递参数。总之，作为过滤器的函数最多只能有两个参数。写完过滤器后，再使用django.template.Library对象将自定义的过滤器注册进去。然后在DTL模板中使用load标签加载过滤器所在的python文件，就可以使用自定义的过滤器了。

1、\apps\app04\templatetags\self_filter.py中：

from django import template

register = template.Library()

def say_hello(name, word):
    """
    :param name: 过滤器的左边值，被过滤器处理的值
    :param word: 使用过滤器时向此函数传递的参数，可以省略
    :return: 两个值拼接
    """
    # 过滤器最多只能是两个参数
    return word+' '+name


# 注册过滤器，第一个参数是定义使用时的过滤器名称，使用时调用此名称即可
# 第二个参数是自定义过滤器的函数名称
register.filter("my_filter", say_hello)

2、\urls.py中配置：path('app04/', include('apps.app04.urls')),

3、\settings.py中配置安装app04。

4、\apps\app04\urls.py中添加路由：path('', views.index),

5、apps/app04/views.py中：

from django.shortcuts import render

def index(request):
    context = {
        'value': 'onefine',
    }
    return render(request, 'app04/index.html', context=context)

6、apps/app04/templates/app04/index.html中：

{% load self_filter %}

<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>app04-index.htmltitle>
head>
<body>
	
    {{ value|my_filter:"hello" }}
body>
html>

访问： http://127.0.0.1:8000/app04/

注意：此DTL文件存放在templates下与app同名的目录下。
详细原因见： https://blog.csdn.net/jiduochou963/article/details/87397560

一个栗子：时间计算过滤器，在这个栗子中你可以看到装饰器的用法。
有时候经常在朋友圈、微博中可以看到一条信息的发表时间，并不常常是具体的时间，而是距离现在多久，比如刚刚、1分钟前等等。我们可以自定义模板过滤器来实现这种功能。
1、需求:

1. 如果时间间隔小于1分钟以内，那么就显示"刚刚"
2. 如果时间间隔大于1分钟小于1小时，那么就显示"xx分钟前"
3. 如果时间间隔大于1小时小于24小时，那么就显示"xx小时前"
4. 如果时间间隔大于24小时小于30天以内，那么就显示"xx天前"
5. 否则就显示具体时间 如2018/02/16 01:32

2、apps/app05/templatetags/self_filter.py中：

from django import template
from datetime import datetime

register = template.Library()

# 第二种方式
# 装饰器，装饰器的参数定义过滤器名称
@register.filter("my_time_since")
def time_since(value):
    if not isinstance(value, datetime):
        return value
    now_time = datetime.now()

    # total_seconds将时间转换为秒
    print("now_time：", now_time)
    print("value：", value)

    timestamp = (now_time - value).total_seconds()
    print(":", now_time-value)
    print("timestamp：", timestamp)

    if timestamp < 60:
        return "刚刚"
    elif timestamp >= 60 and timestamp < 60 * 60:
        minutes = int(timestamp / 60)
        return "%s分钟前" % minutes
    elif timestamp >= 60 * 60 and timestamp < 60 * 60 * 24:
        hours = int(timestamp / 60 / 60)
        return "%s小时前" % hours
    elif timestamp >= 60 * 60 * 24 and timestamp < 60 * 60 * 24 * 30:
        days = int(timestamp / 60 / 60 / 24)
        return "%s天前" % days
    else:
        return value.strftime("%Y/%m/%d %H:%M")

3、apps/app05/urls.py中添加url路由

from . import views
from django.urls import path

urlpatterns = [
    path('', views.index),
]

4、apps/app05/views.py中添加响应函数

from django.shortcuts import render
from datetime import datetime

def index(request):
    context = {
    	# 测试数据：构造时间
        # 'my_time': datetime(year=1996, month=3, day=1, hour=18, minute=0, second=0),
        'my_time': datetime(year=2019, month=2, day=16, hour=11, minute=23, second=0),
    }
    return render(request, 'app05/index.html', context=context)

5、apps/app05/templates/app05/index.html

{% load self_filter %}

<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
    {{ my_time|my_time_since }}
body>
html>

6、注意请不要忘记/settings.py和/urls.py中的配置。

# /settings.py中添加路由
path('app05/', include('apps.app05.urls')),

# /urls.py中安装app
'apps.app05',

注意：django.template.Library.filter可以当做装饰器来使用。如果filter函数没有传递任何参数，那么将默认使用这个函数的名字来作为过滤器的名字。如果给装饰器传递name参数，那么将会使用此值作为过滤器的名称。

---

模版结构优化

提供两种方式，分别是引入模板和模板继承。

引入模版——include标签

有时候一些代码是在许多模版中都用到的，如果每次都重复的去拷贝相同的代码那肯定不符合项目的规范，可以类似于Python中的函数一样把这些重复性的代码抽取出来，以后想要使用这些代码的时候就通过include标签包含进来。

1、apps/app06/templates/app06中：

# header.html
<header>
    <li><a href="{% url 'index' %}">首页a>li>
    <li><a href="{% url 'company' %}">公司a>li>
    <li><a href="{% url 'school' %}">学校a>li>
    <li>欢迎{{ username }}li>
header>

# footer.html
<footer>
    这是footer部分
footer>

# index.html

<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
    {% include 'app06/header.html' %}
    <p>这是首页p>
    {% include 'app06/footer.html' %}
body>
html>

# company.html

<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
    {% include 'app06/header.html' %}
    <p>这是companyp>
    {% include 'app06/footer.html' %}
body>
html>

# school.html

<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
    {% include 'app06/header.html' %}
    <p>这是schoolp>
    {% include 'app06/footer.html' %}
body>
html>

2、apps/app06/urls.py中配置url路由

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name="index"),
    path('school/', views.school, name="school"),
    path('company/', views.company, name="company"),


]

3、apps/app06/views.py中视图函数

from django.shortcuts import render

def index(request):
    context = {
        'username': 'onefine'
    }
    return render(request, 'app06/index.html', context=context)


def company(request):
    return render(request, 'app06/company.html')


def school(request):
    return render(request, 'app06/school.html')

注：

1. 由于username只是给index.html页面传递过去，所以其他页面引用模板的时候就取不到username值。
2. include 标签寻找路径的方式，也是跟render渲染模板的函数是一样的。默认 include 标签包含模版，会自动的使用主模版中的上下文，也即可以自动的使用主模版中的变量。
3. 使用include的时候，如果想要通过html页面给模板传递一些其他参数，可以使用with 参数名=值的形式：

<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
    {% include 'app06/header.html' with username='hahaha'%}
    <p>这是companyp>
    {% include 'app06/footer.html' %}
body>
html>

---

可以看出 由于username只是给index.html页面传递过去，所以其他页面引用模板的时候就取不到username值。

模板继承

在前端页面开发中。有些代码是需要重复使用的，这种情况可以使用 include 标签来实现。也可以使用另外一个比较强大的方式来实现，那就是模版继承。模版继承类似于 Python 中的类，在父类中可以先定义好一些变量和方法，然后在子类中实现。模版继承也可以在父模版中先定义好一些子模版需要用到的代码，然后子模版直接继承就可以了。并且因为子模版肯定有自己的不同代码，因此可以在父模版中定义一个block接口，然后子模版再去实现。
1、apps/app07/urls.py

from django.urls import path
from . import views

app_name = 'app07'

urlpatterns = [
    path('', views.index, name="index"),
    path('school/', views.school, name="school"),
    path('company/', views.company, name="company"),

]

2、apps/app07/views.py

from django.shortcuts import render

def index(request):
    context = {
        'username': 'onefine'
    }
    return render(request, 'app07/index.html', context=context)


def company(request):
    return render(request, 'app07/company.html')


def school(request):
    return render(request, 'app07/school.html')

3、apps/app07/templates/app07中：

# apps/app07/templates/app07/base.html

<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<header>
    <ul>
        <li><a href="{% url 'app07:index' %}">首页a>li>
        <li><a href="{% url 'app07:company' %}">公司a>li>
        <li><a href="{% url 'app07:school' %}">学校a>li>
        <li>欢迎{{ username }}li>
    ul>
header>
<div class="context">
    {% block content %}
    
        
        <p>我是父模板中的content代码p>
    {% endblock %}
div>
<footer>
    <p>这是footer部分p>
footer>
body>
html>

# apps/app07/templates/app07/index.html
{% extends 'app07/base.html' %}
{# 注意：extends标签必须放首行 #}



{% block content %}
    <p>这是首页的代码p>
{% endblock %}

#apps/app07/templates/app07/company.html
{% extends 'app07/base.html' %}
{# 注意：extends标签必须放首行 #}



{% block content %}
    <p>这是company的代码p>
    {#  调用父模板的内容   #}
    {{ block.super }}
{% endblock %}

# apps/app07/templates/app07/school.html
{% extends 'app07/base.html' %}

{#   这里不写内容，将调用父模板的默认内容 #}
{#{% block content %}#}
{#    <p>这是school的代码p>#}
{#{% endblock %}#}

# 这是school的代码，注意：放置在外面的语句将不会被django渲染。

示例代码：

{% load static %}

<html lang="en">
<head>
	<link rel="stylesheet" href="{% static 'style.css' %}" />
	<title>{% block title %}我的站点{% endblock %}title>
head>
<body>
	<div id="sidebar">
		{% block sidebar %}
		<ul>
			<li><a href="/">首页a>li>
			<li><a href="/blog/">博客a>li>
		ul>
		{% endblock %}
	div>
	<div id="content">
		{% block content %}{% endblock %}
	div>
body>
html>

这个模版，我们取名叫做 base.html ，定义好一个简单的 html 骨架，然后定义好两个 block 接口，让子模版来根据具体需求来实现。子模板然后通过 extends 标签来实现，示例代码如下：

{% extends "base.html" %}
{% block title %}博客列表{% endblock %}
{% block content %}
	{% for entry in blog_entries %}
		<h2>{{ entry.title }}</h2>
		<p>{{ entry.body }}</p>
	{% endfor %}
{% endblock %}

注意：

1. extends标签必须放在模版的第一行。
2. 子模板中的代码必须放在block中，否则将不会被渲染。
3. 如果在某个 block 中需要使用父模版的内容，那么可以使用 {{block.super}} 来继承。比如上例， {%block title%} ，如果想要使用父模版的 title ，那么可以在子模版的 title block 中使用 {{ block.super }} 来实现。
4. 在定义 block 的时候，除了在 block 开始的地方定义这个 block 的名字，还可以在 block 结束的时候定义名字。比如 {% block title %}{% endblock title %} 。这在大型模版中显得尤其有用，能让你快速的看到 block 包含在哪里。

加载静态文件

在一个网页中，不仅仅只有一个html骨架，还需要css样式文件，js执行文件以及一些图片等。因此在DTL中加载静态文件是一个必须要解决的问题。在DTL中，使用static标签来加载静态文件。要使用static标签，首先需要{% load static %}。加载静态文件的步骤如下：

1. 首先确保 django.contrib.staticfiles 已经添加到 settings.INSTALLED_APPS 中。

2. 确保在 settings.py 中设置了 STATIC_URL 。

   # 在浏览器中请求静态文件的url
   # 127.0.0.1/static/bootstrap/bootstrap.css
   STATIC_URL = '/static/'
   

3. 在已经安装了的app下创建一个文件夹叫做static，然后再在这个static文件夹下创建一个当前app的名字的文件夹，再把静态文件放到这个文件夹下。例如你的app叫做book，有一个静态文件叫做onefine.jpg，那么路径为book/static/book/oenfine.jpg。（为什么在 app 下创建一个static文件夹，还需要在这个static下创建一个同app名字的文件夹呢？原因是如果直接把静态文件放在static文件夹下，那么在模版加载静态文件的时候就是使用 onefine.jpg ，如果在多个app之间有同名的静态文件，这时候可能就会产生混淆。而在static文件夹下加了一个同名app文件夹，在模版中加载的时候就是==使用/onefine.jpg，==这样就可以避免产生混淆。）

4. 如果有一些静态文件是不和任何app挂钩的。那么可以在 settings.py 中添加 STATICFILES_DIRS ，以后 DTL 就会在这个列表的路径中查找静态文件。比如可以设置为:

   STATICFILES_DIRS = [
   	os.path.join(BASE_DIR, "static"),
   ]
   

5. 在模版中使用load标签加载static标签，比如要加载在项目的static文件夹下的style.css的文件：

   {% load static %}
   <link rel="stylesheet" href="{% static 'style.css' %}">
   

6. 如果不想每次在模版中加载静态文件都使用load加载static标签，那么可以在settings.py中的TEMPLATES/OPTIONS添加'builtins':['django.templatetags.static']，这样以后在模版中就可以直接使用static标签，而不用手动的load了。

7. 如果没有在settings.INSTALLED_APPS中添加django.contrib.staticfiles，那么就需要手动的将请求静态文件的 url 与静态文件的路径进行映射了：

   from django.conf import settings
   from django.conf.urls.static import static
   
   urlpatterns = [
   	# 其他的url映射
   ] + static(settings.STATIC_URL, document_root=settings.STATICFILES_DIRS[0])
   

注：不使用缓存去直接加载一个页面ctrl+shift+r

---