模板语法传值
    {{}}：变量相关
    {%%}：逻辑相关

    1. #模板语法可以传递的后端python类型数据--->基本上python后端的都能到前端去
    2. #后端
    3. def home(request):
    4.     n = 123
    5.     f = 12.12
    6.     s = '你懂得'
    7.     b = False
    8.     l = [11,22,33,44]
    9.     t = (11,22,33,44)
    10.     d = {'username':'yo','age':'20','hobby':'happy'}
    11.     se = {'第一','第二','第三'}
    13.     class MyClass(object):
    14.         def get_one:
    15.             return 'one'
    16.         @classmethod
    17.         def get_cls(cls):
    18.             return 'cls'
    19.         @staticmethod
    20.         def get_sta():
    21.             return 'sta'
    22.     #obj=MyClass()
    23.     #调用语法
    24.     return render(request,'index.html',locals())
    26. #前端
    27. <p>{{ s }}</p>
    28. <p>{{ n }}</p>
    29. <p>{{ f }}</p>
    30. <p>{{ b }}</p>
    31. <p>{{ l }}</p>
    32. <p>{{ t }}</p>
    33. <p>{{ d }}</p>
    34. <p>{{ se }}</p>
    35. <p>{{ func }}</p>--->传递函数名会自动加括号调用 但是模版语法不支持给函数传额外的参数:{{ func }}
    36. <p>{{ MyClass }}</p>传类名的时候也会自动加括号调用(实例化){{ MyClass }}
    37. <p>{{ MyClass.get_cls }}</p>基于上述内容可以得出，无论后端有没有实例化类，在前端只要调用了类中的方法一样能够执行，因为已经自动添加了括号进行调用
    38. <p>{{ MyClass.get_one }}</p> <---> <p>{{ obj.get_one }}</p> 同理
    39. <p>{{ MyClass.get_sta }}</p>
    41. django模板语法的取值只有一种方式，那就是.没有其他调用方法
    42. 后端
    43. li = [1,2,3,4,{'name':'yo'}]
    44. 前端
    45. <p>{{ li.4.name }}</p>

    过滤器(过滤器只能最多有两个参数)

    1. # 过滤器就类似于是模版语法内置的 内置方法
    2. # django内置有60多个过滤器不需要学这么多 了解10个左右就差不多了 后面碰到了再去记忆
    4. 基本语法
    5. {{数据|过滤器:参数}}
    7. #转义
    8. #前端转义
    9. {{xxx|safe}}
    10. #后端转义
    11. from django.utils.safestring import mark_safe
    12. res = mark_safe('<h1>嗯哼</h1>')
    13. #以后能够后端转义尽量后端转义，前端转义容易造成xss注入
    16. <p>统计长度:{{ n|length }}</p>
    17. <p>默认值(第一个参数布尔值是True就展示第一个参数的值否在展示冒号后面的值):{{ b|default:'就这？' }}</p>
    18. <p>判断文件大小：{{ n|filesizeformat }}</p>
    19. <p>日期格式化:{{ time|date:'Y-m-d' }}</p>
    20. <p>切片操作：{{ s|slice:'0:2:1' }}</p>
    21. <p>切分字符{{ s|truncatechars:5 }}</p>{#--->新含义-->（2.x以后...只占一个格子，且若是切分字符数等于字符数，那么不会显示...）#}
    22. <p>切取单词(不包含三个点 按照空格切){{ s|truncatewords:5 }}</p>
    23. <p>移除特定的字符:{{ s|cut:' ' }}</p>
    24. <p>拼接操作{{ l|join:'$' }}</p>
    25. <p>拼接操作(加法):{{ n|add:10 }}</p>
    26. <p>拼接操作(加法):{{ s|add:n }}</p>
    27. <p>转义：{{ sss|safe }}</p>
    28. <p>转义：{{ res }}</p>--后端转义

    标签

    1. #for循环
    2. {% for i in l  %}
    3.     <p>{{forloop}}</p>
    4. {% endfor %}
    5. forloop---> 变量获取循环序号
    6. {'parentloop': {}, 'counter0': 0, 'counter': 1, 'revcounter': 4, 'revcounter0': 3, 'first': True, 'last': False}
    7. forloop.counter: 顺序获取循环序号，从 1 开始计算
    8. forloop.counter0: 顺序获取循环序号，从 0 开始计算
    9. forloop.revcounter: 倒叙获取循环序号，结尾序号为 1（不重要）
    10. forloop.revcounter0: 倒叙获取循环序号，结尾序号为 0（不重要）
    11. forloop.first（一般配合if标签使用）: 第一条数据返回 True，其他数据返回 False
    12. forloop.last（一般配合if标签使用）: 最后一条数据返回 True，其他数据返回 False
    14. #if判断
    15. {% if b %}
    16.     <p>正确</p>
    17. {% elif f %}
    18.     <p>正确2</p>
    19. {% else %}
    20.     <p>错误</p>
    22. #for 和 if 混用
    23. {% for i in lli %}
    24.     {% if forloop.first %}
    25.         <p>'这是第一个'</p>
    26.     {% elif forloop.last %}
    27.         <p>'这是最后一个'</p>
    28.     {% else %}
    29.         <p>{{ i }}</p>
    30.     {% endif %}
    31.     {% empty %}
    32.         <p>for循环的可迭代对象内部没有元素 根本没法循环</p>
    33. {% endfor %}
    35. # 处理字典其他方法
    36. {% for foo in d.keys %}
    37.     <p>{{ foo }}</p>
    38. {% endfor %}
    39. {% for foo in d.values %}
    40.     <p>{{ foo }}</p>
    41. {% endfor %}
    42. {% for foo in d.items %}
    43.     <p>{{ foo }}</p>
    44. {% endfor %}
    46. #with起别名
    47. {% with li.4.1.1.key as key %}
    48.     <h1>{{ key }}</h1>
    49. {% endwith %}
    51. 起别名作用：直接上栗子
    52. 后端：
    53. li = [1,2,3,4,['dd',['ddd',{'key':'123'}]]]-->挺离谱的
    54. 前端获取
    55. {{ li.4.1.1.key }}
    56. 那么如果这个元素要被用很多次，重复的调用就会显得代码非常冗余
    57. 这个时候就可以使用with起别名，在body下套个with就行了

    自定义过滤器、标签、inclusion_tag

    1. '''
    2. 三部曲
    3.     1.在应用下创建一个名字 必须为 templatetags文件夹
    4.     2.在该文件夹内创建任意名称的py文件 --->名字随便起
    5.     3.在py文件内必须有以下两句话(一个字符都不能错)
    6.     from django import template
    8.        register = template.Library()
    9. '''
    11. #自定义过滤器
    12. @register.filter(name='haha')
    13. def ddd(value,value2):
    14.     return value - value2
    16. {#{{ n|haha:n2 }}#}
    18. #自定义标签
    19. @register.simple_tag(name='plus')
    20. def index(a,b,c,d):
    21.     return '%s-%s-%s-%s'%(a,b,c,d)
    23. {#<p>{% plus 'egon' 'jason' 'tank' 'yo' %}</p>#类似于python中的函数#}
    25. # 自定义inclusion_tag
    26. """
    27. 内部原理
    28.     先定义一个方法 
    29.     在页面上调用该方法 并且可以传值
    30.     该方法会生成一些数据然后传递给一个html页面
    31.     之后将渲染好的结果放到调用的位置
    32. """
    33. @register.inclusion_tag('left_menu.html')
    34. def left(n):
    35.     data = ['第{}项'.format(i) for i in range(n)]
    36.     # 第一种
    37.     # return {'data':data}  # 将data传递给left_menu.html
    38.     # 第二种
    39.     return locals()  # 将data传递给left_menu.html
    41. {% left 5 %}
    42. # 总结:当html页面某一个地方的页面需要传参数才能够动态的渲染出来，并且在多个页面上都需要使用到该局部 那么就考虑将该局部页面做成inclusion_tag形式
    43. (在讲bbs的时候会使用到)

    模板的继承

    1. """
    2. 你们有没有见过一些网站
    3.     这些网站页面整体都大差不差 只是某一些局部在做变化    
    4. """
    5. # 模版的继承 你自己先选好一个你要想继承的模版页面
    6. {% extends 'home.html' %}
    8. # 继承了之后子页面跟模版页面长的是一模一样的 你需要在模版页面上提前划定可以被修改的区域
    9. {% block content %}
    10.     模版内容
    11. {% endblock %}
    13. # 子页面就可以声明想要修改哪块划定了的区域
    14. {% block content %}
    15.     子页面内容    
    16. {% endblock %}
    19. # 一般情况下模版页面上应该至少有三块可以被修改的区域
    20.     1.css区域
    21.   2.html区域
    22.   3.js区域
    23.   {% block css %}
    25.     {% endblock %}
    27.   {% block content %}
    29.     {% endblock %}
    31.   {% block js %}
    33.     {% endblock %}
    34.   # 每一个子页面就都可以有自己独有的css代码 html代码 js代码
    36. """
    37. 一般情况下 模版的页面上划定的区域越多 那么该模版的扩展性就越高
    38. 但是如果太多 那还不如自己直接写
    39. """

    模板导入

    1. """
    2. 将页面的某一个局部当成模块的形式
    3. 哪个地方需要就可以直接导入使用即可
    4. """
    5. {% include 'wasai.html' %}

    思考题目

    1. """
    2. 1.反向解析的本质是什么，无名和有名反向解析如何操作？
    3. 2..路由分发能够实现的前提是什么，需要注意什么，名称空间什么时候使用
    4. 3..什么是虚拟环境，django1.X与django2.X/3.X的区别有哪些
    5. 4.诠释为何跨语言传输数据以json格式为主，django返回json格式数据方式有哪些，又有哪些注意事项和配置参数
    6. """