Django框架的基本使用

Django是一个功能强大的web框架

框架模式

1、MVC和MTV框架

MVC：Web服务器开发领域里著名的MVC模式，所谓MVC就是把Web应用分为模型(M)，控制器©和视图(V)三层，结构说明如下：

M: models 数据库相关操作
V: views 视图，也就是业务逻辑相关操作
C: controller  控制器，也就是通过路径找到对应视图函数

MTV：Django的MTV模式本质上和MVC是一样的，也是为了各组件间保持松耦合关系，只是定义上有些许不同。

M: models 数据库相关操作
T: templates html文件相关操作(模板渲染等)
V: views 视图，也就是业务逻辑相关操作

加上一个url控制器，也就是通过路径找到对应视图函数

2、WSGI

WSGI（Web Server Gateway Interface）就是一种规范，它定义了web应用程序与web服务器程序之间的接口格式，实现web应用程序与web服务器程序间的解耦。

开发的项目分为两个部分的程序
1 服务器程序  socket相关功能的模块，wsgiref、uwsgi等等，负责接收网络请求并解析网络请求相关数据，分装加工成一些可用的数据格式,格式大家都是统一的，方便应用程序的开发

2 应用程序  就是使用接收到的网络请求相关数据，进行逻辑代码的开发，比如数据库相关操作，数据结构的调整、文件操作等等。。。

一、Django的基本使用

1、下载的三种方式：

• 直接在pycharm中的setting中进行下载
• 在cmd中通过命令下载：pip install django==版本
• 在pycharm的Terminal控制台中进行下载（下载时要注意路径问题）

2、创建项目

（1）通过cmd或pycharm控制台的命令创建项目

​ 先切换到要创建项目的目录下，然后执行创建项目命令：

django-admin startproject mysite  # mysite是项目名称

​ 创建项目后会生成如下的目录，当前目录下会生成mysite的工程,里面有个主目录和我们创建的项目目录同名，在项目目录下有个manage.py文件，在主目录下有settings.py\urls.py\wsgi.py，每个文件的功能介绍如下：

manage.py ----- Django项目里面的工具，通过它可以调用django shell和数据库，启动关闭项目与项目交互等，不管你将框架分了几个文件，必然有一个启动文件，其实他们本身就是一个文件。
settings.py ---- 包含了项目的默认设置，包括数据库信息，调试标志以及其他一些工作的变量。
urls.py ----- 负责把URL模式映射到应用程序。
wsgi.py ---- runserver命令就使用wsgiref模块做简单的web server，后面会看到renserver命令，所有与socket相关的内容都在这个文件里面了，目前不需要关注它。

​ 一个django项目中可以有多个应用，每个应用完成项目的部分功能，这些功能相对于其他功能来说是相对独立的，但又同时存在于同一个项目中，每个应用的逻辑数据库等也都是相对独立的，每个应用都有属于自己的模块单位；开发的时候，都是通过应用来写逻辑

（2）通过pycharm创建django项目

• 点击File --》New Project 选择第二项 Django

• 在Location中选择选项目创建的地址和项目名

• Project Interpreter:

  Project Interpreter中的Newenvironment using是创建项目执行的虚拟环境

  Project Interpreter中的Existing interpreter是使用本地的环境，也可以使用已创建好的虚拟环境

• More Settings

  Template language:模板引擎；默认是Django的Template模板引擎

  如若下载jinja2模板引擎可进行切换，或者其他模板引擎

  注：django中的模板引擎未单独封装成模块；jinja2是模仿的的django的Template

  Templates folder：存放html文件的文件夹名

  Application name：是创建的应用的应用名

• create创建完成后执行即可，通过控制台显示的链接即可访问

3、运行项目

启动项目命令：

python manage.py runserver 127.0.0.1:8080
ip和port可以不用写，不写时默认是 127.0.0.1:8000

运行成功后，会看到一个项目链接，在浏览器中输入此链接即可访问到创建的项目

4、创建应用Application

（1）cmd或pycharm控制器Terminal中创建应用

​ 要在项目目录下执行命令进行创建应用

python manage.py startapp 应用名
经常用到的三个文件
models.py  数据库相关内容
views.py  视图，业务逻辑代码相关内容
tests.py 用来写一些测试代码，用来测试我们自己写的视图的，目前用不到

（2）pycharm中手动创建应用

• 创建应用文件夹（鼠标右键使用python package创建）
• 在settings.py中找到INSTALLED_APPS在其下面添加应用的配置信息
• 应用名.apps.应用名Config（后面的应用名的首字母大写）

5、django项目的导入

请看博客：https://www.cnblogs.com/wylshkjj/p/11983596.html

6、windows中安装不同版本的python解释器

在python3.7及以上版本中，使用django框架的时候，django的版本要在2.0或以上，否则会出现问题；python3.6使用django的1.0版本。

当想即使用python3.7和python3.6针对django的不同版本进行创建项目时，python解释器的安装要注意，

解释器安装请参考博客：https://www.cnblogs.com/wylshkjj/p/13122349.html

二、url路由系统

在django中，url中的路径写法是正则，正则里面有无名分组正则，有有名分组正则，那么对应django中的功能，我们称之为无名分组路由和有名分组路由

在django的1.0版本中路由配置文件urls.py中使用的是url()，里面可以直接使用正则匹配路径的方式

而在django的2.0版本中路由配置文件urls.py中使用的是path()，里面不能直接使用正则匹配路径，如需使用正则路径进行匹配就要使用re_path()，使用前要先导入

1、无命名分组路由

看写法,urls.py文件中内容如下

urlpatterns = [
		...
    url(r'^books/(\d+)/(\d+)/', views.book),
    #正则里面()分组正则，会将分组中的正则匹配到的内容作为返回值返回
]

简单分析，伪代码
'''
当用户请求的路径是它： /books/2019/8/

url(r'^books/(\d+)/(\d+)/', views.book), 里面做的事情如下

re.match(^books/(\d+)/,/books/2019/)
2019 和 8 作为位置参数交给了要执行的book视图函数
视图函数book的写法
def book(request,xx,oo):
    xx = 2019
    oo = 8
    pass
'''

视图views.py文件中函数的写法

#位置传参，url中正则^books/(\d+)/(\d+)/，那么第一个()分组匹配到的数据，作为book函数的第二个参数，第二个()分组匹配到的数据，作为book的第三个参数
def book(request, year, month):
    print('year', year, 'month', month) #year 2020

    # return HttpResponse('%s所有书籍' % year)
    return HttpResponse('%s年%s月所有书籍' % (year, month))

使用url路由系统时需要注意几个点

1. urlpatterns中的元素按照书写顺序从上往下逐一匹配正则表达式，一旦匹配成功则不再继续。
2. 若要从URL中捕获一个值，只需要在它周围放置一对圆括号（正则分组匹配）。
3. 不需要添加一个前导的反斜杠（也就是写在正则最前面的那个/），因为每个URL 都有。例如，应该是^articles 而不是 ^/articles。
4. 每个正则表达式前面的'r' 是可选的但是建议加上。
5. ^articles$  以什么结尾，以什么开头，严格限制路径

2、有名分组路由

其实就玩得正则的有名分组，看示例

Urls.py文件中的写法

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    # /books/2020/6/
    url(r'^books/(?P<year>\d+)/(?P<month>\d+)/', views.book),
    # {'year':2020,'month':6},url类将有名分组正则匹配出来的数据，交给了book视图函数作为关键字参数来使用]

View.py文件中函数的写法如下

# ^books/(?P<year>\d+)/(?P<month>\d+)/
#获取到url中的有名分组正则匹配到的数据，那么函数形参名称必须和有名分组正则的那个名称相同才可以，也就是按照上面的url来看的话，函数的形参必须是year和month这两个名称,并且关键字传参不需要考虑函数形参的位置
def book(request, month, year):
    # print('year', year, 'month', month) #year 2020
    print(request.path) #/books/2020/6/
    # return HttpResponse('%s所有书籍' % year)
    return HttpResponse('%s年%s月所有书籍' % (year, month))

3、路径中的尾部斜杠问题

当用户通过浏览器访问django框架完整的项目中的某个路径时，如果用户在输入网址路径的最后，没有加上/斜杠，比如http://127.0.0.1:8000/test，那么django会发将用户输入的网址路径加上一个后置的/,也就会将路径变成这样http://127.0.0.1:8000/test/，然后给浏览器发送一个重定向的响应操作，状态码为301，那么浏览器拿到这个重定向操作之后，就会自动发起一个这样的路径请求http://127.0.0.1:8000/test/，所以当我们打开浏览器控制台的network功能查看请求过程时，会看到两个请求，一个没有后置的斜杠的，一个是有后置斜杠的。第二个请求才会走到我们的urs.py文件中的路径配合和分发对应视图的地方。

我们可以通过一个配置项，告诉django，不要自动加路径后面的斜杠了，但是需要注意的就是你自己写的url中的正则，也别加后面的斜杠，不然正则匹配不到。

配置项直接写在settings配置文件中，任意位置

APPEND_SLASH = False  #False表示告诉Django，不加路径后面的斜杠，默认值是True

5、视图函数中指定默认值

views.py文件：

# 在路由没有匹配任何参数的时候，num使用自己的默认值
# 当路由中有分组匹配数据的动作，比如url(r'^test/(\d+)/', views.test),用户输入网址：http://127.0.0.1:8000/test/22/，那么22就被匹配到了，会作为参数传给我们的test函数，那么num的值就变成了22
def test(request, num=10):
    print('number>>>',num)
    return HttpResponse('test')

urls.py文件

# url(r'^test/', views.test),
	url(r'^test/(\d+)/', views.test),

三、Django的视图

1、request的对象

常用的属性和方法

print(request)  # wsgirequest对象
print(request.path)  # 请求路径 #/index/
print(request.method)  # 请求方法
print(request.POST)  # post请求提交的数据 <QueryDict: {'username': ['root']}>
print(request.GET)  # 获取url中的查询参数 <QueryDict: {'a': ['1'], 'b': ['2']}>  #不是针对get请求的
print(request.body)  #获取http请求消息格式的请求数据部分的内容  b''
print(request.META)  #请求头信息
print(request.get_full_path())  # 获取完整路径(包含查询参数的) /index/?a=1&b=3

print(request.FILES)  # 上传的文件对象数据
print(request.FILES.get('file'))  # 上传的文件名

#<QueryDict: {'username': ['root'], 'sex': ['female'], 'hobby': ['2', '3']}>
print(request.POST.get('username'))  # 前端中传输的username的值
print(request.POST.get('sex'))  # 前端中单选传输的sex值
# 多选提交来的数据通过getlist来获取
print(request.POST.getlist('hobby'))  # ['2', '3']

2、response的响应

（1）常用方法

from django.shortcuts import render, HttpResponse, redirect

return HttpResponse('你好') #回复字符串
return render(request,'home.html') #回复html页面

#重定向方法，参数是个路径
return redirect('/home/')  #封装了302状态码，以及浏览器要重定向的路径

（2）添加响应头键值对

ret = render(request,'home.html') 
ret['a'] = 'b' #添加响应头键值对
return ret

（3）添加响应状态码

ret = render(request,'home.html', status=202) #render修改状态码还可以这样改
#ret['a'] = 'b' #添加响应头键值对
ret.status_code = 201 #添加响应状态码
return ret #回复html页面

3、CBV和FBV

两种视图逻辑的写法方法

FBV：全称function based view，就是基于函数来写视图逻辑

CBV：全称class based view，就是基于类来写视图

基于类的视图CBV写法，如下，views.py文件

from django.views import View

#登录需求
class LoginView(View):
    # get请求  获取login页面
    def get(self,request):
        return render(request,'login.html')
        
    # post请求，获取post请求提交的数据，并校验等等
    def post(self,request):
        print(request.POST)
        
        #<QueryDict: {'uname': ['chao'], 'pwd': ['123']}>
        return render(request,'login.html')

url路径的写法：urls.py文件

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^index/', views.index),
    url(r'^home/', views.home),

    # 类视图的url写法
    url(r'^login/', views.LoginView.as_view()),

]

4、cbv源码重点(反射)

from django.views import View
View里面的dispatch方法中的反射逻辑，实现了不同的请求方法，找到我们视图类中的对应方法执行

5、FBV和CBV加装饰器

FBV和普通函数加装饰器方式一样

示例：

#装饰器函数
def outer(f):
    def inner(request, *args ,**kwargs):
        print('前面')
        ret = f(request, *args ,**kwargs)
        print('后面')
        return ret
    return inner

#使用装饰器
@outer
def books(request):
    print('FBV执行了')
    return HttpResponse('book.html--ok')

CBV加装饰器

#装饰器函数
def outer(f):
    def inner(request, *args ,**kwargs):
        print('前面')
        ret = f(request, *args ,**kwargs)
        print('后面')
        return ret
    return inner


#使用装饰器
#1 引入django提供的装饰器方法method_decorator来配合装饰器函数的使用
from django.utils.decorators import method_decorator

@method_decorator(outer,name='get') #CBV加装饰器方式3
class BookView(View):
    #给类方法统一加装饰器，借助dispatch方法(父类的dispatch方法，就是通过反射来完成不同的请求方法找到并执行我们自己定义的视图类的对应方法)
    # 重写dispatch方法，dispatch方法是在其他请求方法对应的类方法执行之前执行的
    # @method_decorator(outer) #加装饰器方式2
    def dispatch(self, request, *args, **kwargs):
        # print('xxxxxx')
        ret = super().dispatch(request, *args, **kwargs)
        # print('oooooo')
        return ret

    #CBV加装饰器的方式1,给单独的方法加装饰器
    # @method_decorator(outer)
    def get(self, request, xx):
        print('CBV的get方法')
        return render(request, 'book.html')

    # @method_decorator(outer)
    def post(self,request, xx):
        print('CBV的post方法')
        return HttpResponse('ok')
  

四、Django的Template模板

1、Template的基本使用

（1）通过{{ 变量 }}：获取单个变量值

（2）通过{% 逻辑 %}：获取逻辑渲染结果

2、变量的使用

Number数据类型，容器数据类型和对象都可以直接进行渲染

（1）返回前端页面的数据格式

• 在return返回的时候可以直接写入参数，区别在于html中渲染的时候直接通过元素直接获取（使用原参数没有作用），容器数据类型才有效，number类型无效

  return render(request, “index.html”, info)

• 在return返回的时候也可以使用字典的方式，使用字典时，就是直接通过字典的键来进行相应的操作

  return render(request, “index.html”, {‘info’: info})

（2）句点号的使用：

​ 在字典数据类型中需要使用句点号和索引搭配才能获取到相应的值

​ 同理对象的方法和属性的调用也是通过句点号，而且要注意调用方法不能加()

# views.py
from django.shortcuts import render
import datetime
# Create your views here.
class obj():
    pass
def index(request):
    pdd = '1234'
    info = {
        'name': '旋风奥利奥',
        'age': '18',
        'hobby': "girl",
        'dict': {'drink': '饮品', 'milk': '牛奶'},
        'list': ['面包', '包子'],
        'object': obj(),
        'size': 123456,
        'time': datetime.datetime.now()
    }
    return render(request, "index.html", info)
    # return render(request, "index.html", {'info': info})

# html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h3>{{ name }}</h3>
<p>{{ dict }}</p>
<p>{{ list }}</p>
<p>{{ pdd }}</p>
<hr>
{% for foo in list %}
<p>{{ foo }}</p>
{% endfor %}
<hr>
{% for k,v in dict.items %}
<p>{{ k }} : {{ v }}</p>
{% endfor %}
<hr>
{{ object.obk }}
</body>
</html>

# url.py
from app01 import views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^index/', views.index)
]

3、Template过滤器

• 通过过滤器对数据进行过滤处理显示
• 使用方式：{{ 变量|过滤器：参数 }}
• 过滤器支持链式操作，通过多个管道符和过滤器相配合实现层级过滤
• 过滤器可以接收参数
• 注意事项：管道符左右两遍不能留空格，否则不能识别；还有参数和：间也不能留空格；

3.1、内置过滤器

（1）default：默认值

​ 当变量获取的到值的时候显示获取的值，获取不到值或者获取的是一个布尔类型的False时就使用默认的default值：{{ value|default:“没有值”}}

（2）length：长度

​ 返回的是字符串或列表的长度：{{ value|length }}

（3）filesizeformat：文件大小的显示处理

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

（4）slice：切片：{{ value|slice:“2:-1” }}

（5）date：时间显示处理

​ 对获取的时间进行过滤处理：{{ value|date:“Y-m-d H:i:s”}}

（6）safe：声明此变量值（或代码段）不转义

{'a_tag':'<a href="">百度</a>',}
渲染
<p>
    {{ a_tag|safe }} #生成标签效果
</p>

（7）truncatechars：指定字符串长度，超出部分以 … 显示
{{ value|truncatechars:9}}：指定九个字符长度，也包括 … 这三个字符

（8）truncatewords：以单词的形式指定字符串长度，超出部分以 … 显示

​ {{ value|truncatewords:3}}：指三个单词长度，不包括 … 部分

（9）cut：过滤字符串

​ {{ value|cut:’ ’ }}：过滤掉value变量中和参数中的空格相同的字符

（10）join：字符串拼接

​ {{ hobby|join:’+’ }}：把列表数据通过加号拼接成一个字符串

3.2、自定义过滤器

• 在应用文件夹中创建一个名为templatetags的文件夹（文件夹的名字必须是templatetags）
• 在templatetags文件夹中创建任意 .py 文件，如：mytag.py
• 在mytag.py文件中写上如下内容

from django import template
register = template.Library()  # 制作注册器，名字必须叫register
#过滤最多两个参数
@register.filter  # 注册过滤器,需要两个参数的
def add(v1, v2):  # v1表示管道符前面的，v2表示冒号后面的参数
    print(v1,v2)  # 100 50
    return v1 + v2

@register.filter  # 注册过滤器，需要一个参数的
def xxx(v1):   # v1表示管道符前面的
    print(v1) 
    return 'xxx'

• 在html文件中导入

{% load mytag %}  <!-- 首先通过load来加载一下mytag文件，不一定放在文件的开头，但是一定要放在使用过滤器的前面先进行引用 -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>

</head>
<body>
<h1>base页面</h1>
  <!-- {% load mytag %} 放这里也是可以的 -->  
<div>
    {{ num|add:50}}  <!-- 使用过滤器，和django内置过滤器用法一样，这里生成的是add函数的返回值 -->
</div>
<div>
    {{ num|xxx }}
</div>
<!-- {% load mytag %} 放这里不行 -->  

</body>
</html>

4、Template标签

​ 使用方式：{% 标签 %} {%end标签%}

4.1、内置标签

（1）for 循环标签

​ {% for xx in hobby %}{% endfor %}

forloop的使用

​ 注：循环序号可以通过｛｛forloop｝｝显示，必须在循环内部用

• forloop.counter 当前循环的索引值(从1开始)，forloop是循环器，通过点来使用功能

• forloop.counter0 当前循环的索引值（从0开始）

• forloop.revcounter 当前循环的倒序索引值（从1开始）

• forloop.revcounter0 当前循环的倒序索引值（从0开始）

• forloop.first 当前循环是不是第一次循环（布尔值）

• forloop.last 当前循环是不是最后一次循环（布尔值）

• forloop.parentloop 本层循环的外层循环的对象，再通过上面的几个属性来显示外层循环的计数等

for循环的反向循环：

​ 可以利用{% for obj in list reversed %}反向完成循环。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
{% for i in dict %}
    <p>{{ i }}</p>
{% endfor %}
<hr>
{% for i in dict.values %}
    <p>{{ i }}</p>
{% endfor %}
<hr>
{% for k,v in dict.items %}
    <p>{{ k }} : {{ v }}</p>
{% endfor %}
<hr>
{% for foo in list %}
    <p>{{ forloop }} : {{ foo }}</p>
{% endfor %}
<hr>
{% for foo in list %}
    <p>{{ forloop.counter }} : {{ foo }}</p>
{% endfor %}
<hr>
{% for foo in list %}
    <p>{{ forloop.counter0 }} : {{ foo }}</p>
{% endfor %}
<hr>
{% for foo in list %}
    <p>{{ forloop.revcounter }} : {{ foo }}</p>
{% endfor %}
<hr>
{% for foo in list %}
    <p>{{ forloop.revcounter0 }} : {{ foo }}</p>
{% endfor %}
<hr>
{% for foo in list %}
    <p>{{ forloop.first }} : {{ foo }}</p>
{% endfor %}
<hr>
{% for foo in list %}
    <p>{{ forloop.last }} : {{ foo }}</p>
{% endfor %}
<hr>
{% for foo in list %}
    {% for foo in list %}
        <p>{{ forloop.parentloop.counter }} : {{ forloop.revcounter0 }} : {{ foo }}</p>
    {% endfor %}
{% endfor %}
<hr>

# 反向循环列表
{% for foo in list reversed %}
    <p>{{ foo }}</p>
{% endfor %}

</body>
</html>

（2）if 判断标签

​ {% if 判断条件 %}{% endif %}

• if语句支持 and 、or、==、>、<、!=、<=、>=、in、not in、is、is not判断，注意条件两边都有空格。
• 但是不支持连续判断操作：{% if a > b > c %}{% endif %}
• {% if %}会对一个变量求值，如果它的值是“True”（存在、不为空、且不是boolean类型的false值），对应的内容块会输出。

{% if num > 100 or num < 0 %}
	<p>无效</p>  <!--不满足条件，不会生成这个标签-->
{% elif num > 80 and num < 100 %}
	<p>优秀</p>
{% else %}  <!--也是在if标签结构里面的-->
	<p>凑活吧</p>
{% endif %}

​

（3）with 起别名标签

​ 使用一个简单地名字缓存一个复杂的变量，多用于给一个复杂的变量起别名，当你需要使用一个“昂贵的”方法（比如访问数据库）很多次的时候是非常有用的；注意：等号左右不要加空格。

方式一：
{% with total=business.employees.count %}
    {{ total }} <!--只能在with语句体内用-->
{% endwith %}

方式二：
{% with business.employees.count as total %}
    {{ total }}
{% endwith %}

（4）for empty联合使用的情况

​ 当循环的hobby没有数据或为空的时候，就显示empty下面的内容

<ul>
    {% for xx in hobby %}
    <li>{{ xx }}</li>
    {% empty %}
        <h2>抱歉，没有查询到相关数据</h2>
    {% endfor %}
</ul>

（5）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的值。

4.2、自定义标签

• 在应用文件夹中创建一个名为templatetags的文件夹（文件夹的名字必须是templatetags）
• 在templatetags文件夹中创建任意 .py 文件，如：mytag.py
• 在mytag.py文件中写上如下内容

from django import template
register = template.Library() #制作注册器，名字必须叫register
@register.simple_tag
def atag(v1,v2): #没有参数个数限制
    print(v1,v2)
    return v1 + v2

• 在html文件中导入

 {% load mytag %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>

</head>
<body>
<h1>base页面</h1>
{% load mytag %}

<div>
    {% atag a b %}  <!-- 注意，是{%%} 来包裹使用，先是标签名称然后空格写参数，参数之间也是空格分隔的 -->
</div>

</body>

</html>

5、Templete模板继承

将一些页面公共的部分，可以抽离出来单独做成一个html页面，使用这些公用部分的其他html文件，只需要继承一下它就可以了，具体使用流程如下：

（1） 创建公用模板,比如内容如下

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        body{
            padding: 0;
            margin: 0;
        }
        {% block css %}
        .nav{
            height: 60px;
            background-color: green;
        }
        {% endblock %}
        .nav a{
            color:white;
            text-decoration: none;
        }
        .left-menu{
            width: 30%;
            background-color: rgba(0,0,0,0.5);
            float:left;
        }
        .menu .menu-title{
            text-align: center;
        }
        .main{
            float: right;
            width: 65%;
            height: 300px;
            border: 1px solid red;
        }
    </style>
</head>
<body>

<div class="nav">
    <a href="/xx1/">首页</a>
    <a href="/person/">个人中心</a>
    <a href="/detail/">详情页</a>
</div>
<div class="left-menu">
    <div class="menu">
        <div class="menu-title">菜单1</div>
        <div class="menu-body">
            <div class="item">局部按摩</div>
            <div class="item">全身按摩</div>
            <div class="item">足底按摩</div>
            <div class="item">头部按摩</div>
        </div>
        <div class="menu-title">菜单2</div>
        <div class="menu-body">
            <div class="item">盲人按摩</div>
            <div class="item">推背</div>
            <div class="item">刮痧</div>
            <div class="item">精油、火罐</div>
        </div>
    </div>
</div>
<div class="main">
    {% block content %}
    公共页面
    {% endblock %}
</div>

</body>
{% block js %}
    
{% endblock %}

</html>

（2）将来如果说继承公用模板的html文件中需要修改公用模板中的一些内容，那么需要在公用模板中预留一些钩子，钩子的写法如下

{% block content %}  #block 后面的块名称随便起
公共页面
{% endblock %}
#也可以这样写 {% endblock content %}  #endblock指定名称

（3）继承公用模板需要在html文件中写如下内容：

{% extends 'xx.html' %}  <!-- 需要先继承一下公用模板，写法就是extends '公用模板文件名称'，注意，必须写在第一行 -->

{% block css %}
.nav{
    height: 60px;
    background-color: pink;
}
{% endblock %}

{% block content %}
    <h1>首页</h1>
{% endblock %}

（4） 在使用公用模板的其他html文件中，如果需要更改公用模板里面的内容，只需要在html文件中写上相同的钩子，钩子里面写上自定义的内容，写法如下

{% block css %}
.nav{
    height: 60px;
    background-color: pink;
}
{% endblock %}

{% block content %}
    <h1>首页</h1>
{% endblock %}

（5）注意事项：

• 如果你在模版中使用 {% extends %} 标签，它必须是模版中的第一个标签。其他的任何情况下，模版继承都将无法工作，模板渲染的时候django都不知道你在干啥。

• 在base模版中设置越多的 {% block %} 标签越好。子模版不必定义全部父模版中的blocks，所以，可以在大多数blocks中填充合理的默认内容，然后，只定义你需要的那一个。多一点钩子总比少一点好。

• 如果你发现你自己在大量的模版中复制内容，那可能意味着你应该把内容移动到父模版中的一个 {% block %} 中。

• {{ block super }}的使用，在子模板中也展示出父模板原来钩子中的内容

  {% block content %}
      <h1>首页</h1>
      {{ block.super }}
  {% endblock %}
  
  

• 为了更好的可读性，你也可以给你的 {% endblock %} 标签一个 名字 。例如：

{% block content %}
...
{% endblock content %}　　

在大型模版中，这个方法帮你清楚的看到哪一个　 {% block %} 标签被关闭了。

• 不能在一个模版中定义多个相同名字的 block 标签。

  #两个block都叫content，这种写法是不对的
  {% block content %}
  
      <h1>首页</h1>
      {{ block.super }}
  {% endblock %}
  {% block content %}
  
      <h1>首页</h1>
      {{ block.super }}
  {% endblock %}
  

6、要注意Template模板渲染实在浏览器解释之前执行的，模板渲染后才轮到浏览器器来执行解释

7、拓展：XSS攻击（上面过滤|safe的拓展）

xss攻击：，全称跨站脚本攻击

​ Django的模板中在进行模板渲染的时候会对HTML标签和JS等语法标签进行自动转义，原因显而易见，这样是为了安全，django担心这是用户添加的数据，比如如果有人给你评论的时候写了一段js代码，这个评论一提交，js代码就执行啦，这样你是不是可以搞一些坏事儿了，写个弹窗的死循环，浏览器就不能用了，浏览器会一直弹出弹窗，这叫做xss攻击，所以浏览器中进行了一些转义处理。但是有的时候我们需要这些HTML元素不被转义，比如我们做一个内容管理系统，后台添加的文章中是经过修饰的，这些修饰可能是通过一个类似于FCKeditor编辑加注了HTML修饰符的文本，如果自动转义的话显示的就是保护HTML标签的源文件。为了在Django中关闭HTML的自动转义有两种方式，如果是一个单独的变量我们可以通过过滤器“|safe”的方式告诉Django这段代码是安全的不必转义。

本文地址：https://blog.csdn.net/sinat_41672927/article/details/107349810