第十二周学习笔记总结

总结

纯手撸web框架

web框架可以简单的理解为是基于互联网的web服务端>>>:socket服务端

1.利用socket模块搭建简易版本的服务端

2.遵循HTTP协议---四大特性、数据格式、响应状态码

3.根据网址后缀的不同请求不同的内容

4.请求方式---GET、POST

5.从请求数据格式中筛选出用户输入的网址后缀

HTTP请求数据；/favicon.ico直接忽略，不影响判断；利用字符串切割和索引取值获取相应数据。

上述框架的缺陷：

1.socket代码重复编写

2.针对请求数据格式的处理复杂且重复

3.针对不同网址后缀的匹配方式过于低端

基于wsgiref模块

wsgiref模块内部封装了socket代码和对请求数据的处理

wsgiref模块解决了两个问题

1.socket代码重复编写

2.针对请求数据格式的处理复杂且重复

思考如何再次实现根据不同的网址后缀返回不同的内容(函数化)

1.从request获取的字典中查找出记录网址后缀的键值对

2.不推荐使用连续的多个if判断

3.针对面条版的代码首先应该考虑封装成函数

根据py文件中功能的不同划分到不同的py文件(模块化)

urls.py          存储对应关系
views.py         存储功能函数
start.py         存储启动文件
templates文件夹   存储html文件

# 以后要想新增功能,只需要在urls.py中添加对应关系,view.py中编写函数

动静态网页

静态网页：就是页面上的数据是直接写死的，要想改变只能修改源码。

动态网页：就是页面上的数据不是全部写死的，有些是动态获取(后端传入)。

jinja2模板语法

jinja2模块能够让我们在html文件内使用类似于后端的语法来操作各种数据类型。

模板语法

<h1>{{ data }}</h1>
<h1>{{ data['name'] }}</h1>
<h1>{{ data.get('pwd') }}</h1>
<h1>{{ data.hobby }}</h1>   # {{}}获取数据

{% for user in user_data %}
    <tr>
        <td>{{ user.id }}</td>
        <td>{{ user.name }}</td>
        <td>{{ user.age }}</td>
    </tr>
{% endfor %}  # 获取方法
<!--作用：获取数据库中的数据展示到前端页面-->

python主流web框架

框架	说明	缺陷
django	大而全 自身携带的功能非常的多 类似于航空母舰	开发小项目的时候使用该框架有点笨重(大材小用)
flask	小而精 自身携带的功能非常的少 类似于特种兵 主要依赖于第三方模块	受限于第三方模块的开发
tornado	异步非阻塞 该框架快到可以作为游戏服务器	上手难度是三者最高的
fastapi，sanic	最近流行的 抽空可以看看

django框架

版本问题

1.X:同步    1.11
2.X:同步    2.2
3.X:异步    3.2
ps:我们学习的时候，可以基于django2.2.22版本学习，与1.X功能几乎一致。3.X仅仅是多了一个功能

下载

在cmd窗口输入'pip3 install django==2.2.22'（用版本2.2.22为例子）。如果之前下载了其他版本不用管，自动替换!

启动注意事项

1.计算机名称尽量不要有中文

2.项目中所有的py文件名尽量不要用中文

3.不同版本的python解释器配合不同版本的django会有一些报错，找到报错信息提示的那一行代码，把逗号删除即可

4.一个pycharm窗口只允许有一个项目，不要做项目的嵌套

验证django是否下载成功

cmd终端输入django-admin有反应就是成功了。

django基本操作命令

命令行操作

1.创建django项目

django-admin startpronject 项目名

2.启动django项目

1.先切换到项目目录下
    cd 项目名
2.执行启动项目
    python38 manage.py runserver ip:port

3.创建app应用

python38 manage.py startapp 应用名

pycharm操作django

1.创建django项目

点击file创建django

2.创建更多的app

pycharm左上角tools，选择run manage.py task

startapp app名称

3.启动项目

直接点击pycharm右上方绿色箭头启动即可

命令行与pycharm操作的区别

1.命令行不会自动创建templates文件夹

2.命令行不会在配置文件编写关于templates文件夹配置

3.pycharm自动创建的第一个应用会自动注册到配置文件中

4.针对db.sqlite3文件不用去在乎它有没有创建，只要运行了django会自动出来

5.创建新的app应用了一定要去配置文件里注册才能生效

django目录结构

django项目目录
    项目同名文件夹
        __init__.py       很少用，主要做一些冷门配置
        settings.py       项目配置文件
        urls.py           对应关系(目前简单理解:网址名后缀跟函数名)
        wsgi.py           django服务，基本不用
    应用名文件夹(可以有多个)
        migrations文件夹   orm相关(数据库打交道的记录)
        __init__.py       很少用，主要做一些冷门配置
        admin.py          django自带的后台管理
        apps.py           创建应用之后用于应用的注册
        models.py         存储与数据库表相关的类
        tests.py          自带的测试文件
        view.py           存储业务相关的逻辑代码(函数，类)
    manage.py             django入口文件
    templates文件夹       存储项目所需的html文件
    db.sqlite3            自带的小型数据库

django小白必会三板斧

与浏览器打交道的视图函数都应该有返回值，常见的就是下列三个

HttpResponse
    主要用于返回字符串类型的数据
render
    主要用于返回html页面，并且支持模板语法(django自己写的)
redirect
    主要用于页面重定向，括号内可以写其他网站的全程，也可以写自己网站的后缀

静态文件及相关配置

我们在访问django框架资源的使用之所以可以拿到数据是因为提前在urls.py文件中开设了相应的资源接口，如果访问不到资源那么就是没有开设相应的接口。

编写登录功能

思路：

1.创建django项目并创建一个app

2.在urls.py添加一组对应关系

3.在app的views,py中编写核心登录逻辑

4.利用三板斧与前端做交互

静态文件

静态文件就是html页面上使用的不经常改变的资源

第三方框架文件(bootstrap)、css文件、js文件、图片文件，上述文件都可以称之为是静态文件

针对静态文件资源一般都会放在static文件夹内,当static目录下出现了很多不同类型的静态文件资源，那么还可以分类管理
    others文件夹
        第三方框架文件
    css文件夹
        所有的css文件
    js文件夹
        所有的js文件
    img文件夹
        所有的img文件

相关配置

针对静态文件资源的访问也需要提前开设相应的接口

理论上应该自己去路由层开设接口资源，但是由于静态文件资源使用频率很高，只要是一个web项目都肯定需要，所以django为了避免开发者繁琐，提供了静态资源的配置文件，只需要填写固定的配置即可开设资源接口。

STATIC_URL = '/static/'  # 作用是什么  /static/是访问静态资源的接口前缀
# 静态文件资源配置
STATICFILES_DIRS = [
    os.path.join(BASE_DIR, 'static')
]  # 为什么是列表(用来存储多个数据的)  这里的static是存储静态文件资源的文件夹名称

以该地址为例:/static/bootstrap-3.4.1-dist/css/bootstrap.min.css

1./static/是接口前缀,表示具备访问静态文件资源的权限

2.具备了权限之后会拿着接口前缀后面的文件路径(bootstrap-3.4.1-dist/css/bootstrap.min.css)去列表中每个文件夹中查找

3.去该路径下面找到一个就结束,比如 static和static1里面都有a.txt 那么只会拿到static中的

4.去该路径下面找完全部都没有就报错

动态配置：修改了接口前缀也能访问

{% load static %}
<link rel="stylesheet" href="{% static 'bootstrap-3.4.1-dist/css/bootstrap.min.css' %}">

请求方法

URL：统一资源定位符(网址)

GET请求

朝别人索要数据，也可以携带额外的数据

GET请求没有请求体(HTTP数据格式)

携带数据的方法：就是在URL后面加个？，把要添加的数据写在？后面。

url?xxx=yyy&zzz=ooo&aaa=bbb

上述携带数据的方式有两个限制

1.数据只能是一些无关紧要的非敏感数据
2.数据大小有限制，一般在2KB~4KB左右

POST请求

朝别人提交数据，也可以携带额外的数据

数据都是放在请求体中并且数据大小没有限制

页面需要获取前端用户数据并且传递给后端

思路：通过form表单传递数据。form表单默认的数据提交方式是get。
method = 'post' ：控制请求的提交方式
action 参数:控制数据的提交地址
方式1：不写参数，就是朝当前页面所在的地址提交
方式2：写后缀，比如/index/，自动补全ip和port
方式3：写全称，比如https://www.baidu.com/

提交post请求前期需要去配置文件中注释一行代码

MIDDLEWARE = [# 'django.middleware.csrf.CsrfViewMiddleware',]

request对象方法

方法	说明
request.method	获取请求方式，结果是纯大写的字符串
request.POST	获取POST请求发送来的普通数据(不包含文件)
request.POST.get()	默认只获取列表中的最后一个数据值
request.POST.getlist()	获取键对应的整个列表，无论有几个数据值
request.GET	获取url后面携带的非敏感数据
request.GET.get()	默认只获取列表中最后一个数据值
request.GET.getlist()	获取键对应的整个列表，无论有几个数据值

pycharm连接MySQL

pycharm也可以充当很多数据库软件的客户端。

如何进入pycharm的数据库客户端：

1. 查找pycharm提供的database按钮，pycharm右上方侧边，左下方边角
2. 上述两个地方都没有 需要下载插件 或者直接重装一个正常的pycharm。

我们以mysql为例子。

第一步：选择mysql数据库。

第二步：输入用户名，密码和库名，测试连接（第一次需要下载驱动）

django连接MySQL

django默认自带一个sqlite3数据库，但是功能很少，仅用于本地测试。

1.默认配置

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

2.修改配置

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql', # 指定数据库软件名称
        'NAME': 'db_django', # 指定库名
        'HOST': '127.0.0.1', # 本机地址
        'PORT': 3306, # 本机mysql端口
        'USER': 'root', # 用户名
        'PASSWORD': '123', # 密码
        'CHARSET': 'utf8' # 编码
    }
}

3.指定连接MySQL的模块

django1.11 版本需要在项目或者应用目录下的__ init__.py中编写一行代码

import pymysql
    pymysql.install_as_MySQLdb()

django2.2 以上版本需要使用mysqlclient模块

django orm简介

ORM：对象关系映射

好处：能够让不会写MySQL的python程序员使用python语法简单快捷的操作MySQL。

坏处：封装了SQL语句，有时候可能效率不高，还需要人为编写SQL提升效率。

概念对应关系

ORM	映射	MySQL
类	映射成	表
对象	映射成	记录
对象点属性	映射成	字段对应的值

orm基本使用

在应用目录下的models.py编写模型类

class user(models.Model):  # 类似于定义了表名
    id = models.AutoField(primary_key=True)  # 类似于定义了主键
    # id int primary key auto_increment

    name = models.CharField(max_length=32)  # 类似于定义了普通字段
    # name varchar(32)

    pwd = models.IntegerField()  # 类似于定义了普通字段
    # pwd int

数据库迁移/同步命令

1.将models中有关数据库的操作记录下来(migrations文件夹)
python38 manage.py makemigrations

2.将操作真正影响到数据库中
python38 manage.py migrate

'''
首次执行迁移命令 django还会自动创建一些默认需要使用到的表
当修改了models中与数据库相关的代码 都必须执行上述的命令
'''
ps:可以简写 也可以指定应用单独迁移/同步

补充

1.迁移数据命令生成的表面的特征是：应用名_类名。由于django支持多个应用，为了区分不同应用下可能会出现相同的表名。

2.表的主键在orm中可以不写，orm会自动帮你添加一个id的主键，如果你需要主键的名称不叫id只能自己创建。

3.每次修改了跟数据库相关的python代码，都需要重新执行迁移命令。

4.针对两个迁移命令，可以采用pycharm提示功能编写，在tools里的run manage.py task中编写命令即可。

orm语法

如何获取对象？
可以使用first()方法，如果没有值会返回None，然后用if判断即可

1.查
models.User.objects.filter()  # 结果可以看成是一个列表套数据对象

2.增
models.User.objects.create()

3.改
models.User.objects.filter(id=1).update(name='jasonNB')

4.删
models.User.objects.filter(id=4).delete()

'''改和删操作前需要先找到需要的操作的数据，如果不写就是默认操作所有数据'''

orm外键关联

MySQL
    一对多
        外键字段在多的一方
    多对多
        外键字段建在第三张关系表
    一对一
        外键字段建在查询频率较高的表中

ORM
    一对多(关键字ForeignKey)
        外键字段建在多的一方
        publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    多对多(关键字ManyToManyField)
        外键字段可以直接写在某张表中，orm会自动帮你创建第三张表
        authors = models.ManyToManyField(to='Authors')
    一对一(关键字OneToOneField)
        外键字段建在查询频率较高的表中
        detail = models.OneToOneField(to='AuthorDetail',on_delete=models.CASCADE)
'''
on_delete=models.CASCADE  级联更新，级联删除
'''

django请求生命周期流程图

整体概括请求的走向以及django的核心组成部分，参考下图。

1.浏览器发送一个基于HTTP协议的请求

2.进入web服务网关接口将请求来的数据拆解成一个request大字典

3.进入django框架里的中间件，相当于保安负责django安全性

4.进入django后端路由层完成功能匹配

5.进入视图层执行核心业务逻辑

6.执行核心业务逻辑的时候可能需要用到html页面，这时候就需要用到模板层

7.用模板的时候也可能用到数据库的数据，这时候用到模型层，由模型层帮你去跟数据库交涉

8.由orm把数据库返回的数据封装成一个数据对象，返回到视图层做一个模板语法，模板渲染

9.由视图层直接返回到中间件再做一层校验，怕携带危险数据

10.没问题会交给web服务网关接口封装数据发给浏览器

路由层

路由匹配

path('网址后缀',函数名)

只要网址后缀匹配上了就会自动执行后面的函数并结束整个路由的匹配。

1.路由结尾的斜杠

默认的情况下不写斜杠django会做二次处理，第一次匹配不上就会让浏览器自动加上斜杠再次请求。

django配置文件中可以指定是否自动添加斜杠：

APPEND_SLASH = False  # 取消斜杠二次处理机制

2.path转换器

当网址后缀不固定的时候，可以使用转换器来匹配。

转换器类型	说明
str	匹配除了'/'之外的非空字符串
int	匹配0或任何正整数，返回一个int
slug	匹配任意由ASCII字母或数字以及连字符和下划线组成的短标签
path	匹配非空字段，包括路径分隔符'/'

转换器匹配到的内容会当做视图函数的关键字参数传入，转换器有几个叫什么名字，那么视图函数的形参必须对应。

3.re_path正则匹配

re_path(正则表达式,函数名)

只要正则表达式能够从用户输入的后缀中匹配到内容就算匹配上了就会自动执行后面的函数并结束整个路由匹配。

re_patn('^test/$', views.test) #^是限制开头$是限制结尾

4.正则匹配之无名分组

re_path('^test/(\d+)/$', views.test)

路由匹配成功之后就会调用视图函数默认情况下会自动给视图函数传递一个request位置参数

def test(request):
    return HttpResponse('测试')

如果路由匹配中使用括号对正则表达式进行了分组，那么在调用视图函数的时候，会将括号内匹配到的内容当做位置参数传递给视图函数

5.正则匹配之有名分组

re_path('^test/(?P<year>\d+)/(?P<others>.*?)/', views.test)

给括号内的正则表达式起别名之后，匹配成功则会讲括号内匹配到的内容按照关键字参数传递给视图函数。

6.django版本区别

django1.11中，只支持正则匹配并且方法是url()

django2,3,4中，方法是path(), re_path()等价于url()

反向解析

反向解析：返回一个结果，该结果可以访问到对应的路由。

步骤一：路由对应关系起别名

path('register/', views.reg, name='reg_view')

步骤二：使用反向解析语法

html页面：

{% url 'reg_view' %}  # reg666/ 结果可以访问路由
例子：<a href="{% url 'reg_view'  %}">reg_view</a>

后端：

from django.shortcuts import reverse
reverse('reg_view')  # reg666/ 结果可以访问路由

ps:反向解析的操作三个方法都一样 path() re_path() url()

无名有名反向解析

步骤一：路由对应关系起别名

path('reg/<str:info>/', views.reg, name='reg_view')

步骤二：使用反向解析语法

当路由中有不确定的匹配因素，反向解析的时候需要人为给出一个具体的值

html页面：

{% url 'reg_view' 'jason' %}

后端：

from django.shortcuts import reverse
reverse('reg_view', args=('jason',))

路由分发

如果一个django项目特别庞大，里面有很多应用，每个应用下有很多对应关系。那么django自带的路由层里面的代码就会非常非常的多。

我们可以根据应用的不同拆分路由对应关系到不同的应用中。django支持每个应用都可以有自己独立的路由层、模板层、静态文件、视图层(默认)、模型层(默认)。所以所有人都可以在应用中开发完整的项目功能，最后汇总到一个空的django项目中，然后通过路由分发整合所有人的应用。

路由分发的作用：能够让基于django开发的多个应用完全独立，便于小组开发

1.创建多个应用，并去配置文件中注册

INSTALLED_APPS = [
    'app01',
    'app02'
]

2.路由分发：总路由

3.子路由

应用场景：当项目特别大，应用特别多的时候，可以使用路由分发，非常方便。

名称空间

在路由分发场景下多个应用在涉及到反向解析别名冲突的时候无法正常解析。

解决方法1：名称空间

总路由添加名称空间。

应用反向解析自动提示

解决方法2：别名不冲突即可

网页伪静态

动态页面：用ASP、PHP、JSP、ASP.net、Perl、或CGI等编程语言制作，不是独立存在于服务器上的网页文件，只有当用户请求时服务器才返回一个完整的网页，内容存在于数据库中，根据用户发出的不同请求，其提供个性化的网页内容。

静态页面：静态页面的URL链接是以.html、htm、.shtml、.xml为链接后缀，存在于服务器上的一个文件，每个网页都是一个独立的文件，内容直接保存在文件中，没有连接数据库。

网页伪静态：将动态网页伪装成静态网页，从而提升网页被搜索引擎收录的概率。
表现形式就是网址看着像一个具体的文件路径

伪静态好处：把网页做成伪静态最主要的就是为了搜索引擎方便搜索引擎蜘蛛(Spider)来抓取网页上的相关内容；提高用户对网页的信任度，因为伪静态的后缀也是.html .htm .shtml .xml;网页静态化也影响着网站在搜索引擎的排名；伪静态明确了网站的URL链接，可以更好的让用户传播、浏览以及输入；伪静态不需要全站生成静态页面，可节省服务器空间使用率。

path('index.html', view.index)

视图层

视图函数的返回值

视图函数必须返回一个HttpResponse对象。(HttpResponse其实是一个类)

HttpResponse

class HttpResponse(HttpResponseBase):
    return HttpResponse()

render

def render(...):
    return HttpResponse(...)

redirect

def redirect(to, *args, permanent=False, **kwargs):
        redirect_class = HttpResponsePermanentRedirect if permanent else HttpResponseRedirect  # 三元表达式
        return redirect_class(resolve_url(to, *args, **kwargs))

视图函数返回json格式数据

将下列数据用json格式展示到网页

user_dict = {'name': 'jason老师', 'pwd': 123, 'hobby': ['read', 'run', 'music']}

方法一：json方法

def obj_json(request):
    json_str = json.dumps(user_dict, ensure_ascii=False)
    return HttpResponse(json_str)

方法二：JsonResponse方法

from django.http import JsonResponse
def obj_json(request):
    return JsonResponse(user_dict, json_dumps_params={'ensure_ascii':False}, safe=False)

'''序列化非字典类型的数据还需要指定safe参数为False'''

from表单携带文件数据

form表单上传的数据中如果含有文件，那么需要做以下几件事。

第一：method属性值必须是post。

第二：enctype属性值必须修改为multipart/form-data，默认是application/x-www-form-urlencoded。

第三：后端需要使用request.FILES获取，然后就可以通过句点符和with open等查看和下载文件信息。

request补充方法

方法	说明
request.body	存放的是接收过来的最原始的二进制数据,request.POST、request.GET、request.FILES这些获取数据的方法其实都从body中获取数据并解析存放的
request.path	获取路径
request.path_info	获取路径
request.get_full_path()	获取路径并且还可以获取到路径后面携带的参数

FBV与CBV

FBV：基于函数的视图

def index(request):
    return HttpResponse()

path('index/', views.index)

CBV：基于类的视图

from django import views
class MyView(views.View):
    def get(self, request):
        return HttpResponse('我是CBV里面的get方法')
    def post(self, request):
        return HttpResponse('我是CBV里面的post方法')

path('func/', views.MyView.as_view())
"""
CBV会自动根据请求方式的不同匹配类中定义的方法并自动执行
"""

CBV源码分析

源码分析入口

path('func/', views.MyView.as_view())
PYTHON 复制 全屏

1.切入点:路由匹配

类名点属性as_view并且还加了括号
as_view可能是普通的静态方法
as_view也可能是绑定给类的方法

2.对象查找属性的顺序

先从对象自身开始、再从产生对象的类、之后是各个父类
MyView.as_view()
先从我们自己写的MyView中查找,没有再去父类Views中查找

3.CBV路由匹配本质:跟FBV是一致的

项目已启动就会执行as_view方法 查看源码返回了一个闭包函数名view
def as_view(cls):
    def view(cls):
      pass
    return view
path('func/', views.view)
# 函数名加括号执行优先级最高

4.路由匹配成功之后执行view函数(访问func触发view执行)

def view(...):
    obj = cls() # cls我们直接写的类，加括号产生一个自己写的类的对象
    return obj.dispatch(request, *args, **kwargs)
'''涉及到对象点名字 一定要确定对象是谁 再确定查找顺序'''

5.研究dispatch方法

def dispatch(...):
      # 利用getattr反射（通过字符串操作对象的属性和方法）
      #参数：obj自己写的类产生的对象，当前的请求方法。 handler就等于自己写的类里的请求方法
      handler = getattr(obj, request.method.lower())
      # 返回的时候加括号传承调用自己写的类里的请求方法
      return handler(request, *args, **kwargs)

ps:查看源码也可以修改，但是尽量不要这么做，很容易产生bug。

模板层

模板语法传值

django提供的模板语法只有两个符号：

{{}}:主要用于数据；{%%}:主要用于方法。

传值的两种方式

# 方式1：指名道姓的传，适用于数据量较少的情况，节省资源
return render(request, 'modal.html', {'name':name})
# 方式2：打包传值(关键字locals())，将整个局部名称空间中的名字全部传入，适用于数据量较多的情况，简单快捷
return render(request,'modal.html',locals())

模板语法传值的范围

数据类型	说明
基本数据类型	都可以直接传递使用
函数名	传递会自动加括号执行并将返回值展示到页面上，函数如果有参数不会执行也不会展示，模板语法不支持有参函数
类名	传递会自动加括号产生对象并展示到页面上
对象	直接传递使用(显示对象的地址,并且具备调用属性和方法的能力)
文件名	直接显示文件IO对象

django的模板语法在操作容器类型的时候只允许使用句点符

模板语法过滤器(类似于python内置函数)

<p>统计长度:{{ s|length }}</p>
<p>加法运算:{{ i|add:123 }}</p>、<p>加法运算:{{ s|add:'heihei' }}</p>
<p>日期转换:{{ s|date:'Y-m-d H:i:s' }}</p>
<p>文件大小:{{ file_size|filesizeformat }}</p>
<p>数据切片:{{ l|slice:'0:10' }}</p>
<p>字符截取(三个点算一个):{{ s1|truncatechars:6 }}</p>
<p>单词截取(空格):{{ s1|truncatewords:6 }}</p>

# 在前端使用 |safe
<p>语法转义:{{ script_tag|safe }}</p>  # safe：将后端写的代码可以在前端被识别被转换

# 在后端使用mark_safe
from django.utils.safestring import mark_safe
script_tag1 = '<script>alert(666)</script>'
res = mark_safe(script_tag1)

<p>{{ res }}</p>
ps:有时候html页面上的数据不一定非要在html页面上编写了 也可以后端写好传入

模板语法标签(类似于python流程控制)

在django模板语法中写标签的时候，只需要写关键字然后tab键就会自动补全。

1.if判断

2.for循环

3.数据是字典，同样提供了keys、values、items方法。

自定义过滤器、标签函数、inclusion_tag

如果想自定义，必须做以下三件事：

1.在应用下创建一个名为templatetags文件夹

2.在该文件夹创建任意名称的py文件

3.在该文件内编写自定义相关固定代码

from django.template import Library
register = Library()

自定义过滤器:只能接收两个参数

自定义标签函数：可以接收任意参数

自定义inclusion_tag：该方法需要先作用于一个局部html页面 之后将渲染的结果放到调用的位置 类似于封装了一个能够快速产生html代码的方法

模板的继承

类似于面向对象的继承:继承了某个页面就可以使用该页面上所有的资源。

如果我们想要继承获取一个页面的大部分只修改一部分代码，我们也可以用继承来实现。

母页面

# 先在母板中通过block划定将来可以被修改的区域(可以有多个)
{% block 名字 %}
    母板内容
{% endblock %}

子页面

{% extends 'html文件名' %} # html文件名是母页面的HTML文件名，继承了母页面

{% block 名字 %}  # 这里写的内容可以直接修改母页面里可以被修改的区域
    子板内容
{% endblock %}

'''子板中还可以使用母板的内容  {{ block.super }} '''

模板上最少应该有三个区域可以让子页面继承：css区域、内容区域、js区域。子页面就可以有自己独立的css、js、内容

{% block css %}
    css修改内容
{% endblock %}

{% block 名字 %}
    子板内容
{% endblock %}

{% block js %}
    js修改内容
{% endblock %}

子页面还可以重复使用父页面的内容

{{ block.super }}

模板的导入

类似于将html页面上的局部页面做成模块的形式，哪个地方想要直接导入即可展示。

使用方式

{% include 'menu.html' %}