在 ORM 框架中，所有模型相关的操作，比如添加/删除等，其实都是映射到数据库中一条数据的操作，因此模型操作也就是数据库表中数据的操作。首先需要创建一个模型。添加模型到数据库中。from django.db import models # Create your models here. class User(models.Model): username = models.CharField(max_length=20) password = models.CharField(max_length=100) # 表一对一,用户表和用户信息表, 常用和不常用 class UserExtension(models.Model): birthday = models.DateTimeField() university = models.CharField(max_length=200) user = models.OneToOneField("User", on_delete=models.CASCADE) class Article(models.Model): title = models.CharField(max_length=100) content = models.TextField() pub_time = models.DateTimeField(auto_now_add=True, null=True) author = models.ForeignKey( "User", on_delete=models.SET_DEFAULT, default=1, related_name="articles" ) tags = models.ManyToManyField("Tag", related_name="articles") class Tag(models.Model): name = models.CharField(max_length=100) class Comment(models.Model): content = models.TextField() origin_comment = models.ForeignKey("self", on_delete=models.CASCADE, null=True)添加一个模型实例到数据库中添加模型到数据库中，首先需要创建一个模型，创建模型的方式很简单，就跟创建普通的 Python 对象是一摸一样的。在创建完模型之后，需要调用模型的 save 方法，这样 Django 会自动的将这个模型转换成sql 语句，然后存储到数据库中。from django.shortcuts import HttpResponse def add_user(request): user = User(username="xiaoming", password="111111") # 调用save()方法：是将模型对象的数据保存到数据库表中，即在数据库表中插入一条新的记录。 user.save() return HttpResponse(f"用户 {user.username} 添加成功!")执行访问以上视图函数 add_user 就会往User这个表里面添加一条数据二次添加或者更新数据，比如创建用户时没创建UserExtension 表里的数据from django.shortcuts import HttpResponse from django.utils import timezone from .models import User, UserExtension def add_user_extension(request): # 获取已经存在的用户 try: user = User.objects.get(username="xiaoming") except User.DoesNotExist: return HttpResponse("用户 xiaoming 不存在。") # 准备要添加的扩展信息数据 birthday = "2024-08-01" university = "Example University" # 创建或更新 UserExtension 数据 user_extension, created = UserExtension.objects.get_or_create( user=user, defaults={'birthday': birthday, 'university': university} ) if not created: # UserExtension 已经存在，更新数据 user_extension.birthday = birthday user_extension.university = university user_extension.save() return HttpResponse(f"用户 {user.username} 的扩展信息已更新。") return HttpResponse(f"用户 {user.username} 的扩展信息已添加。")get_or_create() ：尝试在数据库中获取一个匹配的对象。如果找到了对象，返回该对象和一个布尔值 False，表示对象不是新创建的。如果没有找到对象，创建一个新的对象并保存到数据库中，然后返回该对象和一个布尔值 True，表示对象是新创建的。user=user ：左边的 user 是 UserExtension 模型中的字段。右边的 user 是你在代码中获取或创建的 User 对象，这行代码的意思是在 UserExtension 表中查找 user 字段等于指定 User 对象的记录。efaults={'birthday': birthday, 'university': university}** **：get_or_create 方法的一个参数，它用于在对象不存在时指定默认值。defaults: 这是一个字典，包含了一组键值对，用于在创建新对象时提供默认值。'birthday': birthday: 如果创建新对象，使用 birthday 变量的值作为 birthday 字段的默认值。user_extension, created = ... ：这行代码将 get_or_create 方法的返回值解包为两个变量：user_extension: 这是获取到的或新创建的 UserExtension 对象。created: 这是一个布尔值，如果对象是新创建的，则为 True，否则为 False查找数据查找数据都是通过模型下的 objects 对象来实现的。查找所有数据要查找 User 这个模型对应的表下的所有数据，使用.all() 将返回 模型下的所有数据。users = User.objects.all()数据过滤在查找数据的时候，有时候需要对一些数据进行过滤。那么这时候需要调用 objects 的 filter 方法。users = User.objects.filter(username="chixm") for user in users: print({user.username}) 获取单个对象objects.get 是 Django ORM 中用于从数据库中获取单个对象的方法。它期望查询条件只返回一个对象，如果查询结果中没有对象或有多个对象，会抛出相应的异常。用于获取符合条件的唯一对象，适用于查询结果唯一的情况。user = User.objects.get(username="henry") 数据排序在之前的例子中，数据都是无序的。如果你想在查找数据的时候使用某个字段来进行排序，那么可以使用 order_by 方法来实现。users = User.objects.order_by("username")以上代码在提取所有用户名数据的时候，将会使用 username 首字母从小到大进行排序。如果想要进行倒序排序，那么可以在 username 前面加一个负号。users = User.objects.order_by("-username")修改数据在查找到数据后，便可以进行修改了。修改的方式非常简单，只需要将查找出来的对象的某个属性进行修改，然后再调用这个对象的 save 方法便可以进行修改。def modify_user(request): user = User.objects.get(id=1) user.username = "ching" user.save() return HttpResponse("success!") 删除数据在查找到数据后，便可以进行删除了。删除数据非常简单，只需要调用这个对象的 delete 方法即可。def delete_user(request): user = User.objects.get(id=2) user.delete() return HttpResponse("delete success!") 查询操作查找是数据库操作中一个非常重要的技术。查询一般就是使用 filter 、 exclude 以及 get 三个方法来实现。我们可以在调用这些方法的时候传递不同的参数来实现查询需求。在 ORM 层面，这些查询条件都是使用 field + __ + condition 的方式来使用的。查询条件exact使用精确的 = 进行查找。如果提供的是一个 None ，那么在 SQL 层面就是被解释为 NULL 。article = Article.objects.get(id__exact=14) article = Article.objects.get(id__exact=None)以上的两个查找在翻译为 SQL 语句为如下：select ... from article where id=14; select ... from article where id IS NULL;查询结果 .query 看到就可以看到底层执行的 SQL 语句，如上就是 article.queryiexact使用 like 是忽略大小写进行查找。article = Article.objects.filter(title__iexact='hello world')那么以上的查询就等价于以下的 SQL 语句：select ... from article where title like 'hello world';注意上面这个 sql 语句，因为在 MySQL 中，没有一个叫做 ilike 的。所以 exact 和 iexact 的区别实际上就是 LIKE 和 = 的区别，在大部分 collation=utf8_general_ci 情况下都是一样的（ collation 是 用来对字符串比较的）。contains大小写敏感，判断某个字段是否包含了某个数据。articles = Article.objects.filter(title__contains='hello')在翻译成 SQL 语句为如下：select ... where title like binary '%hello%';在使用 contains 的时候，翻译成的 sql 语句左右两边是有百分号的，意味着使用的是模糊查询。而 exact 翻译成 sql 语句左右两边是没有百分号的，意味着使用的是精确的查询。icontains大小写不敏感的匹配查询。articles = Article.objects.filter(title__icontains='hello')在翻译成 SQL 语句为如下：select ... where title like '%hello%';in提取那些给定的 field 的值是否在给定的容器中。容器可以为 list 、 tuple 或者任何一个可以迭代的对象，包括 QuerySet 对象。（可以用一个列表、元组或其他可迭代对象里的值来筛选数据库中的记录）articles = Article.objects.filter(id__in=[1,2,3])以上代码在翻译成 SQL 语句为如下：select ... where id in (1,3,4)当然也可以传递一个 QuerySet 对象进去。inner_qs = Article.objects.filter(title__contains='hello') categories = Category.objects.filter(article__in=inner_qs)以上代码的意思是获取那些文章标题包含 hello 的所有分类。将翻译成以下 SQL 语句，示例代码如下：select ...from category where article.id in (select id from article where title like '%hello%');gt某个 field 的值要大于给定的值。articles = Article.objects.filter(id__gt=4)以上代码的意思是将所有 id 大于4的文章全部都找出来。将翻译成以下 SQL 语句：select ... where id > 4;gte类似于 gt ，是大于等于。lt类似于 gt 是小于。lte类似于 lt ，是小于等于。startswith判断某个字段的值是否是以某个值开始的。大小写敏感。articles = Article.objects.filter(title__startswith='hello')以上代码的意思是提取所有标题以 hello 字符串开头的文章。将翻译成以下 SQL 语句：select ... where title like 'hello%'istartswith类似于 startswith ，但是大小写是不敏感的。endswith判断某个字段的值是否以某个值结束。大小写敏感。articles = Article.objects.filter(title__endswith='world')以上代码的意思是提取所有标题以 world 结尾的文章。将翻译成以下 SQL 语句：select ... where title like '%world';iendswith类似于 endswith ，只不过大小写不敏感。range判断某个 field 的值是否在给定的区间中。from django.utils.timezone import make_aware from datetime import datetime start_date = make_aware(datetime(year=2024,month=1,day=1)) end_date = make_aware(datetime(year=2024,month=3,day=29,)) articles = Article.objects.filter(pub_date__range=(start_date,end_date))以上代码的意思是提取所有发布时间在 2024/1/1 到 2024/3/29 之间的文章。将翻译成以下的 SQL 语句：select ... from article where pub_time between '2024-01-01' and '2024-03-29'需要注意的是，以上提取数据，不会包含最后一个值。也就是不会包含 2024/3/29 的文章。date针对某些 date 或者 datetime 类型的字段。可以指定 date 的范围。并且这个时间过滤，还可以使用链式调用。articles = Article.objects.filter(pub_date__date=date(2024,3,29))以上代码的意思是查找时间为 2024/3/29 这一天发表的所有文章。将翻译成以下的 sql 语句：select ... WHERE DATE(CONVERT_TZ(`front_article`.`pub_date`, 'UTC', 'Asia/Shanghai')) = 2018-03-29year根据年份进行查找。articles = Article.objects.filter(pub_date__year=2024) articles = Article.objects.filter(pub_date__year__gte=2023)以上的代码在翻译成 SQL 语句为如下：select ... where pub_date between '2024-01-01' and '2024-12-31'; select ... where pub_date >= '2023-01-01';month同 year ，根据月份进行查找。day同 year ，根据日期进行查找。week_dayDjango 1.11 新增的查找方式。同 year ，根据星期几进行查找。1表示星期天，7表示星期六， 2-6 代表的是星期一到星期五。time根据时间进行查找。articles = Article.objects.filter(pub_date__time=datetime.time(12,12,12));以上的代码是获取每一天中12点12分12秒发表的所有文章。 更多的关于时间的过滤，可以参考 Django 官方文档：https://docs.djangoproject.com/zh-hans/5.0/ref/models/querysets/#rangeisnull根据值是否为空进行查找。articles = Article.objects.filter(pub_date__isnull=False)以上的代码的意思是获取所有发布日期不为空的文章。将来翻译成 SQL 语句如下：select ... where pub_date is not null;regex和iregex大小写敏感和大小写不敏感的正则表达式。articles = Article.objects.filter(title__regex=r'^hello')以上代码的意思是提取所有标题以 hello 字符串开头的文章。将翻译成以下的 SQL 语句：select ... where title regexp binary '^hello';iregex 是大小写不敏感的。根据关联的表进行查询假如现在有两个 ORM 模型，一个是 Article ，一个是 Category 。class Category(models.Model): """文章分类表""" name = models.CharField(max_length=100) class Article(models.Model): """文章表""" title = models.CharField(max_length=100,null=True) category = models.ForeignKey("Category",on_delete=models.CASCADE)比如想要获取文章标题中包含"hello"的所有的分类。categories = Category.object.filter(article__title__contains("hello"))聚合函数如果使用原生 SQL ，则可以使用聚合函数来提取数据。比如提取某个商品销售的数量，那么可以使用Count ，如果想要知道商品销售的平均价格，那么可以使用 Avg 。 在Django ORM中，聚合函数通过aggregate方法来实现。Django提供了一组聚合函数，允许你在查询集中执行聚合计算，包括Count、Avg、Sum、Max、Min等。from django.db import models class Author(models.Model): """作者模型""" name = models.CharField(max_length=100) age = models.IntegerField() email = models.EmailField() class Meta: db_table = 'author' class Publisher(models.Model): """出版社模型""" name = models.CharField(max_length=300) class Meta: db_table = 'publisher' class Book(models.Model): """图书模型""" name = models.CharField(max_length=300) pages = models.IntegerField() price = models.FloatField() rating = models.FloatField() author = models.ForeignKey(Author,on_delete=models.CASCADE) publisher = models.ForeignKey(Publisher, on_delete=models.CASCADE) class Meta: db_table = 'book' class BookOrder(models.Model): """图书订单模型""" book = models.ForeignKey("Book",on_delete=models.CASCADE) price = models.FloatField() class Meta: db_table = 'book_order'以下这些聚合函数的用法，都是基于以上的模型对象来实现的。Avg ：求平均值比如想要获取所有图书的价格平均值。from django.db.models import Avg result = Book.objects.aggregate(Avg('price')) print(result)以上的打印结果是： {"price__avg":23.0}其中 price__avg 的结构是根据 field__avg 规则构成的。如果想要修改默认的名字，那么可以将 Avg 赋值给一个关键字参数。from django.db.models import Avg result = Book.objects.aggregate(my_avg=Avg('price')) print(result)那么以上的结果打印为： {"my_avg":23}Count ：获取指定的对象的个数from django.db.models import Count result = Book.objects.aggregate(book_num=Count('id'))以上的 result 将返回 Book 表中总共有多少本图书。Count 类中，还有另外一个参数叫做 distinct ，默认是等于 False ，如果是等于 True ，那么将去掉那些重复的值。比如要获取作者表中所有的不重复的邮箱总共有多少个，那么可以通过以下代码来实现：from djang.db.models import Count result = Author.objects.aggregate(count=Count('email',distinct=True))Max 和Min ：获取指定对象的最大值和最小值比如想要获取 Author 表中，最大的年龄和最小的年龄分别是多少。from django.db.models import Max,Min result = Author.objects.aggregate(Max('age'),Min('age'))如果最大的年龄是88,最小的年龄是18。那么以上的result将为：{"age__max":88,"age__min":18}Sum ：求指定对象的总和比如要求图书的销售总额。from djang.db.models import Sum result = Book.objects.annotate(total=Sum("bookstore__price")).values("name","total")以上的代码 annotate 的意思是给 Book 表在查询的时候添加一个字段叫做 total ，这个字段的数据来源是从 BookStore 模型的 price 的总和而来。 values 方法是只提取 name 和 total 两个字段的值。更多的聚合函数可以参考官方文档：https://docs.djangoproject.com/zh-hans/5.0/ref/models/querysets/#aggregation-functionsaggregate和annotate的区别aggregate ：返回使用聚合函数后的字段和值。annotate ：在原来模型字段的基础之上添加一个使用了聚合函数的字段，并且在使用聚合函数的时候，会使用当前这个模型的主键进行分组（group by）。比如以上 Sum 的例子，如果使用的是 annotate ，那么将在每条图书的数据上都添加一个字段叫做total ，计算这本书的销售总额。而如果使用的是 aggregate ，那么将求所有图书的销售总额。F表达式和Q表达式F表达式F表达式 是用来优化 ORM 操作数据库的。比如我们要将公司所有员工的薪水都增加1000元，如果按照正常的流程，应该是先从数据库中提取所有的员工工资到Python内存中，然后使用Python代码在员工工资的基础之上增加1000元，最后再保存到数据库中。这里面涉及的流程就是，首先从数据库中提取数据到Python内存中，然后在Python内存中做完运算，之后再保存到数据库中。employees = Employee.objects.all() for employee in employees: employee.salary += 1000 employee.save()而 F表达式 就可以优化这个流程，它可以不需要先把数据从数据库中提取出来，计算完成后再保存回去，他可以直接执行 SQL语句 ，就将员工的工资增加1000元。from djang.db.models import F Employee.object.update(salary=F("salary")+1000)F表达式 并不会马上从数据库中获取数据，而是在生成 SQL 语句的时候，动态的获取传给 F表达式 的值。比如如果想要获取作者中， name 和 email 相同的作者数据。如果不使用 F表达式 ，那么需要使用以下代码来完成： authors = Author.objects.all() for author in authors: if author.name == author.email: print(author)如果使用 F表达式 ，那么一行代码就可以搞定。from django.db.models import F authors = Author.objects.filter(name=F("email"))Q表达式如果想要实现所有价格高于100元，并且评分达到9.0以上评分的图书。那么可以通过以下代码来实现：books = Book.objects.filter(price__gte=100,rating__gte=9)以上这个案例是一个并集查询，可以简单的通过传递多个条件进去来实现。 但是如果想要实现一些复杂的查询语句，比如要查询所有价格低于10元，或者是评分低于9分的图书。那就没有办法通过传递多个条件进去实现了。这时候就需要使用 Q表达式 来实现了。示例代码如下：from django.db.models import Q books = Book.objects.filter(Q(price__lte=10) | Q(rating__lte=9))以上是进行或运算，当然还可以进行其他的运算，比如有 & 和 ~ （非） 等。一些用Q表达式的例子如下from django.db.models import Q # 获取id等于3的图书 books = Book.objects.filter(Q(id=3)) # 获取id等于3，或者名字中包含文字"记"的图书 books = Book.objects.filter(Q(id=3)|Q(name__contains("记"))) # 获取价格大于100，并且书名中包含"记"的图书 books = Book.objects.filter(Q(price__gte=100)&Q(name__contains("记"))) # 获取书名包含“记”，但是id不等于3的图书 books = Book.objects.filter(Q(name__contains='记') & ~Q(id=3))
Django数据库MySQL驱动程序安装使用 Django 来操作 MySQL ，实际上底层还是通过 Python 来操作的。因此想要用 Django 来操作 MySQL ，首先还是需要安装一个驱动程序。在 Python3 中，驱动程序有多种选择。比如有 pymysql 以及 mysqlclient 等。这里我们就使用 mysqlclient 来操作。mysqlclient 安装非常简单pip install mysqlclient配置连接数据库在操作数据库之前，首先要连接数据库，这里以配置 MySQL 为例。Django 连接数据库，不需要单独的创建一个连接对象。只需要在 settings.py 文件中找到DATABASES字段做好数据库相关的配置就可以了。DATABASES = { "default": { # 数据库引擎（是mysql还是oracle等） "ENGINE": "django.db.backends.mysql", # 数据库的名字 "NAME": "database_django", # 连接mysql数据库的用户名 "USER": "root", # 连接mysql数据库的密码 "PASSWORD": "root", # mysql数据库的主机地址 "HOST": "127.0.0.1", # mysql数据库的端口号 "PORT": "3306", } }其中 engine 的选择还有以下：'django.db.backends.postgresql''django.db.backends.mysql''django.db.backends.sqlite3''django.db.backends.oracle'在Django中操作数据库在 Django 中操作数据库有两种方式。第一种方式就是使用原生 sql 语句操作，第二种就是使用 ORM 模型来操作。本笔记记录使用ORM 模型来操作，这里稍微记录一下原生 sql 语句操作在 Django 中使用原生 sql 语句操作其实就是使用 python db api 的接口来操作。如果你的 mysql 驱动使用的是 pymysql ，那么你就是使用 pymysql 来操作的，只不过 Django 将数据库连接的这一部分封装好了，我们只要在 settings.py 中配置好了数据库连接信息后直接使用 Django 封装好的接口就可以操作了。# 使用django封装好的connection对象，会自动读取settings.py中数据库的配置信息 from django.db import connection # 获取游标对象 cursor = connection.cursor() # 拿到游标对象后执行sql语句 cursor.execute("select * from book") # 获取所有的数据 rows = cursor.fetchall() # 遍历查询到的数据 for row in rows: print(row)以上的 execute 以及 fetchall 方法都是 Python DB API 规范中定义好的。ORM模型介绍ORM ，全称 Object Relational Mapping ，中文叫做对象关系映射，通过 ORM 我们可以通过类的方式去操作数据库，而不用再写原生的SQL语句。通过把表映射成类，把行作实例，把字段作为属性， ORM 在执行对象操作的时候最终还是会把对应的操作转换为数据库原生语句。创建ORM模型ORM 模型一般都是放在 app 的 models.py 文件中。每个 app 都可以拥有自己的模型。并且如果这个模型想要映射到数据库中，那么这个 app 必须要放在 settings.py 的 INSTALLED_APP 中进行安装。以下是写一个简单的书籍 ORM 模型。# 从Django的 django.db 模块中导入了 models 模块 # models 模块包含了用于定义各种数据库字段类型和模型的类 from django.db import models # 定义了一个名为 Book 的类，并继承自 models.Model # 继承 models.Model 表示这个类是一个Django模型，将映射到数据库中的一个表 class Book(models.Model): # 包含四个字段：name、author、pub_time 和 price name = models.CharField(max_length=20,null=False) author = models.CharField(max_length=20,null=False) pub_time = models.DateTimeField(auto_add_now=True) price = models.FloatField(default=0)以上便定义了一个模型。这个模型继承自 django.db.models.Model，如果这个模型想要映射到数据库中，就必须继承自这个类。这个模型以后映射到数据库中，表名是模型名称的小写形式，为 book 。在这个表中，有四个字段，还有一个字段没有写，就是主键 id ，在 django 中，如果一个模型没有定义主键，那么将会自动生成一个自动增长的 int 类型的主键，并且这个主键的名字就叫做 id 。映射模型到数据库中将 ORM 模型映射到数据库中，总结起来就是以下几步：1.在 settings.py 中，配置好 DATABASES ，做好数据库相关的配置。2.在 app 中的 models.py 中定义好模型，这个模型必须继承自 django.db.models 。3.将这个 app 添加到 settings.py 的 INSTALLED_APP 中的末尾。INSTALLED_APPS = [ ... "django.contrib.messages", "django.contrib.staticfiles", # "APP 名称", ]4在命令行终端，进入到项目所在的路径，然后执行命令 python manage.py makemigrations 来生成迁移脚本文件。5.同样在命令行中，执行命令 python manage.py migrate 来将迁移脚本文件映射到数据库中。模型常用Field和参数在 Django 中，定义了一些 Field 来与数据库表中的字段类型来进行映射。在Django模型中，字段用于定义模型的属性，代表数据库表中的列。每个字段代表一个特定的数据类型，并定义可以存储在相应列中的数据类型。Django提供了多种字段类型来处理不同的数据类型和约束。常用字段的示例：from django.db import models # CharField类 class Book(models.Model): title = models.CharField(max_length=100) # 存储书名的字段（最大长度：100个字符） # IntegerField类 class Student(models.Model): age = models.IntegerField() # 存储学生年龄的字段 # FloatField类 class Product(models.Model): price = models.FloatField() # 存储产品价格的字段 # DateField类 class Event(models.Model): event_date = models.DateField() # 存储事件日期的字段 # DateTimeField类 class Post(models.Model): pub_date = models.DateTimeField() # 存储帖子发布日期和时间的字段 # BooleanField类 class Task(models.Model): is_completed = models.BooleanField() # 存储任务完成状态的字段 # ForeignKey类 class Author(models.Model): name = models.CharField(max_length=100) class Book(models.Model): title = models.CharField(max_length=100) author = models.ForeignKey(Author, on_delete=models.CASCADE) # 外键字段，建立一对多关系 # ManyToManyField类 class Course(models.Model): name = models.CharField(max_length=100) class Student(models.Model): name = models.CharField(max_length=100) courses = models.ManyToManyField(Course) # 多对多字段，建立多对多关系 # EmailField类 class Contact(models.Model): email = models.EmailField() # 存储联系人电子邮件地址的字段 # ImageField类 class UserProfile(models.Model): profile_picture = models.ImageField(upload_to='profile_pics/') # 存储用户个人资料图片的字段常用字段AutoField：映射到数据库中是 int 类型，可以有自动增长的特性。一般不需要使用这个类型，如果不指定主键，那么模型会自动的生成一个叫做 id 的自动增长的主键。如果你想指定一个其他名字的并且具有自动增长的主键，使用 AutoField 也是可以的。BigAutoField：64位的整形，类似于 AutoField ，只不过是产生的数据的范围是从 1-9223372036854775807 。BooleanField：在模型层面接收的是 True/False 。在数据库层面是 tinyint 类型。如果没有指定默认值，默认值是None 。CharField：在数据库层面是 varchar 类型。在 Python 层面就是普通的字符串。这个类型在使用的时候必须要指定最大的长度，也即必须要传递 max_length 这个关键字参数进去。DateField：日期类型。在 Python 中是 datetime.date 类型，可以记录年月日。在映射到数据库中也是 date 类型。使用这个 Field 可以传递以下几个参数：auto_now ：在每次这个数据保存的时候，都使用当前的时间。比如作为一个记录修改日期的字段，可以将这个属性设置为 True 。auto_now_add ：在每次数据第一次被添加进去的时候，都使用当前的时间。比如作为一个记录第一次入库的字段，可以将这个属性设置为 True 。DateTimeField：日期时间类型，类似于 DateField 。不仅仅可以存储日期，还可以存储时间。映射到数据库中是datetime 类型。这个 Field 也可以使用 auto_now 和 auto_now_add 两个属性。TimeField：时间类型。在数据库中是 time 类型。在 Python 中是 datetime.time 类型。EmailField：类似于 CharField 。在数据库底层也是一个 varchar 类型。最大长度是254个字符。FileField：用来存储文件的ImageField：用来存储图片文件的FloatField：浮点类型。映射到数据库中是 float 类型。IntegerField：整形。值的区间是 -2147483648—2147483647 。BigIntegerField大整形。值的区间是 -9223372036854775808—9223372036854775807 。PositiveIntegerField：正整形。值的区间是 0—2147483647 。SmallIntegerField：小整形。值的区间是 -32768—32767 。PositiveSmallIntegerField：正小整形。值的区间是 0—32767 。TextField：大量的文本类型。映射到数据库中是longtext类型。UUIDField：只能存储 uuid 格式的字符串。 uuid 是一个32位的全球唯一的字符串，一般用来作为主键。URLField：类似于 CharField ，只不过只能用来存储 url 格式的字符串。并且默认的 max_length 是200。Field的常用参数在Django模型中初始化字段时，可以使用各种参数来自定义字段的行为。每个参数都有特定的目的，并允许您定义字段的特性和约束。以下是初始化字段时使用的一些常见参数：from django.db import models # max_length：指定字段的最大长度 # min_length：指定字段的最低长度 class Book(models.Model): title = models.CharField(max_length=100, min_length=1) # null：确定字段是否可以存储NULL值 class Student(models.Model): name = models.CharField(max_length=100) age = models.IntegerField(null=True) # blank：指示字段是否允许为空 class Article(models.Model): title = models.CharField(max_length=100, blank=True) # default：为字段设置默认值 class Order(models.Model): order_number = models.CharField(max_length=10, default="0000") # choices：为字段提供选项列表 GENDER_CHOICES = [ ('M', 'Male'), ('F', 'Female'), ('O', 'Other'), ] class Person(models.Model): name = models.CharField(max_length=100) gender = models.CharField(max_length=1, choices=GENDER_CHOICES) # primary_key：指示字段是否为模型的主键 class UserProfile(models.Model): user_id = models.AutoField(primary_key=True) username = models.CharField(max_length=100) # unique：指定字段的值必须在所有模型实例中唯一 class Product(models.Model): product_code = models.CharField(max_length=10, unique=True) # verbose_name：为字段设置一个人类可读的名称 class Car(models.Model): make = models.CharField(max_length=100, verbose_name="Car Make") # help_text：为字段提供额外的描述性文本 class Employee(models.Model): name = models.CharField(max_length=100, help_text="Employee's full name") # validators：允许您为字段指定验证器列表 from django.core.validators import MinValueValidator, MaxValueValidator class Score(models.Model): score = models.IntegerField(validators=[MinValueValidator(0), MaxValueValidator(100)]) # upload_to：与ImageField一起使用，指定上传文件的目录 class UserProfile(models.Model): name = models.CharField(max_length=100) profile_pic = models.ImageField(upload_to='profile_pics/') # db_index：指示字段是否应该有数据库索引以加快查询速度 class Person(models.Model): name = models.CharField(max_length=100, db_index=True) # editable：确定字段在表单和admin接口中是否可编辑 class Task(models.Model): task_name = models.CharField(max_length=100, editable=False) # db_column: 重命名当前字段，保存到数据时不使用name，而使用tag_name作为表的字段名 class Tag(models.Model): name = models.CharField(max_length=20,db_column="tag_name")max_length：指定字段的最大长度。这个参数适用于如CharField和CommaSeparatedIntegerField这样的字段。null：确定字段是否可以在数据库中存储NULL值。如果设置为True，则字段可以是NULL的；如果设置为False，则字段将有一个必填值。在使用字符串相关的Field （CharField / TextField）的时候，官方推荐尽量不要使用这个参数，也就是保持默认值 False 。blank：指示字段是否允许为空（即，包含一个空值）。如果设置为True，则字段可以为空；如果设置为False，则字段必须有一个值。这个和 null 是有区别的， null 是一个纯数据库级别的。而 blank 是表单验证级别的。default：为字段设置默认值。如果在创建对象时没有提供值，则将使用默认值。可以为一个值，或者是一个函数，但是不支持 lambda 表达式。并且不支持列表/字典/集合等可变的数据结构。choices：为字段提供选项列表。这个参数与如CharField和IntegerField这样的字段一起使用，以限制可能的值。primary_key：指示字段是否为模型的主键。只能有一个字段被设置为主键。unique：指定字段的值必须在所有模型实例中唯一。verbose_name：为字段设置一个人类可读的名称。这在表单或admin接口中显示字段时用作标签。help_text：为字段提供额外的描述性文本。当用户与字段交互时，此文本显示为工具提示或提示。validators：允许您为字段指定验证器列表。验证器是验证字段值的函数。upload_to：与ImageField一起使用，以指定上传文件应存储的目录。db_index：指示字段是否应该有数据库索引以加快editable：确定字段在表单和admin接口中是否可编辑。这对于不应该在admin界面中更改的字段（如自动生成的字段）很有用。db_column：这个字段在数据库中是表下的字段的名字。如果没有设置这个参数，那么将会使用模型中属性的名字。这些参数为Django模型中的字段行为提供了灵活性和控制。通过适当使用这些参数，您可以根据特定要求和约束定制字段。更多 Field 参数详情可以参考官方文档：https://docs.djangoproject.com/zh-hans/5.0/ref/models/fields/模型中Meta配置对于一些模型级别的配置。我们可以在模型中定义一个类，叫做 Meta 。然后在这个类中添加一些类属性来控制模型的作用。class Book(models.Model): name = models.CharField(max_length=20,null=False) desc = models.CharField(max_length=100,name='description',db_column="description1") pub_date = models.DateTimeField(auto_now_add=True) class Meta: db_table = 'book_model' ordering = ['pub_date']db_table：这个模型映射到数据库中的表名。如果没有指定这个参数，那么在映射的时候将会使用模型名来作为默认的表名ordering：设置在提取数据的排序方式，比如我想在查找数据的时候根据添加的时间排序模型 Meta 选项官方文档：https://docs.djangoproject.com/zh-hans/5.0/ref/models/options/外键和表关系外键在 MySQL 中，表有两种引擎，一种是 InnoDB ，另外一种是 myisam 。如果使用的是 InnoDB 引擎，是支持外键约束的。外键的存在使得 ORM 框架在处理表关系的时候异常的强大。外键在 Django 中的使用，类定义为 class ForeignKey(to,on_delete,**options) 。第一个参数是引用的是哪个模型，第二个参数是在使用外键引用的模型数据被删除了，这个字段该如何处理，比如有 CASCADE 、 SET_NULL等。这里以一个实际案例来说明。比如有一个 User 和一个 Article 两个模型。一个 User可以发表多篇文章，一个 Article 只能有一个 Author，并且通过外键进行引用。那么相关的示例代码如下：class User(models.Model): username = models.CharField(max_length=20) password = models.CharField(max_length=100) class Article(models.Model): title = models.CharField(max_length=100) content = models.TextField() author = models.ForeignKey("User",on_delete=models.CASCADE)以上使用 ForeignKey 来定义模型之间的关系。即在 article 的实例中可以通过 author 属性来操作对应的 User 模型。这样使用起来非常的方便。article = Article(title='abc',content='123') author = User(username='张三',password='111111') article.author = author article.save() # 修改article.author上的值 article.author.username = '李四' article.save()使用了 ForeignKey 后，就能通过 author 访问到对应的 user 对象的原因，是因为在底层， Django 为Article 表添加了一个 属性名_id 的字段（比如author的字段名称是author_id），这个字段是一个外 键，记录着对应的作者的主键。以后通过 article.author 访问的时候，实际上是先通过 author_id 找到对应的数据，然后再提取 User 表中的这条数据，形成一个模型。 如果想要引用另外一个 app 的模型，那么应该在传递 to 参数的时候，使用 app.model_name 进行指定。以上例为例，如果 User 和 Article 不是在同一个 app 中，那么在引用的时候的示例代码如下：# User模型在user这个app中 class User(models.Model): username = models.CharField(max_length=20) password = models.CharField(max_length=100) # Article模型在article这个app中 class Article(models.Model): title = models.CharField(max_length=100) content = models.TextField() author = models.ForeignKey("user.User",on_delete=models.CASCADE)如果模型的外键引用的是本身自己这个模型，那么 to 参数可以为 'self' ，或者是这个模型的名字。在论坛开发中，一般评论都可以进行二级评论，即可以针对另外一个评论进行评论，那么在定义模型的时 候就需要使用外键来引用自身。示例代码如下：class Comment(models.Model): content = models.TextField() origin_comment = models.ForeignKey('self',on_delete=models.CASCADE,null=True) # 或者 # origin_comment = models.ForeignKey('Comment',on_delete=models.CASCADE,null=True)外键删除操作如果一个模型使用了外键。那么在对方那个模型被删掉后，该进行什么样的操作。可以通过 on_delete 来指定。可以指定的类型如下：CASCADE ：级联操作。如果外键对应的那条数据被删除了，那么这条数据也会被删除。PROTECT ：受保护。即只要这条数据引用了外键的那条数据，那么就不能删除外键的那条数据。SET_NULL ：设置为空。如果外键的那条数据被删除了，那么在本条数据上就将这个字段设置为空。如果设置这个选项，前提是要指定这个字段可以为空。SET_DEFAULT ：设置默认值。如果外键的那条数据被删除了，那么本条数据上就将这个字段设置为默认值。如果设置这个选项，前提是要指定这个字段一个默认值。SET() ：如果外键的那条数据被删除了。那么将会获取 SET 函数中的值来作为这个外键的值。 SET函数可以接收一个可以调用的对象（比如函数或者方法），如果是可以调用的对象，那么会将这个对象调用后的结果作为值返回回去。DO_NOTHING ：不采取任何行为。一切全看数据库级别的约束。以上这些选项只是Django级别的，数据级别依旧是RESTRICT！表关系表之间的关系都是通过外键来进行关联的。而表之间的关系，无非就是三种关系：一对一、一对多（多对一）、多对多等。一对多应用场景：比如文章和作者之间的关系。一个文章只能由一个作者编写，但是一个作者可以写多篇文章。文章和作者之间的关系就是典型的多对一的关系。实现方式：一对多或者多对一，都是通过 ForeignKey 来实现的。还是以文章和作者的案例进行记录。class User(models.Model): username = models.CharField(max_length=20) password = models.CharField(max_length=100) class Article(models.Model): title = models.CharField(max_length=100) content = models.TextField() author = models.ForeignKey("User",on_delete=models.CASCADE)那么以后在给 Article 对象指定 author ，就可以使用以下代码来完成：article = Article(title='abc',content='123') author = User(username='zhiliao',password='111111') # 要先保存到数据库中 author.save() article.author = author article.save()并且以后如果想要获取某个用户下所有的文章，可以通过 article_set 来实现。user = User.objects.first() # 获取第一个用户写的所有文章 articles = user.article_set.all() for article in articles: print(article)一对一应用场景：比如一个用户表和一个用户信息表。在实际网站中，可能需要保存用户的许多信息，但是有些信息是不经常用的。如果把所有信息都存放到一张表中可能会影响查询效率，因此可以把用户的一些不常用的信息存放到另外一张表中我们叫做 UserExtension 。但是用户表 User 和用户信息表 UserExtension 就是典型的一对一了。实现方式： Django 为一对一提供了一个专门的 Field 叫做 OneToOneField 来实现一对一操作。class User(models.Model): username = models.CharField(max_length=20) password = models.CharField(max_length=100) class UserExtension(models.Model): birthday = models.DateTimeField(null=True) school = models.CharField(blank=True,max_length=50) user = models.OneToOneField("User", on_delete=models.CASCADE)在 UserExtension 模型上增加了一个一对一的关系映射。其实底层是在 UserExtension 这个表上增加了一个 user_id ，来和 user 表进行关联，并且这个外键数据在表中必须是唯一的，来保证一对一。多对多应用场景：比如文章和标签的关系。一篇文章可以有多个标签，一个标签可以被多个文章所引用。因此标签和文章的关系是典型的多对多的关系。实现方式： Django 为这种多对多的实现提供了专门的 Field 。叫做 ManyToManyField 。还是拿文章和标签为例进行讲解。class Article(models.Model): title = models.CharField(max_length=100) content = models.TextField() tags = models.ManyToManyField("Tag",related_name="articles") class Tag(models.Model): name = models.CharField(max_length=50)在数据库层面，实际上 Django 是为这种多对多的关系建立了一个中间表。这个中间表分别定义了两个外键，引用到 article 和 tag 两张表的主键。related_name和related_query_namerelated_name还是以 User 和 Article 为例来进行。如果一个 article 想要访问对应的作者，那么可以通过author 来进行访问。但是如果有一个 user 对象，想要通过这个 user 对象获取所有的文章，这时候可以通过 user.article_set 来访问，这个名字的规律是 模型名字小写_set 。user = User.objects.get(name='张三') user.article_set.all()如果不想使用 模型名字小写_set 的方式，想要使用其他的名字，那么可以在定义模型的时候指定related_nameclass Article(models.Model): title = models.CharField(max_length=100) content = models.TextField() # 传递related_name参数，以后在方向引用的时候使用articles进行访问 author = models.ForeignKey("User",on_delete=models.SET_NULL,null=True,related_name='articles')以后在反向引用的时候。使用 articles 可以访问到这个作者的文章模型。user = User.objects.get(name='张三') user.articles.all()如果不想使用反向引用，那么可以指定 related_name='+' class Article(models.Model): title = models.CharField(max_length=100) content = models.TextField() # 传递related_name参数，以后在方向引用的时候使用articles进行访问 author = models.ForeignKey("User",on_delete=models.SET_NULL,null=True,related_name='+')以后将不能通过 user.article_set 来访问文章模型了related_query_name在查找数据的时候，可以使用 filter 进行过滤。使用 filter 过滤的时候，不仅仅可以指定本模型上的某个属性要满足什么条件，还可以指定相关联的模型满足什么属性。比如现在想要获取写过标题为 abc 的所有用户，那么可以这样写：users = User.objects.filter(article__title='abc')如果设置了 related_name 为 articles ，因为反转的过滤器的名字将使用 related_name 的名字，那么上例代码将改成如下：users = User.objects.filter(articles__title='abc')可以通过 related_query_name 将查询的反转名字修改成其他的名字。比如 article 。示例代码如下：class Article(models.Model): title = models.CharField(max_length=100) content = models.TextField() # 传递related_name参数，以后在方向引用的时候使用articles进行访问 author = models.ForeignKey("User",on_delete=models.SET_NULL,null=True,related_name='articl es',related_query_name='article')那么在做反向过滤查找的时候就可以使用以下代码：users = User.objects.filter(article__title='abc')
目前市面上有非常多的模板系统，其中最知名最好用的就是DTL和Jinja2。 DTL 是 Django Template Language 三个单词的缩写，也就是Django自带的模板语言。当然也可以配置Django支持Jinja2等其他模板引擎，但是作为Django内置的模板语言，和Django可以达到无缝衔接而不会产生一些不兼容的情况。DTL与普通的HTML文件的区别DTL模板是一种带有特殊语法的HTML文件，这个HTML文件可以被Django编译，可以传递参数进去，实现数据动态化。在编译完成后，生成一个普通的HTML文件，然后发送给客户端。渲染模板渲染模板有多种方式。列举两种常用的方式。render_to_string ：找到模板，然后将模板编译后渲染成Python的字符串格式。最后再通过HttpResponse 类包装成一个 HttpResponse 对象返回回去。示例代码如下：from django.template.loader import render_to_string from django.http import HttpResponse def book_detail(request,book_id): html = render_to_string("detail.html") return HttpResponse(html)django还提供了一个更加简便的方式，直接将模板渲染成字符串和包装成 HttpResponse 对象一步到位完成。示例代码如下：from django.shortcuts import render def book_list(request): return render(request,'list.html')模板查找路径配置：在项目的 settings.py 文件中。有一个 TEMPLATES 配置，这个配置包含了模板引擎的配置，模板查找路径的配置，模板上下文的配置等。模板路径可以在两个地方配置。DIRS ：这是一个列表，在这个列表中可以存放所有的模板路径，以后在视图中使用 render 或者render_to_string 渲染模板的时候，会在这个列表的路径中查找模板。APP_DIRS ：默认为 True ，这个设置为 True 后，会在 INSTALLED_APPS 的安装了的 APP 下的templates 文件夹中查找模板。TEMPLATES = [ { .... # 定义存放模板的目录，这里使用 templates 目录 "DIRS": [BASE_DIR / "templates"], "APP_DIRS": True, "OPTIONS": { ... }, ] 查找顺序：比如代码 render('list.html') 。先会在 DIRS 这个列表中依次查找路径下有没有这个模板，如果有，就返回。如果 DIRS 列表中所有的路径都没有找到，那么会先检查当前这个视图所处的 app 是否已经安装，如果已经安装了，那么就先在当前这个 app 下的 templates 文件夹中查找模板，如果没有找到，那么会在其他已经安装了的 app 中查找。如果所有路径下都没有找到，那么会抛出一个 TemplateDoesNotExist 的异常。DTL模板语法变量：模板中可以包含变量， Django 在渲染模板的时候，可以传递变量对应的值过去进行替换。变量的命名规范和 Python 非常类似，只能是阿拉伯数字和英文字符以及下划线的组合，不能出现标点符号等特殊字符。变量需要通过视图函数渲染，视图函数在使用 render 或者 render_to_string 的时候可以传递一个context 的参数，这个参数是一个字典类型。以后在模板中的变量就从这个字典中读取值的。示例代码如下：# views.py代码 def profile(request): return render(request,'profile.html',context={'username':'陌上花'}) # profile.html模板代码 {{ username }} 除了变量，还可以是字典，列表以及对象。模板中的变量同样也支持 点(.) 的形式。# views.py代码 def info(request): # 1. 普通的变量 username = "悦来小陌" # 2. 字典类型 book = {"firm": "悦来集团", "name": "henry"} # 3. 列表 books = [ {"name": "全职高手", "author": "蝴蝶蓝"}, {"name": "斗破苍穹", "author": "天蚕土豆"}, ] # 4. 对象 class Person: def __init__(self, realname): self.realname = realname context = { "username": username, "book": book, "books": books, "Person": Person("陌上花"), } return render(request, "info.html", context=context) # infp.html模板代码 {{username}} 公司名称:{{book.firm}}, CEO: {{book.name}} 下标为 0 的小说作者是: {{books.0.author}} 下标为 1 的小说是: {{books.1.name}} 姓名为: {{Person.realname}} 在出现了点的情况，比如book.firm ，模板是按照以下方式进行解析的： 如果 book 是一个字典，那么就会查找这个字典的 firm 这个 key 对应的值。 如果 person 是一个对象，那么就会查找这个对象的 realname 属性，或者是 realname 这个方法。 如果出现的是 books.1 ，会判断 books 是否是一个列表或者元组或者任意的可以通过下标访问的对象，如果是的话就取这个列表的第1个值。如果不是就获取到的是一个空的字符串。 有以下几点需要注意： 不能通过中括号的形式访问字典和列表中的值，比如dict['key']和list[1]是不支持的！DTL模板语法里改为点（.）来访问，对应的应该是dict.key 和list.1 因为使用点（.）语法获取对象值的时候，可以获取这个对象的属性，如果这个对象是一个字典，也可以获取这个字典的值。所以在给这个字典添加key的时候，千万不能和字典中的一些属性重复。比如items，因为items是字典的方法，那么如果给这个字典添加一个items作为key，那么以后就不能再通过item来访问这个字典的键值对了。 常用的模板标签if 标签if 标签相当于 Python 中的 if 语句，有 elif 和 else 相对应，但是所有的标签都需要用标签符号（ {%%} ）进行包裹。if 标签中可以使用 ==、!=、<、<=、>、>=、in、not in、is、is not 等判断运算符。还有注意的是，使用if时有起始标签{% if %}，就要有结束标签{% endif %}{% if num > 18 %} 数字大于 18 {% elif num == 18 %} 数字等于 18 {% else %} 数字小于 18 {% endif %}for...in... 标签for...in... 类似于 Python 中的 for...in... 。可以遍历列表、元组、字符串、字典等一切可以遍历的对象。{% for person in persons %} {{ person.name }} {% endfor %}如果想要反向遍历，那么在遍历的时候就加上一个 reversed 。{% for person in persons reversed %} {{ person.name }} {% endfor %}遍历字典的时候，需要使用 items 、 keys 和 values 等方法。在 DTL 中，执行一个方法不能使用圆括号的形式。遍历字典示例代码如下： {% for key,value in person.items %} key：{{ key }} value：{{ value }} {% endfor %}在 for 循环中， DTL 提供了一些变量可供使用。这些变量如下：forloop.counter ：当前循环的下标。以1作为起始值。forloop.counter0 ：当前循环的下标。以0作为起始值。forloop.revcounter ：当前循环的反向下标值。比如列表有5个元素，那么第一次遍历这个属性是等于5，第二次是4，以此类推。并且是以1作为最后一个元素的下标。forloop.revcounter0 ：类似于 forloop.revcounter 。不同的是最后一个元素的下标是从0开始。forloop.first ：是否是第一次遍历。forloop.last ：是否是最后一次遍历。forloop.parentloop ：如果有多个循环嵌套，那么这个属性代表的是上一级的for循环。for...in...empty 标签这个标签使用跟 for...in... 是一样的，只不过是在遍历的对象如果没有元素的情况下，会执行 empty 中的内容。{% for person in persons %} {{ person }} {% empty %} 暂时还没有任何人 {% endfor %}with 标签在模版中定义变量。有时候一个变量访问的时候比较复杂，那么可以先把这个复杂的变量缓存到一个变量上，以后就可以直接使用这个变量就可以了。context = { "persons": ["xiaomo","henry"] } {% with lisi=persons.1 %} {{ lisi }} {% endwith %}有几点需要强烈的注意：在 with 语句中定义的变量，只能在 {%with%}{%endwith%} 中使用，不能在这个标签外面使用。定义变量的时候，不能在等号左右两边留有空格。比如 {% with lisi = persons.1%} 是错误的。还有另外一种写法同样也是支持的： {% with persons.1 as lisi %} {{ lisi }} {% endwith %}url 标签在模版中，经常要写一些 url ，比如某个a标签中需要定义 href 属性。当然如果通过硬编码的方式直接将这个 url 写死在里面也是可以的。但是这样对于以后项目维护可能不是一件好事。因此建议使用这种反转的方式来实现，类似于 django 中的 reverse 一样。图书列表页面如果 url 反转的时候需要传递参数，那么可以在后面传递。但是参数分位置参数和关键字参数。位置参数和关键字参数不能同时使用。# path部分 path('detail/<book_id>/',views.book_detail,name='detail') # url反转，使用位置参数 图书详情页面 # url反转，使用关键字参数 图书详情页面spaceless 标签移除html标签中的空白字符。包括空格、tab键、换行等。 {% spaceless %} Foo {% endspaceless %}那么在渲染完成后，会变成以下的代码： Foo aceless 只会移除html标签之间的空白字符。而不会移除标签与文本之间的空白字符。autoescape 标签开启和关闭这个标签内元素的自动转义功能。自动转义是可以将一些特殊的字符。比如<转义成 html 语法能识别的字符，会被转义成<，而>会被自动转义成 >。模板中默认是已经开启了自动转义的。# 传递的上下文信息 context = { "info":"百度" } # 模板中关闭自动转义 {% autoescape off %} {{ info }} {% endautoescape %}那么就会显示百度的一个超链接。如果把 off 改成 on ，那么就会显示成一个普通的字符串。{% autoescape on %} {{ info }} {% endautoescape %}更多标签可以查看官方文档：https://docs.djangoproject.com/zh-hans/5.0/ref/templates/builtins/模板常用过滤器在模版中，有时候需要对一些数据进行处理以后才能使用，一般在 Python 中是通过函数的形式来完成的。而在模版中，则是通过过滤器来实现的，过滤器使用的是|来使用。比如使用 add 过滤器，那么示例代码如下：开发中常用的过滤器cut移除值中所有指定的字符串。类似于 python 中的 replace(args,"") ，语法：示例 # 数据 greet = "Hello World, Hello Python, Hello Django" # 模板 {{greet}} > Hello World, Hello Python, Hello Django # 移除空格 > HelloWorld,HelloPython,HelloDjango # 移除逗号 >Hello World Hello Python Hello Django date将一个日期按照指定的格式，格式化成字符串。示例代码如下：# 数据 context = { "birthday": datetime.now() } # 模版 那么将会输出 2024/07/27 。其中Y代表的是四位数字的年份，m代表的是两位数字的月份，d代表的是两位数字的日。 还有更多时间格式化的方式。见下表。Y：四位数字的年份 （2024）m ：两位数字的月份（01-12） n ：月份，1-9前面没有0前缀（1-12） d ：两位数字的天（01-31） j ：天，但是1-9前面没有0前缀（1-31） g ：小时，12小时格式的，1-9前面没有0前缀（1-12） h ：小时，12小时格式的，1-9前面有0前缀（01-12） G ：小时，24小时格式的，1-9前面没有0前缀（1-23） H ：小时，24小时格式的，1-9前面有0前缀（01-23） i ：分钟，1-9前面有0前缀（00-59） s ：秒，1-9前面有0前缀（00-59）default如果值被评估为 False 。比如 [] ， "" ， None ， {} 等这些在 if 判断中为 False 的值，都会使用default 过滤器提供的默认值。语法 如果 value 是等于一个空的字符串。比如 ""# 数据 context = { "profile": "", } # 空字符就不会显示 {{profile_none}} # 由于是空字符，就会显示 default里定义的文字 这个家伙很懒,什么都没留下. default_if_none如果值是 None ，那么将会使用 default_if_none 提供的默认值。这个和 default 有区别， default 是所有被评估为 False 的都会使用默认值。而 default_if_none 则只有这个值是等于 None 的时候才会使用默认值。如果 value 是等于 "" 也即空字符串，那么以上会输出空字符串。如果 value 是一个 None 值，才会输出 nothing 。first返回列表/元组/字符串中的第一个元素。如果 value 是等于 ['a','b','c'] ，那么输出将会是alast返回列表/元组/字符串中的最后一个元素。如果 value 是等于 ['a','b','c'] ，那么输出将会是cfloatformat使用四舍五入的方式格式化一个浮点类型。如果这个过滤器没有传递任何参数，那么只会在小数点后保留一个小数。如果小数后面全是0，那么只会保留整数。也可以传递一个参数，标识具体要保留几个小数。# 数据 context = { "num": [34.45678, 18.000, 5.17], } 不传参数: >不传参数:34.5 传参数保留3位: >传参数保留3位:34.457 join类似与 Python 中的 join ，将列表/元组/字符串用指定的字符进行拼接。如果 value 是等于 ['a','b','c'] ，那么以上代码将输出 a/b/c 。length获取一个列表/元组/字符串/字典的长度。如果 value 是等于 ['a','b','c'] ，那么以上代码将输出3 如果 value 为 None ，那么以上将返回0random在被给的列表/字符串/元组中随机的选择一个值。如果 value 是等于 ['a','b','c'] ，那么以上代码会在列表中随机选择一个safe标记一个字符串是安全的。也即会关掉这个字符串的自动转义。如果 value 是一个不包含任何特殊字符的字符串，比如 这种，那么以上代码就会把字符串正常的输入。如果 value 是一串 html 代码，那么以上代码将会把这个 html 代码渲染到浏览器中。# 数据 context = { "html": " 欢迎来到悦来集团! ", } # 只会原封不动的带标签渲染显示出来 {{html}} > 欢迎来到悦来集团! # 会解析标签的作用，然后渲染显示 >欢迎来到悦来集团!slice类似于 Python 中的切片操作 将会给 some_list 从2开始做切片操作stringtags删除字符串中所有的 html 标签 如果 value 是 hello world ，那么以上代码将会输出 hello world 。truncatechars如果给定的字符串长度超过了过滤器指定的长度。那么就会进行切割，并且会拼接三个点来作为省略号。如果 value 是等于 abcdef ，那么输出的结果是 abcd… ，只有四个字母是因为三个点也占了一个字符模版结构include模版有时候一些代码是在许多模版中都用到的。如果每次都重复的去拷贝代码那肯定不符合项目的规范。一般可以把这些重复性的代码抽取出来，就类似于Python中的函数一样，以后想要使用这些代码的时候，就通过 include 包含进来。这个标签就是 include 。# header.html 我是header # footer.html 我是footer # main.html {% include 'header.html' %} 我是main内容 {% include 'footer.html' %}include 标签寻找路径的方式。也是跟 render 渲染模板的函数是一样的。默认 include 标签包含模版，会自动的使用主模版中的上下文，也即可以自动的使用主模版中的变量。模板继承在前端页面开发中。有些代码是需要重复使用的。这种情况可以使用 include 标签来实现，也可以使用另外一个比较强大的方式来实现，那就是模版继承。模版继承类似于 Python 中的类，在父类中可以先定义好一些变量和方法，然后在子类中实现。模版继承也可以在父模版中先定义好一些子模版需要用到的代码，然后子模版直接继承就可以了。并且因为子模版肯定有自己的不同代码，因此可以在父模版中定义一个block接口，然后子模版再去实现。以下是父模版的代码： {% block title %}{% endblock %} - 陌上花 {% block head %}{% endblock %} <hender> 首页 留言 </hender> {% block body %}{% endblock %} Copyright © Blog All Rights Reserved. 2016- 这个模版，取名叫做 base.html ，定义好一个简单的 html 骨架。然后定义好 block 接口，让子模版来根据具体需求来实现。block 接口的定义和模板标签一样，需要有起始标签{% block 自定义名称 %}，就要有结束标签 {% endblock %}hotarticle.html文件的内容 热门文章 文章 文章 文章 文章 {% for article in articles %} {{article}} {% endfor%} 子模板然后通过 extends 标签来实现，示例代码如下：{% extends "cc_base.html" %} {% block title %}首页{% endblock %} {% block head %} {% endblock %} {% block body %} {% include "hotarticle.html"%} {% endblock%}以上代码保存后解析的代码会成这样，框起来的地方就是三个 block 传入的数据具体效果需要注意的是：extends标签必须放在模版的第一行。子模板中的代码必须放在block中，否则将不会被渲染。如果在某个 block 中需要使用父模版的内容，那么可以使用 {{block.super}} 来继承。比如上例，{%block title%} ，如果想要使用父模版的 title ，那么可以在子模版的 title block 中使用 {{ block.super }} 来实现。在定义 block 的时候，除了在 block 开始的地方定义这个 block 的名字，还可以在 block 结束的时候定义名字。比如 {% block title %}{% endblock title %} 。这在大型模版中显得尤其有用，能让你快速的看到 block 包含在哪里。
Django5 入门Django相关的网址Github源代码：https://github.com/django/djangoDjango官网：https://www.djangoproject.com/安装Django通过 pip install django 安装 django ，本文以 Django 5.0.3 版本进行记录。pip install django #如需要指定版本用这个命令 pip install django==5.0.3 初始化 Django 项目创建项目使用命令： django-admin startproject [项目名称] 即可创建。初始化一个新的 Django 项目，例如：django-admin startproject startdjango 创建应用（app）：一个项目类似于是一个架子，但是真正起作用的还是 app 。在终端进入到项目所在的路径，然后执行 python manage.py startapp [app名称] 创建一个app。运行Django项目进入项目，通过命令行的方式： python manage.py runserver这样可以在本地访问项目网站，默认端口号是 8000 ，在浏览器中通过 http://127.0.0.1:8000/ 来访问cd startdjango python manage.py runserver如果想要修改端口号，那么在运行的时候可以指定端口号，python manage.py runserver 9000这样就可以通过9000端口来访问python manage.py runserver 9000项目结构介绍 manage.py：以后和项目交互基本上都是基于这个文件。一般都是在终端输入python manage.py [子命令]。可以输入python manage.py help看下能做什么事情。除非你知道你自己在做什么，一般情况下不应该编辑这个文件。 settings.py：本项目的设置项，以后所有和项目相关的配置都是放在这个里面。 urls.py：这个文件是用来配置URL路由的。比如访问http://127.0.0.1/news/是访问新闻列表页，这些东西就需要在这个文件中完成。 wsgi.py：项目与WSGI工协议兼容的web服务器入口，部署的时候需要用到的，一般情况下也是不需要修改的。 project和app的关系app是django项目的组成部分。一个app代表项目中的一个模块，所有URL请求的响应都是由app来处理。比如豆瓣，里面有图书，电影，音乐，同城等许许多多的模块，如果站在django的角度来看，图书，电影这些模块就是app，图书，电影这些app共同组成豆瓣这个项目。因此这里要有一个概念，django项目由许多 app组成，一个app可以被用到其他项目，django也能拥有不同的app。通过命令：python manage.py startapp bookURL分发器一、视图：视图一般都写在 app 的 views.py 中。并且视图的第一个参数永远都是 request （一个HttpRequest）对象。这个对象存储了请求过来的所有信息，包括携带的参数以及一些头部信息等。在视图中，一般是完成逻辑相关的操作。def book_list(request): return HttpResponse("书籍列表！")视图可以是函数，也可以是类。二、URL映射：视图写完后，要与URL进行映射，即用户在浏览器中输入什么 url 的时候可以请求到这个视图函数。在用户输入了某个 url ，请求到我们的网站的时候， django 会从项目的 urls.py 文件中寻找对应的视图。在 urls.py 文件中有一个 urlpatterns 变量，以后 django 就会从这个变量中读取所有的匹配规则。匹配规则需要使用 django.urls.path 函数进行包裹，这个函数会根据传入的参数返回URLPattern 或者是 URLResolver 的对象。示例代码如下：from django.contrib import admin from django.urls import path from book import views urlpatterns = [ path('admin/', admin.site.urls), path('book/',views.book_list) ]URL中添加参数：有时候， url 中包含了一些参数需要动态调整。比如博客某篇文章的详情页的url，是https://moshanghua.net/details/3276 后面的 3276 就是这篇文章的 id ，那么文章详情页面的url就可以写成 https://moshanghua.net/details/<id> ，其中id就是文章的id。在django 中实现这种需求。可以在 path 函数中，使用尖括号的形式来定义一个参数。比如我现在想要获取一本书籍的详细信息，那么应该在 url 中指定这个参数。示例代码如下：from django.contrib import admin from django.urls import path from book import views urlpatterns = [ path('admin/', admin.site.urls), path('book/',views.book_list), path('book/<book_id>',views.book_detail) ]而 views.py 中的代码如下：def book_detail(request, book_id): return HttpResponse(f"您查询的图书 id 是: {book_id}")在指定参数时，也可以指定参数的类型，比如以上 book_id 为整形，那么在定义 URL 的时候，就可以使用以下语法实现：... path('book/<int:book_id>',views.book_detail) ...除了 int 类型， django 的 path 部分还支持 str 、 slug 、 uuid 、 path 类型。也可以通过查询字符串的方式传递一个参数过去。示例代码如下：urlpatterns = [ path('admin/', admin.site.urls), path('book/',views.book_list), path('book/detail',views.book_detail) ]在 views.py 中的代码如下：def book_detail(request): book_id = request.GET.get("id") name = request.GET.get("name") return HttpResponse(f"您查询的图书 id 是: {book_id}，图书的名称是:《{name}》")在访问的时候就是通过 /book/detail?id=1&name=xx 即可将参数传递过去。path函数详解path 函数的定义为： path(route,view,name=None,kwargs=None) 。route 参数： url 的匹配规则。这个参数中可以指定 url 中需要传递的参数，比如在访问文章详情页的时候，可以传递一个 id 。传递参数是通过 <> 尖括号来进行指定的。并且在传递参数的时候，可以指定这个参数的数据类型，比如文章的 id 都是 int 类型，那么可以这样写 <int:id> ，以后匹配的时候，就只会匹配到 id 为 int 类型的 url，而不会匹配其他的 url ，并且在视图函数中获取这个参数的时候，就已经被转换成一个 1.int 类型了。其中还有几种常用的类型：2.str ：非空的字符串类型。默认的转换器。但是不能包含斜杠。3.int ：匹配任意的零或者正数的整形。到视图函数中就是一个int类型。4.slug ：由英文中的横杠 - 或者下划线 _ 连接英文字符或者数字而成的字符串。5.uuid ：匹配 uuid 字符串。6.path ：匹配非空的英文字符串，可以包含斜杠 /view 参数：可以为一个视图函数或者是 类视图.as_view() 或者是 django.urls.include() 函数的返回值。name 参数：这个参数是给这个 url 取个名字的，在项目比较大， url 比较多的时候用处很大。URL中包含另外一个urls模块（路由模块化）：在项目中，不可能只有一个 app ，如果把所有的 app 的 views 中的视图都放在 urls.py 中进行映射，肯定会让代码显得非常乱。因此 django 给提供了一个方法，可以在 app 内部包含自己的 url 匹配规则，而在项目的 urls.py 中再统一包含这个 app 的 urls 。使用这个技术需要借助 include 函数。示例代码如下：# startdjango/urls.py文件： from django.contrib import admin from django.urls import path,include urlpatterns = [ path('admin/', admin.site.urls), path('book/',include("book.urls")) ]在 urls.py 文件中把所有的和 book 这个 app 相关的 url 都移动到 app/urls.py 中了，然后在startdjango/urls.py 中，通过 include 函数包含 book.urls ，以后在请求 book 相关的url的时候都需要加一个 book 的前缀。# book/urls.py文件： from django.urls import path from . import views urlpatterns = [ path('list/',views.book_list), path('detail/<book_id>/',views.book_detail) ]访问书的列表的 url 的时候，就通过 /book/list/ 来访问，访问书籍详情页面的 url 的时候就通过book/detail/<id> 来访问。为了避免多个模块的 urls.py 中包含同名的 url ，可以指定一个应用命名空间：# book/urls.py文件： from django.urls import path from . import views # 指定应用命名空间 app_name='book' urlpatterns = [ path('list/',views.book_list), path('detail/<book_id>/',views.book_detail) ]url反转（路由反转）一般是通过url来访问视图函数。有时候知道这个视图函数，但是想反转回它的url。这时候就可以通过 reverse 来实现。示例代码如下：print(reverse("list")) > /book/list/如果有应用命名空间或者有实例命名空间，那么应该在反转的时候加上命名空间。示例代码如下：print（reverse('book:list')） > /book/list/如果这个url中需要传递参数，那么可以通过 kwargs 来传递参数。示例代码如下：print(reverse("book:detail",kwargs={"book_id":1})) > /book/detail/1因为 django 中的 reverse 反转 url 的时候不区分 GET 请求和 POST 请求，因此不能在反转的时候添加查询字符串的参数。如果想要添加查询字符串的参数，只能手动的添加。示例代码如下：login_url = reverse('login') + "?next=/" print(login_url)