模板语法
文件目录
python的模板：HTML代码＋模板语法
1.模板语法之--变量
总url分发器urls.py
from django.contrib import admin
from django.urls import path,re_path
from app01 import views
urlpatterns = [
path('admin/', admin.site.urls),
re_path(r"index/", views.index),
# re_path的路径前面不能加 /
]
app01/views.py
from django.shortcuts import render
from django.shortcuts import HttpResponse
def index(request):
"""
模板语法：
变量：{{}}
1.深度查询 句点符号 .
2.过滤器 {{val|filter_name:参数}}
标签：{% %}
"""
name = "yuan"
i = 10
l = [111,222,333]
info = {"name":"yuan","age":22}
b = True
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
alex = Person("alex",23)
egon = Person("egon",23)
person_list=[alex,egon]
# return render(request,"index.html")
# locals()返回当前的所有局部变量字典，如{"name":"yuan",...}
return render(request,"index.html",locals())
templates/index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>变量</h1>
<p>{{ n }}</p>
<p>{{ i }}</p>
<p>{{ info }}</p>
<p>{{ l }}</p>
<p>{{ alex }}</p>
<p>{{ person_list }}</p>
<p>{{ b }}</p>
<h2>深度查询通过句点符号 .</h2>
<p>{{ l.1 }}</p>比如访问一个列表的下标为1的元素
<p>{{ info.name }}</p>
<p>{{ alex.name }}</p>
<p>{{ alex.age }}</p>
<p>{{ person_list.2.age }}</p>
<p>{{ l.1 }}</p>
</body>
</html>
2.过滤器
作用是将变量按照特定的形式展现出来
语法：{{obj|filter__name:param}} param可选，根据过滤器需求填写，过滤器可自定义(后面详细讲)
常用的过滤器
default
如果一个变量是false或者为空，使用给定的默认值。否则，使用变量的值。例如：
{{ value|default:"nothing" }}
length
返回值的长度。它对字符串和列表都起作用。例如：
{{ value|length }}
# 如果 value 是 ['a', 'b', 'c', 'd']，那么输出是 4。
filesizeformat
将值格式化为一个 “人类可读的” 文件尺寸 （例如 '13 KB', '4.1 MB', '102 bytes', 等等）。例如：
{{ value|filesizeformat }}
# 如果 value 是 123456789，输出将会是 117.7 MB。
date
# 如果 value=datetime.datetime.now()
{{ value|date:"Y-m-d" }}
slice
# 如果 value="hello world"
{{ value|slice:"2:-1" }}
truncatechars
如果字符串字符多于指定的字符数量，那么会被截断。截断的字符串将以可翻译的省略号序列（“...”）结尾。
参数：要截断的字符数
{{ value|truncatechars:9 }}
safe
Django的模板中会对HTML标签和JS等语法标签进行自动转义，原因显而易见，这样是为了安全。但是有的时候我们可能不希望这些HTML元素被转义，比如我们做一个内容管理系统，后台添加的文章中是经过修饰的，这些修饰可能是通过一个类似于FCKeditor编辑加注了HTML修饰符的文本，如果自动转义的话显示的就是保护HTML标签的源文件。为了在Django中关闭HTML的自动转义有两种方式，如果是一个单独的变量我们可以通过过滤器“|safe”的方式告诉Django这段代码是安全的不必转义。比如：
value="<a href="">点击</a>"
{{ value|safe}}
更多过滤器请参考：
[点击我！](https://www.cnblogs.com/huangxm/p/6286144.html)
示例
view_demo/urls.py 与 view_demo/setting.py配置同上！
app01/views.py
from django.shortcuts import render
import datetime
def index(request):
# 模板语法
"""
模板语法：
变量：{{}}
1.深度查询 句点符号 .
2.过滤器 {{val|filter_name:参数}} 参数可选
标签：{% %}
"""
name = "yuan"
i = 10
l = [111,222,333]
info = {"name":"yuan","age":22}
b = True
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
alex = Person("alex",23)
egon = Person("egon",23)
person_list=[alex,egon]
none_list = []
# 过滤器讲解，过滤器就是把数据暗按照特定的方式显现出来
now = datetime.datetime.now()
file_size = 2018
myString = "This is deluoruisi"
link = "<a href='#'>click</a>"
# locals()返回当前的所有局部变量字典，如{"name":"yuan",...}
return render(request,"index.html",locals())
templates/index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>变量</h1>
<p>{{ n }}</p>
<p>{{ i }}</p>
<p>{{ info }}</p>
<p>{{ l }}</p>
<p>{{ alex }}</p>
<p>{{ person_list }}</p>
<p>{{ b }}</p>
<h2>深度查询通过句点符号 .</h2>
<p>{{ l.1 }}</p>比如访问一个列表的下标为1的元素
<p>{{ info.name }}</p>
<p>{{ alex.name }}</p>
<p>{{ alex.age }}</p>
<p>{{ person_list.2.age }}</p>
<p>{{ l.1 }}</p>
<h2>过滤器</h2>
{#date是一个特定的过滤器，不能随便改名字 {{val|filter_name:参数}} #}
<p>{{ now|date:"Y-m-d" }}</p>
{# none_list如果为空，则显示 数据为空#}
<p>{{ none_list|default:"数据为空" }}</p>
<p>{{ file_size|filesizeformat }}</p>
{#截断 字符串,末尾加三个...#}
<p>{{ myString|truncatechars:6 }}</p>
<p>{{ myString|truncatewords:6 }}</p>
{#safe 安全机制--保证变量是字符串，相当于防止注入攻击safe过滤可以告诉django这个数据是安全的#}
<p>{{ link|safe }}</p>
</body>
</html>
3.模板语法之标签
将setting.py中的MIDDLEWARE .csrf. 中间件取消掉注释！
标签看起来像是这样的： {% tag %}。标签比变量更加复杂：一些在输出中创建文本，一些通过循环或逻辑来控制流程，一些加载其后的变量将使用到的额外信息到模版中。一些标签需要开始和结束标签 （例如{% tag %} ...标签 内容 ... {% endtag %}）。
for标签
遍历每一个元素
{% for person in person_list %}
<p>{{ person.name }}</p>
{% endfor %}
可以利用{% for obj in list reversed %}反向完成循环。
遍历一个字典：
{% for key,val in dic.items %}
<p>{{ key }}:{{ val }}</p>
{% endfor %}
注：循环序号可以通过｛｛forloop｝｝显示
forloop.counter The current iteration of the loop (1-indexed)
forloop.counter0 The current iteration of the loop (0-indexed)
forloop.revcounter The number of iterations from the end of the loop (1-indexed)
forloop.revcounter0 The number of iterations from the end of the loop (0-indexed)
forloop.first True if this is the first time through the loop
forloop.last True if this is the last time through the loop
for ... empty
for 标签带有一个可选的{% empty %} 从句，以便在给出的组是空的或者没有被找到时，可以有所操作。
{% for person in person_list %}
<p>{{ person.name }}</p>
{% empty %}
<p>sorry,no person here</p>
{% endfor %}
if 标签
{% if %}会对一个变量求值，如果它的值是“True”（存在、不为空、且不是boolean类型的false值），对应的内容块会输出。
{% if num > 100 or num < 0 %}
<p>无效</p>
{% elif num > 80 and num < 100 %}
<p>优秀</p>
{% else %}
<p>凑活吧</p>
{% endif %}
with标签
使用一个简单地名字缓存一个复杂的变量，当你需要使用一个“昂贵的”方法（比如访问数据库）很多次的时候是非常有用的
{% with total=business.employees.count %}
{{ total }} employee{{ total|pluralize }}
{% endwith %}
csrf_token
这个标签用于跨站请求伪造保护(用于验证post请求！)，用法如下：
<form action="" method="post">
{% csrf_token %}
<input type="submit" value="提交">
</form>
示例学习
view_demo/urls.py
from django.urls import path,re_path
from app01 import views
urlpatterns = [
re_path(r"login/", views.login),
]
app01/view.py
from django.shortcuts import render
from django.shortcuts import HttpResponse
import datetime
# 标签
def login(request):
"""
模板语法：
变量：{{}}
1.深度查询 句点符号 .
2.过滤器 {{val|filter_name:参数}} 参数可选
标签：{% %}
{}
"""
name = "yuan"
i = 10
l = [111, 222, 333]
info = {"name": "yuan", "age": 22}
b = True
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
alex = Person("alex", 23)
egon = Person("egon", 23)
person_list = [alex, egon]
none_list = []
# 过滤器讲解，过滤器就是把数据暗按照特定的方式显现出来
now = datetime.datetime.now()
file_size = 2018
myString = "This is deluoruisi"
link = "<a href='#'>click</a>"
# 标签 {% %} 最重要的标签 for if
user = None
if request.method == "POST":
return HttpResponse("OK")
# locals() 中存放当前的局部变量，字典形式
return render(request,"login.html",locals())
templates/login.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h2>标签</h2>
{#for 标签用法如下，有结束标签 endfor,for 里面有内置的变量#}
{#专门负责序号，forloop,此下也有一些参数...#}
{# 如果列表为空，执行可选的empty #}
{% for foo in l %}
<p>{{ forloop.counter }} :{{ foo }}</p>
{% endfor %}
{% for person in person_list %}
<p>{{ person.name }}</p>
{% empty %}
<p>如果person_list为空执行我！</p>
{% endfor %}
{#if 标签！！逻辑判断！ #}
{% if user %}
<p><a href="#">hi {{ user }} ....</a></p>
{% else %}
<p><a href="#">登录/注册！</a></p>
{% endif %}
{#with 标签 替换一个名字(一般用于替换长的名字)#}
{% with person_list.1.name as n %}
{{ n }}
{% endwith %}
{#这里将setting.py中的MIDDLEWARE .csrf. 中间件取消掉注释！#}
{# {% csrf_token %} 作用是用于django中间件进行识别，在第一次get请求发给#}
{#浏览器的时候自动生成一个带有特定标识的标签，当第二次为POST请求的时候服务器根据这个特定的标签#}
{#判断当前的请求是合法的！！就不会出现Forbidden报错，目的就是为了让POST请求#}
<form action="" method="post">
{% csrf_token %}
<input type="text" name="user">
<input type="submit">
</form>
</body>
</html>
4.自定义标签和过滤器
自定义标签和过滤器的步骤
- 在settings中的INSTALLED_APPS配置当前app，不然django无法找到自定义的simple_tag.
- 在app中创建templatetags模块(模块名只能是templatetags)
- 创建任意 .py 文件，如：my_tags.py
from django import template
from django.utils.safestring import mark_safe
register = template.Library() #register的名字是固定的,不可改变
@register.filter
def filter_multi(v1,v2):
return v1 * v2
@register.simple_tag
def simple_tag_multi(v1,v2):
return v1 * v2
@register.simple_tag
def my_input(id,arg):
result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
return mark_safe(result)
- 在使用自定义simple_tag和filter的html文件中导入之前创建的 my_tags.py
{% load my_tags %}
- 使用simple_tag和filter（如何调用）
{% load xxx %}
# num=12
{{ num|filter_multi:2 }} #24
{{ num|filter_multi:"[22,333,4444]" }}
{% simple_tag_multi 2 5 %} 参数不限,但不能放在if for语句中
{% simple_tag_multi num 5 %}
注意：filter可以用在if等语句后，simple_tag不可以
{% if num|filter_multi:30 > 100 %}
{{ num|filter_multi:30 }}
{% endif %}
示例学习
ver_demo/setting.py
...
INSTALLED_APPS = [
'app01.apps.App01Config', # 似乎是pyCharm自己添加的
# 'app01', ???? 这个与上面两个只能存一个，否则回报错？？？？
]
...
view_demo/urls.py
略
新建文件以及文件夹app01/templatetags/my_tag_filter.py
templatetags名字必须叫这个，py文件可以随便取
# 自定义标签
from django import template
# register注册必须这么写
register = template.Library()
# 自定义乘法过滤器
# 过滤器最多定义两个形参，
@register.filter
def multi_filter(x,y):
return x * y
# 自定义乘法标签,标签可以定义多个形参
@register.simple_tag
def multi_tag(x,y):
return x * y
app01/views.py
视图函数同上，这里略
templates/index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h2>使用自定义过滤器</h2>
{% load my_tag_filter%}
<p>{{ i|multi_filter:30}}</p>
<h2>使用自定义标签</h2>
<p>{% multi_tag 9 9 %}</p>
<h3>自定义过滤器和自定义标签的比较</h3>
{% if i|multi_filter:10 > 100 %}
<p>大于</p>
{% else %}
<p>小于等于</p>
{% endif %}
{#标签不能像上面这样写！会发生语法报错#}
{#{% if {% multi_tag 9 9 %} %}#}
{# <p>大于</p>#}
{#{% else %}#}
{# <p>小于等于</p>#}
{#{% endif %}#}
</body>
</html>
5.模板继承
Django模版引擎中最强大也是最复杂的部分就是模版继承了。模版继承可以让您创建一个基本的“骨架”模版，它包含您站点中的全部元素，并且可以定义能够被子模版覆盖的 blocks 。
一个html文件里面只能引入一个模板，但是可以引入多个组件！！
通过从下面这个例子开始，可以容易的理解模版继承：
<!DOCTYPE html>
<html lang="en">
<head>
<link rel="stylesheet" href="style.css" />
<title>{% block title %}My amazing site{% endblock %}</title>
</head>
<body>
<div id="sidebar">
{% block sidebar %}
<ul>
<li><a href="/">Home</a></li>
<li><a href="/blog/">Blog</a></li>
</ul>
{% endblock %}
</div>
<div id="content">
{% block content %}{% endblock %}
</div>
</body>
</html>
这个模版，我们把它叫作 base.html， 它定义了一个可以用于两列排版页面的简单HTML骨架。“子模版”的工作是用它们的内容填充空的blocks。
在这个例子中， block 标签定义了三个可以被子模版内容填充的block。 block 告诉模版引擎： 子模版可能会覆盖掉模版中的这些位置。
子模版可能看起来是这样的：
{% extends "base.html" %}
{% block title %}My amazing blog{% endblock %}
{% block content %}
{% for entry in blog_entries %}
<h2>{{ entry.title }}</h2>
<p>{{ entry.body }}</p>
{% endfor %}
{% endblock %}
extends 标签是这里的关键。它告诉模版引擎，这个模版“继承”了另一个模版。当模版系统处理这个模版时，首先，它将定位父模版——在此例中，就是“base.html”。
那时，模版引擎将注意到 base.html 中的三个 block 标签，并用子模版中的内容来替换这些block。根据 blog_entries 的值，输出可能看起来是这样的：
<!DOCTYPE html>
<html lang="en">
<head>
<link rel="stylesheet" href="style.css" />
<title>My amazing blog</title>
</head>
<body>
<div id="sidebar">
<ul>
<li><a href="/">Home</a></li>
<li><a href="/blog/">Blog</a></li>
</ul>
</div>
<div id="content">
<h2>Entry one</h2>
<p>This is my first entry.</p>
<h2>Entry two</h2>
<p>This is my second entry.</p>
</div>
</body>
</html>
请注意，子模版并没有定义 sidebar block，所以系统使用了父模版中的值。父模版的 {% block %} 标签中的内容总是被用作备选内容（fallback）。
这种方式使代码得到最大程度的复用，并且使得添加内容到共享的内容区域更加简单，例如，部分范围内的导航。
这里是使用继承的一些提示：
-
如果你在模版中使用 {% extends %} 标签，它必须是模版中的第一个标签。其他的任何情况下，模版继承都将无法工作。
-
在base模版中设置越多的 {% block %} 标签越好。请记住，子模版不必定义全部父模版中的blocks，所以，你可以在大多数blocks中填充合理的默认内容，然后，只定义你需要的那一个。多一点钩子总比少一点好。
-
如果你发现你自己在大量的模版中复制内容，那可能意味着你应该把内容移动到父模版中的一个 {% block %} 中。
-
If you need to get the content of the block from the parent template, the {{ block.super }} variable will do the trick. This is useful if you want to add to the contents of a parent block instead of completely overriding it. Data inserted using {{ block.super }} will not be automatically escaped (see the next section), since it was already escaped, if necessary, in the parent template.
-
为了更好的可读性，你也可以给你的 {% endblock %} 标签一个 名字 。例如：
{% block content %}
...
{% endblock content %}
```
在大型模版中，这个方法帮你清楚的看到哪一个 {% block %} 标签被关闭了。
不能在一个模版中定义多个相同名字的 block 标签。
**示例学习**
urls.py 和 views.py 和上面的示例一样，这里就不做多的展示了！
1. 新建模板templates/base.html 和 templates/advertising.html
