{ {variable}}

{ {variable.name}}
#输出Lily
{ {variable.info.home}}
#输出Beijing

1
2
3
4
5
6
7
8
9
10

以MyDjango为例，抽取index.html部分代码，代码如下：

• {% for type in type_list %}

• { { type.type }}

  {% for name in name_list %} {% if name.type == type.type %} { { name.name }} {% endif %} {% endfor %}

• {% endfor %}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

上述代码分别使用模板的变量和标签，说明如下：

1.{ { title }} 代表模板变量，从变量名title可以知道，变量的数据类型是字符串或整型

2.{% load staticfiles %} 是模板的内置标签，load标签用于导入静态资源信息

3.{% static “css/hw_index.css” %} 是模板的内置把标签，static标签用于读取静态资源的文件内容

4.{% for type in type_list %} 是for遍历标签，将变量进行遍历输出

5.{% if name.type == type.type %} 是if判断标签，主要对变量进行判断处理

6.{ { type.type }} 代表变量type_list的某个属性

在这里插入图片描述

在这里插入图片描述

在上述常用标签中，每个标签的使用方法都是各不相同的。我们通过简单的例子进一步了解标签的使用方法，代码如下：

{% for item in myList %}
{ { item }}
{% endfor %}

{% if name = ‘Lily’ %}
{ {name}}
{% elif name = ‘Lucy’ %}
{ {name}}
{% else %}
{ {name}}
{% endif %}

第一页

{% with total = products_total %}
{ { total }}
{% endwith %}

{% load staticfiles %}

{% static “css/hw_index.css” %}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

在for标签中，模板还提供一些特殊的变量来获取for标签的循环信息，说明如下：

● forloop.counter： 循环的当前索引值，从1开始计数；常用于生成一个表格或者列表的序号！

● forloop.counter0： 循环的当前索引值，从0开始计数；

● forloop.revcounter： 循环结束的次数（从1开始）

● forloop.revcounter0 循环结束的次数（从0开始）

● forloop.first： 判断当前是否循环的第一次，是的话，该变量的值为True。我们经常要为第一行加点特殊的对待，就用得上这个判断了，结合if。

● forloop.last： 如果这是最后一次循环，则为真

● forloop.parentloop： 对于嵌套循环，返回父循环所在的循环次数。某些场景下，这是个大杀器，能解决你很多头疼的问题。

上述变量来自于forloop对象，该独享的模板引擎解析for标签时所称城的。举例如下：

{% for name in name_list %}
{% if forloop.counter == 1 %}
这是第一次循环
{% elif forloop.last %}
这是最后一次循环
{% else %}
本次循环次数为{ { forloop.counter }}
{% endif %}
{% endfor %}

1
2
3
4
5
6
7
8
9

2，模板继承

模板继承是通过模板标签实现的，其作用是将多个HTML模板的共同代码集中在一个新的HTML模板中，然后各个模板可以通过调用新的HTML模板，从而生成新的HTML网页，减少模板间代码重复使用。代码如下：

Hello Django

1
2
3
4
5
6
7
8
9
10
11

上述代码是一个完整的HTML模板，一个完整的模板有和两大部分，其中部分在大多数情况下都是相同的，因此可以将部分写道同用模板中，将共用模板命名为base.html，代码如下：

1
2
3
4
5
6
7
8
9
10

在base.html的代码中可以看到，里的内容变为{% block body %}{% endblock %}，block标签相当于一个函数，body是对该函数的命名，开发者可自行命名。在一个模板中可以添加多个block标签，只要每个block标签的命名不相同即可。接着在模板index.html中调用共同模板base.html，代码如下：

{% extends “base.html” %}
{% block body %}
首页

Hello Django

1
2
3
4
5

模板index.html调用统统模板base.html的实质是由模板继承实现的，调用步骤如下：

在模板index.html中使用{% extends “base.html” %} 来继承base.html
由标签{% block body %}在继承模板的基础上实现自定义的模板内容
由 {% endblock %} 结束block标签

3，自定义过滤器

过滤器主要是对变量内容进行处理，例如替换、逆序、转义等。通过过滤器处理变量可以将变量的数据格式和内容转化为我们想要的效果。使用方法如下：

{ { variable | filter }}

1

模板引擎解析带过滤器的变量时，首先通过filter处理变量variable，然后将处理后的变量显示在网页上。其中，variable代表模板变量，管道符号‘|’代表变量使用过滤器，filter代表某个过滤器。变量可以支持多个过滤器同时使用，如下：

{ { variable | filter | lower}}

1

在使用的过程中，某些过滤器还可以传入参数，但仅支持一个参数的传入。带参数过滤器的使用方法如下：

{ { variable | date:“D d M Y”}}

1

Django为开发者提供内置过滤器

https://www.cnblogs.com/waltsmith/p/8088099.html

实际开发中，如果内置过滤器不符合开发需求，我们需要自定义过滤器来解决问题。首先在MyDjango中添加文件和文件夹，如下：

在这里插入图片描述

在MyDjango项目中添加user_defined文件夹，该文件夹下继续添加文件夹templatetags。templatetags用于存放自定义过滤器的代码文件，该文件夹也可以存放在项目的App中，但是需要注意的是，文件夹的命名必须为templatetags，否则Django在运行的时候无法识别自定义过滤器。最后，在templatestags文件夹下创建myfilter.py文件，该文件的编写自定义过滤器的实现代码。

​ 完成过滤器目录搭建，接着是配置过滤器信息，在配置文件settings.py的INSTALLED_APPS里面添加user_defined。当项目启动时，Django会从INSTALLED_APPS的配置中查找到过滤器，若过滤器设置在index的目录下，则只需在INSTALLED_APPS配置index即可，如下：

在这里插入图片描述

完成上述两个环境配置后，编写自定义过滤器代码myfilter.py中添加以下代码：

from django import template

register = template.Library()

@register.filter
def myreplace(value, args):
oldValue = args.split(’:’)[0]
newValue = args.split(’:’)[1]
return value.replace(oldValue, newValue)

1
2
3
4
5
6
7
8
9

上述代码用于实现HTML模板的字符串替换功能，与Python的replace函数相同，说明如下：

导入模板功能template，通过template声明Library对象，给对象赋值给register，称为注册过滤器
过滤器以函数形式实现，在函数前使用register.filter装饰器表示该函数是一个过滤器
函数参数可设置一个或两个，上述参数分别为value和args，value是HTML模板的变量，参数args是过滤器函数定义的函数参数
过滤函数最后必须将处理结果返回，否则出现异常

最后HTML模板中使用我们自定义的过滤器，以index.html模板的title为例，代码如下：

{% load myfilter %}

在HTML模板中使用自定义过滤器可以分为两个步骤，说明如下：

{% load staticfiles %}用于导入templatetags文件夹的myfilter.py文件中所定义的功能，用来告诉Django在那个地方可以找到自定义过滤器。
{
    
       { title | myreplace:‘首页|我的首页’ }}把变量title含有‘首页’的内容替换成‘我的首页’。其中，myreplace是过滤器的函数名，‘首页：我的首页’是函数参数args的值，函数参数value的值为模板变量title的值。

在这里插入图片描述
六，模型与数据库

Django对各种数据库提供了很好的支持，包括：PostgreSQL、MySQL、SQLite和Oracle，并且为这些数据库提供统一的调用API，这些API统称为ORM框架。通过使用Django内置ORM框架可以实现数据库连接和读写操作。
1，构建模型

ORM框架是一种程序技术，用于实现面向对象编程语言中不同类型系统的数据之间的转换。从效果上说，其实是创建了一个可在编程语言中使用的"虚拟对象数据库"，通过对虚拟对象数据库操作从而实现对目标数据库的操作，虚拟对象数据库与目标数据库是相互对应的。在Django中，虚拟对象数据库也成为模型。通过模型实现对目标数据库的读写操作，实现方法如下：

配置目标数据库信息，主要在settings.py中设置数据库信息
构建虚拟对象数据库，在App的modle.py文件中以类的形式定义模型
通过模型在目标数据库中创建相应的数据库
在视图函数通过对模型操作实现目标数据库的读写操作

在这里插入图片描述

我们使用Navicat Prenium数据库管理工具查看mysql数据库的信息，如下：

在这里插入图片描述

在这里插入图片描述

数据表只能通过模型创建，因为Django对模型和目标数据库之间由自身的映射规则，如果自己在数据库中创建数据表，可能不一定符合Django的见表规则，从而导致模型和目标数据库无法建立通信。在项目index的models.py文件中定义模型，代码如下：

from django.db import models

class Type(models.Model):
id = models.AutoField(primary_key=True)
type_name = models.CharField(max_length=20)

class Product(models.Model):
id = models.AutoField(primary_key=True)
name = models.CharField(max_length=50)
weight = models.CharField(max_length=20)
size = models.CharField(max_length=20)
type = models.ForeignKey(Type, on_delete=models.CASCADE)

1
2
3
4
5
6
7
8
9
10
11
12
13

上述代码分别定义了Type和Product，定义说明如下：

模板以 类的形式定义，继承Django的model.Model类。一个类代表目标数据库的一张数据表，类的命名一般首字母大写
模板的字段以类属性进行定义，如id = models.IntegerField(primary_key=True) 代表在数据表Type中命名一个id字段，该字段数据类型为整型并且设置为主键

完成模型定义后，接着在目标数据库中创建相应数据表，在目标数据库中创建表是通过Django的管理工具manage.py完成，创建命令如下：

#根据model.py生疮相关.py文件，该文件用于创建数据库

在这里插入图片描述

#创建数据表

在这里插入图片描述

在目标数据库中创建数据表需要执行两次命令，分别是makemigrations和migrate指令。创建过程说明如下：

​ makemigrations指令用于将index所定义的模型生成0001_initial.py文件，该文件放在index的migrations文件夹，打开0001_initial.py文件，其文件内容如下：

在这里插入图片描述

0001_initial.py文件将model.py的内容生成数据表脚本代码。而migrate指令更加脚本代码在目标数据库中生成相应数据表。指令完成后，可在数据库中查看到已创建的数据表，如下：

在这里插入图片描述

数据表index_product和index_type是由index的模型所创建的，分别对应模型Product和Type。其他数据表是Django内置功能所使用的数据表，分别是session、用户认证管理和Admin日志记录等。

我们创建了index_prodect和index_type，而表字段是在模型中定义的，在哦行Type和Product中定义的字段类型由整型和字符类型，但实际开发中，我们需要定义不同的数据类型满足各种要求，因此Django划分了多种不同的数据类型，如下：

在这里插入图片描述

Django提供的字段类型还会对数据进行正则处理和验证功能，进一步完善数据的严谨性。除了表字段类型外，每个表字段还可以设置相应的参数，让字段更加完善。字段说明如下：

在这里插入图片描述
2，数据表的关系

一个模型对应目标数据库的一个数据表，每个数据表之间也是存在关联的，表与表之间由三种关系:一对一、一对多、多对多。

​ 一对一存在两个数据表中，第一个表的某一行数据与第二个表的某一行数据相关，同时第二个表的某一行数据也至于第一个表的某一行数据相关，这种关系称为一对一关系。
ID 姓名 国籍 参加节目
1001 王大锤 中国 万万没想到
1002 李光洙 韩国 Running Man
1003 高晓松 未知 晓说
ID 出生日期 逝世日期
1001 1988 NULL
1002 1981 NULL
1003 未知 NULL

两个表中，ID分别一一对应，而且不会在同一个表中有重复的ID，使用这种关系通常是一个数据表中有太多字段，将常用的字段抽取出来并组成一个新的数据表。在模型中可以通过OneToOneField来构建表的一一对应关系，代码如下：

class Performer(models.Model):
id = models.IntegerField(primary_key=True)
name = models.CharField(max_length=20)
nationality = models.CharField(max_length=20)
masterpiece = models.CharField(max_length=50)

class Performer_info(models.Model):
id = models.IntegerField(primary_key=True)
performer = models.OneToOneField(Performer,on_delete=models.CASCADE)
birth = models.CharField(max_length=20)
elapse = models.CharField(max_length=20)

1
2
3
4
5
6
7
8
9
10
11

在这里插入图片描述
使用Django管理工具manage.py创建数据表Performer和Performer_info，创建数据表前最好删除0001_initial.py文件并清空数据库中的数据表。如下：

在这里插入图片描述

一对多存在于两个或两个以上的数据表中，第一个表的数据可以与第二个表的一行到多行数据进行关联，但第二个表的每一行数据只能与第一个表的某一行进行关联，如下：
ID 姓名 国籍
1001 王大锤 中国
1002 李光洙 韩国
1003 高晓松 未知
ID 参加节目
1001 万万没想到
1002 Running Man
1003 晓说
1003 奇葩说

表1字段ID的数据可以重复并且在表2中找到对应数据，而表1字段ID是唯一的，这是一种最常见的表关系。在模型中可以通过ForeignKey来构建一对多关系，代码如下：

class Performer(models.Model):
id = models.IntegerField(primary_key=True)
name = models.CharField(max_length=20)
nationality = models.CharField(max_length=20)

class Program(models.Model):
id = models.IntegerField(primary_key=True)
performer = models.ForeignKey(Performer,on_delete=models.CASCADE)
name = models.CharField(max_length=20)

1
2
3
4
5
6
7
8
9

使用Django的管理工具manage.py创建数据表Performer和Program，创建数据表前最好先删除001_initial.py文件并清空数据库里的数据表，生成的数据表如下：

在这里插入图片描述

多对多存在与两个或者两个以上数据表中，第一个表的某一行数据可以与第二个表的一道多行数据进行关联，同事第二个表的某一行数据也可以与第一个表的一到多行数据进行关联，如下：
ID 姓名 国籍
1001 王大锤 中国
1002 李光洙 韩国
1003 高晓松 未知
ID 参加节目
1001 万万没想到
1002 Running Man
1003 晓说
1004 英雄联盟
ID 节目ID 演员ID
1 1001 1001
2 1001 1002
3 1002 1001

从上面三个数据表中可以发现，一个演员可以参加多个节目，而一个节目也可以由多个演员共同演出。每个表的字段ID都是唯一的，节目ID和演员ID出现了重复数据，多对多关系需要使用新的数据表来管理两个表的关系。在模型中可以通过ManyToManyField来构建数据表的多对多关系，代码如下：

class Performer(models.Model):
id = models.IntegerField(primary_key=True)
name = models.CharField(max_length=20)
nationality = models.CharField(max_length=20)

class Program(models.Model):
id = models.IntegerField(primary_key=True)
name = models.CharField(max_length=20)
performer = models.ManyToManyField(Performer)

1
2
3
4
5
6
7
8
9

Django创建多对多关系的时候只需要创建两个数据库对象，在创建数据表的时候会自动生成三个数据表来建立多对多关系，如下：

在这里插入图片描述
3，数据表的读写

前两节主要通过模型来构建目标数据库的数据表，本节主要通过模型操作来实现数据库的读写操作。数据库的读写操作主要是对数据库进行增、删、改、查。数据表index_type和index_product分别在两个数据表中添加如下内容数据。

手动在navicat客户端的mydjango数据库的index_type数据表中加入以下数据：

在这里插入图片描述

为了更改的演示数据库的读写操作，在MyDjango项目中使用shell模式进行演示（该模式主要为方便开发人员和执行脚本）在PyCharm的Terminal下启动shell模式，输入‘python manage.py shell’指令即可开启

在这里插入图片描述

在这里插入图片描述

在shell模式下，如果相对数据表index_product插入数据，输入如下代码：

In [1]: from index.models import
In [2]: p = Product()
In [3]: p.name = ‘荣耀 V9’
In [4]: p.weight = ‘111g’
In [5]: p.size = ‘120757mm’
In [6]: p.type_id = 1
In [7]: p.save()

1
2
3
4
5
6
7

从models.py中导入Product
对模型Product声明并实例化，生成对象P
对对象p的属性进行赋值，对象p的属性来自模型Product所定义的字段
完成赋值，需要对p进行保存

代码执行结束后，可以查看到插入数据的情况：

在这里插入图片描述

除了上述方法外，数据的插入还有以下两种方式：

方法一：（通过Django的ORM框架提供的API实现，使用create方法实现数据插入） Product.objects.create(name=‘荣耀V12’,weight=‘111g’,size=‘120757’,type_id=1)

方法二：（在实例化时直接设置属性值） p = Product(name=‘荣耀V12’,weight=‘111g’,size=‘120757’,type_id=1)

如果想对现有数据进行更新，实现步骤与数据插入大致相同，唯一的区别在模型实例化后，要更新数据，需要先进行依次数据查询，将查询结果以对象形式赋给p，最后对p的属性进行数据的更新，代码如下：

In [1]: p = Product.objects.get(id=5)
In [2]: p.name='华为荣耀V9‘
In [3]: p.save()

1
2
3

七，表单与模型

表单是搜集用户数据信息的各种表单元素的集合。其作用是实现网页上的数据交互，数据在网站上输入数据信息，然后提交但网站服务器上处理。

​ 用户表单是Web开发的一项基本功能，Django表单功能是由Form类实现，主要分为两种：django.forms.Form、django.forms.ModelForm。前者是一个基础的表单功能，后者是在前者基础上结合模型所生成的数据表单。
1，初识表单

传统的表单生成方式是在模板文件中编写HTML代码实现的，在HTML语言中，表单由标签实现。表单生成方式如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

一个完整的表单有四部分构成：提交地址、请求方式、元素空间和提交按钮。说明如下：

提交地址用于设置用户提交的表单数据应由哪个URL接收和处理，由控件的属性action决定。当用户向服务器提交数据时，如果属性action为空，提交的数据应有当前URL来接收和处理，否则网页会跳转到属性action所指向的URL地址。
请求方式用于设置表单提交方式，通常时GET请求或POST请求，由控件的属性method决定。
元素控件时供用户输入数据信息的输入框。由HTML的控件实现，其控件属性type用于设置输入框的类型，常用的输入框类型有文本框、下拉框和复选框。
提交按钮供用户提交数据到服务器，该按钮也是由HTML的控件实现的。但该按钮具有一定的特殊性，因此不归纳到元素控件的范围内。

在模板文件中，直接编写表单时一个较为简单的实现方式，如果表单元素较多，会在无形中增加模板的代码量，这样对日后维护和更新造成极大的不便。为了简化表单的实现过程和提高表单的灵活性，Django提供了完善的表单功能。我们对MyDjango目录做了细微调整，如下：

在这里插入图片描述

在MyDjango的index中添加了而空白文件form.py，该文件主要用于编写表单的实现功能，文件夹可自行命名；同时在文件夹templates中添加模板文件data_form.html，该文件用于将表单数据像是在网页上。form.py、views.py和data_form.html中分别添加如下代码：

from django import forms
from .models import *

class ProductForm(forms.Form):
name = forms.CharField(max_length=20, label=‘名字’,)
weight = forms.CharField(max_length=50, label=‘重量’)
size = forms.CharField(max_length=50, label=‘尺寸’)

choices_list = [(i+1, v[‘type_name’]) for i,v in enumerate(Type.objects.values(‘type_name’))]
type = forms.ChoiceField(choices=choices_list, label=‘产品类型’)

from django.shortcuts import render
from .form import *
def index(request):
product = ProductForm()
return render(request, ‘data_form.html’,locals())

数据出错啦，错误信息：{ { product.errors }}.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

上述代码显示了Django内置表单功能的使用方法，主要由form.py、view.py和data_form.html共同实现，实现说明如下：

在form.py中定义表单ProduceForm，表单以类的形式表示。在表单中定义不同类型类的属性，这些属性在表单中称为表单字段，每个字段代表HTML里的一个控件，这是表单的基本组成单位。
在views.py中导入form.py所定义的ProductForm类，在视图函数index中ProductForm实例化生成对象product，再将对象product传递给模板data_form.html
模板data_form.html将对象product以HTML的的形式展示在网页上

在这里插入图片描述
2，表单的定义

Django的表单功能主要是通过定义表单类，再由类的实例化生成HTML的表单元素控件，这样，可以在模板中减少HTML的编码，每个HTML的表单元素控件有表达那字段决定，代码如下:

#表单类ProductForm的表单字段name
name = forms.CharField(max_length=20, label=‘名字’,)
#表单字段name所生成的HTML元素控件

1
2
3
4
5
6
7

从表单字段转换HTML元素控件可以发现：

字段name的参数label将转换成HTML的标签
字段name的form.CharField类型转换成HTML的控件，标签是一个输入框控件，type="text"代表当前输入框为文本输入框，参数type用于设置输入框的类型
字段name的命名转换成控件的参数name，表单字段的参数max_length将转换成控件的参数required maxlength。

除了上述表单字段外，Django还提供了多种内置的表单字段

在这里插入图片描述

表单字段除了转换HTML控件外，还有一定的数据格式规范，数据格式规范主要由字段类型和字段参数实现，每个不同类型的表单字段都由一些自己特殊的参数，但每个表单字段都具有共同参数，如下：

required=True #请求不能为空
widget=None #HTML插件
label=None #用于生成lable标签或显示内容
initial=None #初始值
help_text=’’ #帮助信息（在标签旁边显示） error_messages=None #（错误信息{‘required’:‘不能为空’，‘invalid’：‘格式错误’}） show_hidden_initial=False#是否在当前插件后面加一个隐藏的并且有默认值的插件（可用于检验两次输入是否一致）
validators=() #自定义验证规则 localize=False #是否支持本地化 disabled=False #是否可以编辑 label_suffix=None #label内容后缀

1
2
3
4
5
6

我们对form.py的表单ProductForm的字段进行优化，代码如下：

from django import forms
from .models import *
from django.core.exceptions import ValidationError # 自定义数据验证函数 def weight_validate(value):
if not str(value).isdigit():
raise ValidationError(‘请输入正确的重量’) # 表单 】
class ProductForm(forms.Form): # 设置错误信息并设置样式
name = forms.CharField(max_length=20, label=‘名字’, widget=forms.widgets.TextInput(attrs={‘class’: ‘c1’}), error_messages={‘required’: ‘名字不能为空’},) # 使用自定义数据验证函数
weight = forms.CharField(max_length=50, label=‘重量’,
validators=[weight_validate])
size = forms.CharField(max_length=50, label=‘尺寸’) # 获取数据库数据 choices_list = [(i+1, v[‘type_name’]) for i,v in enumerate(Type.objects.values(‘type_name’))] # 设置CSS样式 type = forms.ChoiceField(widget=forms.widgets.Select(attrs={‘class’: ‘type’,‘size’:‘4’}), choices=choices_list,label=‘产品类型’)

1
2
3
4
5
6
7
8
9
10

优化的代码分别使用了widget、label、error_messages和validators，这四个参数是实际开发过程中常用的参数，参数说明如下：

参数widget是一个form.widgets对象，其作用是设置表单字段的CSS央视。widget的对象类型应与表单字段类型相符合，如果字段类型为CharField和widget的对象类型为form.widgets.TextInput，二者的含义与作用是一致的，都代表文本输入框；如果字段类型为ChoiceField和widget的对象类型为form.widgets.TextInput相结合，前者是下拉选择框，后者是文本输入框，那么网页就会优先显示为文本输入框。
参数label会转换成HTML的标签，作用是对控件的描述和命名，使用户理解控件的作用和含义。
参数error_messages用于设置数据验证是被后的错误信息，参数值以字典形式表示，字典的健为表单字段的参数名，字典的值为错误信息。
参数validators用于自定义数据验证函数，当前用户提交表单数据后，首先执行自定义的验证函数，当数据验证失败后，会抛出设置参数error_messages，因为数据验证已由参数validators优先处理。

为了进一步验证优化后的