Django之模型层
模型层(ORM语法):跟数据库打交道的
补充知识
# django自带的sqlite3数据库对日期格式不是很敏感 处理的时候容易出错
测试脚本创建
""" 当你只是想测试django中的某一个py文件内容 那么你可以不用书写前后端交互的形式 而是直接写一个测试脚本即可 脚本代码无论是写在应用下的tests.py还是自己单独开设py文件都可以 """ # 测试环境的准备 去manage.py中拷贝前四行代码 然后自己再写两行 import os import sys if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() # 在这个代码块的下面就可以测试django里面的单个py文件了
实例：
test.py
import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() # 所有的代码都必须等待环境准备完毕之后才能书写 from app01 import models # 注意这行导入不能放在main上面导入，一定要在django.setup()下方写，因为要等上面测试环境完成 models.User.objects.all()
单表操作
环境准备：
数据库
单表操作数据增删改查示例
models.py
from django.db import models # Create your models here. class User(models.Model): name = models.CharField(max_length=32) age = models.IntegerField() register_time = models.DateField() # 日期字段，表示年月日，models.DateTimeField()表示年月日，时分秒 """ 针对DateField()和DateTimeField()两个重要参数： auto_now=True:每次操作数据的时候，该字段会自动将当前时间更新 auto_now_add=True:在创建数据的时候，会自动将当前创建时间记录下来，之后只要不人为的修改，那么就一直不变 """ def __str__(self): return self.name
test.py
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # 单表操作 # 增 # 方法一： # res = models.User.objects.create(name="jason",age=18,register_time="2020-5-29") # print(res) # 返回值是创建对象本身 # 方法二： # import datetime # ctime = datetime.datetime.now() # user_obj = models.User(name="egon",age=99,register_time=ctime) # 日期格式还支持直接传日期对象 # user_obj.save() # 删 # 方法一： # res = models.User.objects.filter(pk=2).delete() # print(res) # 返回值是当前命令所影响的行数 # 补充，以前是用id来取，这里pk会自动查找到当前表的主键字段，指代的就是当前表的主键，用了pk之后，就不需要知道当前表的主键字段到底叫什么 # # 方法二： # user_obj = models.User.objects.filter(pk=1).first() # user_obj.delete()
# 补充
对象.delete() # 删一条
qureyset对象.delete() # 删除多条 eg: models.User.object.all().delete()
# 修改 # 方法一： # models.User.objects.filter(pk=1).update(age=22) # # 方法二： user_obj = models.User.objects.filter(pk=2).first() user_obj.age = 66 user_obj.save() # """ ps: user_obj = models.User.objects.get(pk=4) get方法返回的直接就是当前数据对象 但是该方法不推荐使用 一旦数据不存在该方法会直接报错 而filter则不会 所以我们还是用filter """
单表操作必知必会13条：
test.py
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # 必知必会13条 # 1.all() 查询所有数据 # 2.filter() 带有过滤条件的查询
# 3.get() 直接拿数据对象 但是条件不存在直接报错
# 4.first() 拿queryset里面第一个元素 # res = models.User.objects.all().first() # print(res)
# 5.last() # res = models.User.objects.all().last() # print(res) # 6.values() 可以指定获取的数据字段 类似数据库select name,age from User;语句 列表套字典 # res = models.User.objects.values('name','age') # <QuerySet [{'name': 'jason', 'age': 18}, {'name': 'egonPPP', 'age': 84}]> # print(res)
# 7.values_list() 列表套元祖 res = models.User.objects.values_list('name','age') # <QuerySet [('jason', 18), ('egonPPP', 84)]> print(res) """ res = models.User.objects.values_list('name','age') # <QuerySet [('jason', 18), ('egonPPP', 84)]> print(res.query) # SELECT `app01_user`.`name`, `app01_user`.`age` FROM `app01_user` # 查看内部封装的sql语句 上述查看sql语句的方式 只能用于queryset对象 只有queryset对象才能够点击query查看内部的sql语句 """
# 8.distinct() 去重 # res = models.User.objects.values('name','age').distinct() # print(res) """ 去重一定要是一模一样的数据 如果带有主键那么肯定不一样 你在往后的查询中一定不要忽略主键 """
# 9.order_by() # res = models.User.objects.order_by('age') # 默认升序 # res = models.User.objects.order_by('-age') # 降序 # print(res)
# 10.reverse() 反转的前提是 数据已经排过序了 order_by() # res = models.User.objects.all() # res1 = models.User.objects.order_by('age').reverse() # print(res,res1) # 11.count() 统计当前数据的个数 # res = models.User.objects.count() # print(res)
#12.exclude() 排除在外 # res = models.User.objects.exclude(name='jason') # print(res) # 13.exists() 基本用不到因为数据本身就自带布尔值 返回的是布尔值 # res = models.User.objects.filter(pk=10).exists() # print(res)
补充：查看内部sql语句的方法
# 方式1 res = models.User.objects.values_list('name','age') # <QuerySet [('jason', 18), ('egonPPP', 84)]> print(res.query) queryset对象才能够点击query查看内部的sql语句 # 方式2:所有的sql语句都能查看 # 去配置文件中配置一下即可 LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'handlers': { 'console':{ 'level':'DEBUG', 'class':'logging.StreamHandler', }, }, 'loggers': { 'django.db.backends': { 'handlers': ['console'], 'propagate': True, 'level':'DEBUG', }, } }
神奇的双下划线查询
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # 神奇的双下划线查询 # 练习题 # 年龄大于35岁的数据 # res = models.User.objects.filter(age__gt=35) # print(res) # 年龄小于35岁的数据 # res = models.User.objects.filter(age__lt=35) # print(res) # 大于等于 小于等于 # res = models.User.objects.filter(age__gte=32) # print(res) # res = models.User.objects.filter(age__lte=32) # print(res) # 年龄是18 或者 32 或者40 # res = models.User.objects.filter(age__in=[18,32,40]) # print(res) # 年龄在18到40岁之间的 首尾都要 # res = models.User.objects.filter(age__range=[18,40]) # print(res) # 查询出名字里面含有s的数据 模糊查询 ps:默认区分大小写 # res = models.User.objects.filter(name__contains='s') # print(res) # # 查询出名字里面含有p的数据 默认区分大小写 # res = models.User.objects.filter(name__contains='p') # print(res) # 忽略大小写 # res = models.User.objects.filter(name__icontains='p') # print(res) # 以什么开头|以什么结尾
# res = models.User.objects.filter(name__startswith='j') # res1 = models.User.objects.filter(name__endswith='j') # # print(res,res1) # 查询出注册时间是1月的（按月份找） # res = models.User.objects.filter(register_time__month='1') # 查询出注册时间是2020年的(按年份找) # res = models.User.objects.filter(register_time__year='2020') # 查询出注册时间是29号的(按日找) res = models.User.objects.filter(register_time__day="29") print(res)
多表操作
以图书管理系统为例：
环境：
models.py
from django.db import models # Create your models here. class Book(models.Model): title = models.CharField(max_length=32) price = models.DecimalField(max_digits=8,decimal_places=2) publish_date = models.DateField(auto_now_add=True) # 一对多 publish = models.ForeignKey(to="Publish") # 多对多 authors = models.ManyToManyField(to="Author") class Publish(models.Model): name = models.CharField(max_length=32) addr = models.CharField(max_length=64) email = models.EmailField() # varchar(254) 该字段不是给models看的，而是给后面我们会学到的校验型组件看的 class Author(models.Model): name = models.CharField(max_length=32) age = models.IntegerField() # 一对一 author_detail = models.OneToOneField(to="AuthorDetail") class AuthorDetail(models.Model): phone = models.BigIntegerField() # 电话号码用BigIntegerField或者直接用CharField addr = models.CharField(max_length=64)
给三给表先写点数据
一对多的外键增删改查
test.py
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # 一对多的外键增删改查 以Book表为例 # 增 # 方法一：直接写实际字段 id，,Book表中publish_date字段可以不给，创建时会自动写入创建时间 # models.Book.objects.create(title='论语',price=899.23,publish_id=1) # models.Book.objects.create(title='聊斋',price=444.23,publish_id=2) # models.Book.objects.create(title='老子',price=333.66,publish_id=1) # 方法二：虚拟字段 对象 # publish_obj = models.Publish.objects.filter(pk=3).first() # models.Book.objects.create(title='红楼梦',price=666.23,publish=publish_obj) # 删 # models.Publish.objects.filter(pk=1).delete() # 级联删除 # 修改 # 方法一：
# models.Book.objects.filter(pk=1).update(publish_id=2)
# 方法二：
# publish_obj = models.Publish.objects.filter(pk=1).first() # models.Book.objects.filter(pk=1).update(publish=publish_obj)
多对多的外键增删改查（就是在操作两者之间的第三者关系表）
test.py
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # 多对多的外键增删改查 以Book表为例 # 增 # 方法一：add中放主键id数字 # 如何在第三张表book_authors中建立书籍和作者的绑定关系 # 先整一个书籍对象 # book_obj = models.Book.objects.filter(pk=3).first() # print(book_obj.authors) # 就类似于你已经到了第三张关系表了，authors是Book类里的多对多虚拟字段 # book_obj.authors.add(1) # 书籍id为3的书籍绑定一个主键为1 的作者 # book_obj.authors.add(2, 3) # 还可以绑定多个作者 # 方法二：add中放对象 # book_obj = models.Book.objects.filter(pk=1).first() # author_obj = models.Author.objects.filter(pk=1).first() # author_obj1 = models.Author.objects.filter(pk=2).first() # author_obj2 = models.Author.objects.filter(pk=3).first() # book_obj.authors.add(author_obj) # book_obj.authors.add(author_obj1,author_obj2) # 还可以放作者对象 """ add给第三张关系表添加数据 括号内既可以传数字也可以传对象 并且都支持多个 """ # 删除 # 方法一： # book_obj = models.Book.objects.filter(pk=1).first() # book_obj.authors.remove(2) # # 书籍id为1的书籍解除绑定一个主键为2 的作者 # book_obj.authors.remove(1,3) # # 方法二： # book_obj = models.Book.objects.filter(pk=1).first() # author_obj = models.Author.objects.filter(pk=1).first() # author_obj1 = models.Author.objects.filter(pk=2).first() # author_obj2 = models.Author.objects.filter(pk=3).first() # book_obj.authors.remove(author_obj,author_obj2) """ remove 括号内既可以传数字也可以传对象 并且都支持多个 """ # 修改 # 方法一： # book_obj = models.Book.objects.filter(pk=1).first() # book_obj.authors.set([1,2]) # 括号内必须给一个可迭代对象 # book_obj.authors.set([3]) # 括号内必须给一个可迭代对象 # 方法二： # book_obj = models.Book.objects.filter(pk=1).first() # author_obj = models.Author.objects.filter(pk=2).first() # author_obj1 = models.Author.objects.filter(pk=3).first() # book_obj.authors.set([author_obj,author_obj1]) # 括号内必须给一个可迭代对象 """ set 括号内必须传一个可迭代对象，该对象内既可以数字也可以对象 并且都支持多个 """ # 清空 # 在第三张关系表中清空某个书籍与作者的绑定关系 book_obj = models.Book.objects.filter(pk=1).first() book_obj.authors.clear() """ clear 括号内不要加任何参数 """
修改单独说明：
1、
修改前
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # 修改 book_obj = models.Book.objects.filter(pk=1).first() book_obj.authors.set([1,2]) # 会将id为1的book，对应的作者从1，3改为1，2，会先将id为1的book对应的作者id为3的删掉，再重新建
2、
修改前
test.py
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # 修改 book_obj = models.Book.objects.filter(pk=1).first() book_obj.authors.set([3]) # 将id为1的book对应author_id为1，2的先删掉，然后再建一个id为1的book对应author_id为3
修改后
FOREIGNKEY中的DB_CONSTRAINT参数有什么用
db_constraint 唯一约束 db_constraint = True 方便查询 约束字段 db_constraint = fales 不约束字段 同时也可以查询
正反向概念
# 正向 # 反向 外键字段在我手上那么，我查你就是正向 外键字段如果不在手上，我查你就是反向 book >>>外键字段在书那儿(正向)>>> publish publish >>>外键字段在书那儿(反向)>>>book 一对一和多对多正反向的判断也是如此 正向查询按外键字段
eg: author_obj = models.Author.objects.filter(name='jason').first() res = author_obj.author_detail
.all() 查询数据可能有多个的时候
反向查询按表名小写 _set.all() 查询数据可能有多个的时候 eg: # publish_obj = models.Publish.objects.filter(name='东方出版社').first() # 出版社查书 反向 # res = publish_obj.book_set # app01.Book.None # res = publish_obj.book_set.all() """ 基于对象 反向查询的时候 当你的查询结果可以有多个的时候 就必须加_set.all() 当你的结果只有一个的时候 不需要加_set.all() """
多表查询
子查询（基于对象的跨表查询）
练习题：
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # 正向 # 子查询(基于对象的跨表查询) # 1.查询书籍主键为1的出版社 # book_obj = models.Book.objects.filter(pk=1).first() # # 书查出版社 正向 # res = book_obj.publish # 通过一对一多的外键publish，book_obj.publish得到书籍主键为1的出版社对象 # # print(res) # print(res.name) # print(res.addr) # 2.查询书籍主键为2的作者 # book_obj = models.Book.objects.filter(pk=2).first() # # 书查作者 正向 # # res = book_obj.authors # app01.Author.None # res = book_obj.authors.all() # <QuerySet [<Author: Author object>, <Author: Author object>]> # print(res) """ 在书写orm语句的时候跟写sql语句一样的 不要企图一次性将orm语句写完 如果比较复杂 就写一点看一点 正向什么时候需要加.all() 当你的结果可能有多个的时候就需要加.all() 如果是一个则直接拿到数据对象 book_obj.publish book_obj.authors.all() author_obj.author_detail """ # 3.查询作者jason的电话号码 # author_obj = models.Author.objects.filter(name='jason').first() # res = author_obj.author_detail # print(res) # print(res.phone) # print(res.addr) # 反向查 # 4.查询出版社是东方出版社出版的书 # publish_obj = models.Publish.objects.filter(name='东方出版社').first() # 出版社查书 反向 # res = publish_obj.book_set # app01.Book.None # res = publish_obj.book_set.all() # print(res) # 5.查询作者是jason写过的书 # author_obj = models.Author.objects.filter(name='jason').first() # 作者查书 反向 # res = author_obj.book_set # app01.Book.None # res = author_obj.book_set.all() # print(res) # 6.查询手机号是110的作者姓名 # author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first() # res = author_detail_obj.author # jason <class 'app01.models.Author'> # print(res.name) """ 基于对象 反向查询的时候 当你的查询结果可以有多个的时候 就必须加_set.all() 当你的结果只有一个的时候 不需要加_set.all() """
联表查询（基于双下划线的跨表查询）
# 基于双下划线的跨表查询 # 1.查询jason的手机号和作者姓名
# 正向 按外键字段小写__跨表后要取字段名 # res = models.Author.objects.filter(name='jason').values('author_detail__phone','name') # values()支持正反向概念
# # author_detail__phone：正向利用author_detail字段跨到作者详情表，之后拿phone # print(res) # 反向 按表名小写__跨表后要取字段名 # res = models.AuthorDetail.objects.filter(author__name='jason') # filter同样支持正反向的概念，拿作者姓名是jason的作者详情 # res = models.AuthorDetail.objects.filter(author__name='jason').values('phone','author__name') # print(res)
# # 总结：
# # 利用正反向的概念，正向使用使用外键字段，反向使用表名小写
# 2.查询书籍主键为1的出版社名称和书的名称 # res = models.Book.objects.filter(pk=1).values('title','publish__name') # print(res) # 反向 # res = models.Publish.objects.filter(book__id=1).values('name','book__title') # print(res) # 3.查询书籍主键为1的作者姓名 # res = models.Book.objects.filter(pk=1).values('authors__name') # print(res) # 反向 # res = models.Author.objects.filter(book__id=1).values('name') # print(res) # 查询书籍主键是1的作者的手机号 # book author authordetail # res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone') # authors__author_detail__phone：book通过外键字段authors进入作者表，再通过作者表中author_detail外键字段进入作者详情表 # print(res) """ 你只要掌握了正反向的概念 以及双下划线 那么你就可以无限制的跨表 """
补充：filter(外键字段=外键对象)
models.py
blog与article表是一对一关系
from django.db import models from django.contrib.auth.models import AbstractUser # Create your models here. class UserInfo(AbstractUser): phone = models.BigIntegerField(null=True, blank=True, verbose_name="手机号") # 头像 avatar = models.FileField(upload_to="avatar/", default='avatar/default.png') """ 给avatar字段传文件对象 该文件会自动存储到avatar文件夹 然后avatar字段只保存文件路径avatar/default.png """ create_time = models.DateTimeField(auto_now_add=True) blog = models.OneToOneField(to='Blog', null=True) class Meta: verbose_name_plural = "用户表" # 修改admin后台管理默认的表名 def __str__(self): return self.username class Blog(models.Model): site_name = models.CharField(max_length=32, verbose_name='站点名称') site_title = models.CharField(max_length=32, verbose_name='站点标题') # 简单模拟 认识样式内部原理的操作 site_theme = models.CharField(max_length=64, verbose_name='站点样式') # 存css/js的文件路径 class Meta: verbose_name_plural = "个人站点" def __str__(self): return self.site_name class Category(models.Model): name = models.CharField(max_length=32, verbose_name='文章分类') blog = models.ForeignKey(to='Blog', null=True) class Meta: verbose_name_plural = "文章分类" def __str__(self): return self.name class Tag(models.Model): name = models.CharField(max_length=32, verbose_name='文章标签') blog = models.ForeignKey(to='Blog', null=True) tags = models.ManyToManyField(to='Article', through='Article2Tag', through_fields=('tag', 'article') ) class Meta: verbose_name_plural = "文章标签" def __str__(self): return self.name class Article(models.Model): title = models.CharField(max_length=64, verbose_name='文章标题') desc = models.CharField(max_length=255, verbose_name='文章简介') # 文章内容有很多 一般情况下都是使用TextField content = models.TextField(verbose_name='文章内容') create_time = models.DateTimeField(auto_now_add=True) # 数据库字段设计优化 up_num = models.BigIntegerField(default=0, verbose_name='点赞数') down_num = models.BigIntegerField(default=0, verbose_name='点踩数') comment_num = models.BigIntegerField(default=0, verbose_name='评论数') # 外键字段 blog = models.ForeignKey(to='Blog', null=True) category = models.ForeignKey(to='Category', null=True) tags = models.ManyToManyField(to='Tag', through='Article2Tag', through_fields=('article', 'tag') ) class Meta: verbose_name_plural = "文章" def __str__(self): return self.title class Article2Tag(models.Model): article = models.ForeignKey(to='Article') tag = models.ForeignKey(to='Tag') class UpAndDown(models.Model): user = models.ForeignKey(to='UserInfo') article = models.ForeignKey(to='Article') is_up = models.BooleanField() # 传布尔值存0/1 class Comment(models.Model): user = models.ForeignKey(to='UserInfo') article = models.ForeignKey(to='Article') content = models.CharField(max_length=255, verbose_name="评论内容") create_time = models.DateTimeField(auto_now_add=True, verbose_name='评论时间') # 自关联 parent = models.ForeignKey(to='self', null=True) # 一定要加null=True,因为有些评论就是根评论
views.py
def site(request, username): # 先校验当前用户名对应的个人站点是否存在 user_obj = models.UserInfo.objects.filter(username=username).first() print(user_obj) if not user_obj: return render(request, "error.html") # 返回个人站点页面 blog = user_obj.blog # 查询当前个人站点的所有文章 article_list = models.Article.objects.filter(blog=blog) return render(request, 'site.html', locals())
related_name
publish = ForeignKey(Blog, related_name='bookList')
# 练习: 查询人民出版社出版过的所有书籍的名字与价格(一对多) # 反向查询 不再按表名:book,而是related_name:bookList queryResult=Publish.objects .filter(name="人民出版社") .values_list("bookList__title","bookList__price")
反向查询时，如果定义了related_name ，则用related_name替换表名
聚合查询（聚合函数的使用）
# 聚合查询，orm要使用聚合函数要先导入模块，通常情况下聚合查询都是配合分组一起使用的
# 如果不想分组但是还想使用聚合函数那么就需要使用aggregate()方法 示例：models.模型类名.objects.aggregate()
""" 只要是跟数据库相关的 基本都在django.db.models里面 如果上述没有那么应该在django.db里面 """ from django.db.models import Max,Min,Sum,Avg,Count
简单示例：
test.py
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # 聚合查询，orm要使用聚合函数要先导入模块，一般都是结合分组使用，如果想在不使用分组的情况下使用聚合函数,要使用aggregate() """ 只要是跟数据库相关的 基本都在django.db.models里面 如果上述没有那么应该在django.db里面 """ from django.db.models import Max,Min,Sum,Avg,Count # 1、统计所有书的平均价格 # res = models.Book.objects.aggregate(Avg("price")) # print(res) # 2、上述方法一次性使用 res = models.Book.objects.aggregate(Max('price'), Min('price'), Sum('price'), Count('pk'), Avg('price')) print(res)
分组查询
""" MySQL分组查询都有哪些特点 分组之后默认只能获取到分组的依据 组内其他字段都无法直接获取了 严格模式 ONLY_FULL_GROUP_BY """
简单示例：
test.py
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # 分组查询，分组查询关键字annotate() 类似MySQL中group by from django.db.models import Max,Min,Sum,Avg,Count # 1、统计每一本书的作者个数 # res = models.Book.objects.annotate() # models后面点什么 就是按什么分组 # res = models.Book.objects.annotate(author_num=Count("authors__pk")).values("title","author_num") # res1 = models.Book.objects.annotate(author_num=Count("authors")).values("title", "author_num") # # author_num=Count("authors__id") author_num是我们自己定义的别名 用来存储聚合函数统计出来的每本书对应的作者个数 # # Count("authors__id") 括号里面（书查作者正向）可以使用外键字段名__字段，也可以直接写外键字段（因为orm帮我们简化了） # # res = models.Book.objects.annotate(author_num=Count("authors")).values("title","author_num") # print(res,res1) # 2、统计每个出版社卖的最便宜的书的价格(作业:复习原生SQL语句 写出来) # res = models.Publish.objects.annotate(min_price=Min("book__price")).values("name","min_price") # print(res) # 3、统计不止一个作者的图书 # res = models.Book.objects.annotate(author=Count("authors")).filter(author__gt=1).values("title","author") # print(res) """ 补充： 只要你的orm语句得出的结果还是一个queryset对象 那么它就可以继续无限制的点queryset对象封装的方法 """ # 4、查询每个作者出的书的总价格 # res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name','sum_price') # print(res) """ 如果我想按照指定的字段分组该如何处理呢？ 如果annotate前面出现values那么就会按照values括号里分组 models.Book.objects.values('price').annotate() 后续BBS作业会使用 你们的机器上如果出现分组查询报错的情况 你需要修改数据库严格模式 """
F与Q查询
F查询
示例：
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # F查询 """ 能够帮助你直接获取到表中某个字段对应的数据 """ from django.db.models import F # F查询需要导入F # 1、查询卖出数大于库存数的书籍 # res = models.Book.objects.filter(maichu__gt=F('kucun')) # print(res) # 2.将所有书籍的价格提升500块 models.Book.objects.update(price=F('price') + 500) # 3.将所有书的名称后面加上爆款两个字 """ 在操作字符类型的数据的时候 F不能够直接做到字符串的拼接 """ from django.db.models.functions import Concat from django.db.models import Value models.Book.objects.update(title=Concat(F('title'), Value('爆款'))) # models.Book.objects.update(title=F('title') + '爆款') # 所有的名称会全部变成空白
Q查询
"""filter括号内多个参数默认是and关系""" # 如果想改成or或这非not关系需要用到Q查询
示例：
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # Q查询 from django.db.models import Q # Q查询需要导入Q # 1、查询卖出数大于100或者价格小于600的书籍 """filter括号内多个参数是and关系""" from django.db.models import Q res = models.Book.objects.filter(Q(maichu__gt=100),Q(price__lt=600)) # Q包裹逗号分割 还是and关系 # res = models.Book.objects.filter(Q(maichu__gt=100)|Q(price__lt=600)) # | or关系 # res = models.Book.objects.filter(~Q(maichu__gt=100)|Q(price__lt=600)) # ~ not关系 maichu之前是大于100，现在条件就是not取反，小于等于100 print(res)
Q查询高阶
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # Q查询 from django.db.models import Q # Q查询需要导入Q # Q的高阶用法 能够将查询条件的左边也变成字符串的形式 q = Q() q.children.append(('maichu__gt', 100)) q.children.append(('price__lt', 600)) res = models.Book.objects.filter(q) # filter括号内也支持直接放q对象，默认还是and关系 print(res) """" 改成or关系 q = Q() q.connector = 'or' # 指定为or q.children.append(('maichu__gt', 100)) q.children.append(('price__lt', 600)) res = models.Book.objects.filter(q) print(res) """
Django中如何开启事务
""" 事务 ACID 原子性 不可分割的最小单位 一致性 跟原子性是相辅相成 隔离性 事务之间互相不干扰 持久性 事务一旦确认永久生效 事务的回滚 rollback 事务的确认 commit """
示例：
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # 目前你只需要掌握Django中如何简单的开启事务 # 事务 需要导入transaction from django.db import transaction try: with transaction.atomic(): # sql1 # sql2 ... # 在with代码快内书写的所有orm操作都是属于同一个事务 except Exception as e: print(e) print('执行其他操作')
其他回滚操作实例参考：
https://www.cnblogs.com/oklizz/p/11240212.html
数据库设计范式
当一个关系中的所有分类都是不可再分的数据项时，该关系是规范化的。不可再分的数据项，即不存在组合数据项和多项数据项。一个低一级的关系模式，通过模式分解可以转换为若干高一级范式的关系模式的集合，这个过程就叫规范化。二维数据表可以分为5级范式为1NF、2NF、3NF、4NF、5NF。第一范式满足最低的要求条件，第五范式满足最高要求的条件。
第一范式条件：必须不包含重复组的关系，即每一列都是不可拆分的原子项。
如以下表存在可再分项（高级职称），所以不满足第一范式
非规范化转换为规范化的第一范式方法很简单，将表分别从横向、纵向展开即可。将高级职称横向展开即可以得到满足第一范式的表结构。
第二范式条件：关系模式必须满足第一范式，并且所有非主属性都完全依赖于主码。注意，符合第二范式的关系模型可能还存在数据冗余、更新异常等问题。
举例如关系模型（职工号，姓名，职称，项目号，项目名称）中，职工号->姓名，职工号->职称，而项目号->项目名称。显然依赖关系不满足第二范式，常用的解决办法是差分表格，比如拆分为职工信息表和项目信息表。
第三范式的条件：关系模型满足第二范式，所有非主属性对任何候选关键字都不存在传递依赖。即每个属性都跟主键有直接关系而不是间接关系，像：a-->b-->c。一般数据库设计中，一般要求达到3NF，第四第五较少涉及。
比如Student表（学号，姓名，年龄，性别，所在院校，院校地址，院校电话）这样一个表结构，就存在上述关系。 学号--> 所在院校 --> (院校地址，院校电话)。我们应该拆开来，如下：
（学号，姓名，年龄，性别，所在院校）--（所在院校，院校地址，院校电话）
ORM中常用字段以及参数
AutoField 主键字段 primary_key=True CharField varchar verbose_name 字段的注释 max_length 长度 IntegerField int BigIntegerField bigint DecimalField max_digits=8 decimal_places=2 EmailFiled varchar(254) DateField date DateTimeField datetime auto_now:每次修改数据的时候都会自动更新当前时间 auto_now_add:只在创建数据的时候记录创建时间后续不会自动修改了 BooleanField(Field) - 布尔值类型 该字段传布尔值(False/True) 数据库里面存0/1 TextField(Field) - 文本类型 该字段可以用来存大段内容(文章、博客...) 没有字数限制 后面的bbs作业 文章字段用的就是TextField FileField(Field) - 字符类型 upload_to = "/data" 给该字段传一个文件对象，会自动将文件保存到/data目录下然后将文件路径保存到数据库中 /data/a.txt 后面bbs作业也会涉及 # 更多字段 直接参考博客:https://www.cnblogs.com/Dominic-Ji/p/9203990.html
自定义字段
# django除了给你提供了很多字段类型之外 还支持你自定义字段
自定义类型示例：
models.py
# 自定义字段需要让类继承feild class MyCharField(models.Field): def __init__(self, max_length, *args, **kwargs): self.max_length = max_length # 调用父类的init方法 super().__init__(max_length=max_length, *args, **kwargs) # 一定要是关键字的形式传入 def db_type(self, connection): """ 返回真正的数据类型及各种约束条件 """ return 'char(%s)' % self.max_length # 自定义字段使用 class Book(models.Model): title = models.CharField(max_length=32) price = models.DecimalField(max_digits=8,decimal_places=2) publish_date = models.DateField(auto_now_add=True) # 自定义字段 myfield = MyCharField(max_length=16)
外键字段及参数
unique=True ForeignKey(unique=True) ===> OneToOneField() # 你在用前面字段ForeignKey创建一对一 orm会有一个提示信息 orm推荐你使用后者但是前者也能用 db_index 如果db_index=True 则代表着为此字段设置索引 (复习索引是什么) to_field 设置要关联的表的字段 默认不写关联的就是另外一张的主键字段 on_delete 当删除关联表中的数据时，当前表与其关联的行的行为。 """ django2.X及以上版本 需要你自己指定外键字段的级联更新级联删除 """
数据库查询优化
only与defer
select_related与prefetch_related
orm语句的特点
# orm语句的特点: 惰性查询 如果你仅仅只是书写了orm语句 在后面根本没有用到该语句所查询出来的参数 那么orm会自动识别 直接不执行
only和defer
test.py
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # orm语句特点：惰性查询 # res = models.Book.objects.all() # print(res) # 要用数据了才会走数据库 # only与defer # 1、想要获取书籍表中所有书的名字 # 原先方法，拿到QuerySet对象(列表套字典) # res = models.Book.objects.values('title') # print(res) # for d in res: # print(d.get('title')) # 2、实现获取到的是一个数据对象 然后点title就能够拿到书名 并且没有其他字段 # 使用only res = models.Book.objects.only('title') # print(res) # <QuerySet [<Book: 三国演义爆款>, <Book: 红楼梦爆款>, <Book: 论语爆款>, <Book: 聊斋爆款>, <Book: 老子爆款>]> for i in res: print(i.title) # 点击only括号内的字段 不会走数据库 # print(i.price) # 点击only括号内没有的字段 会重新走数据库查询（因为其对象本身只有title属性）而all方法的对象本身就有了所有属性所以不需要走数据库了 # 3、对象除了没有title属性之外其他的都有 res = models.Book.objects.defer('title') # 对象除了没有title属性之外其他的都有 # print(res) for i in res: print(i.price) # 点击only括号内没有的字段 不会走数据库查询 # print(i.title) # 点击only括号内的字段 会重新走数据库查询 """ defer与only刚好相反 defer括号内放的字段不在查询出来的对象里面 查询该字段需要重新走数据 而如果查询的是非括号内的字段 则不需要走数据库了 """
select_related与prefetch_related
select_related ==》 inner join
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # select_related与prefetch_related 跟跨表操作有关 # 查询每本书的出版社名称 # 原先方法 # res = models.Book.objects.all() # for i in res: # print(i.publish.name) # 每循环一次就要走一次数据库查询 # 优化查询select_related res = models.Book.objects.select_related("publish") # INNER JOIN for i in res: print(i.publish.name) """ select_related内部直接先将book与publish连起来 然后一次性将大表里面的所有数据 全部封装给查询出来的对象 这个时候对象无论是点击book表的数据还是publish的数据都无需再走数据库查询了 ps：select_related括号内只能放外键字段 一对多 一对一 多对多也不行
ps2:select_related括号内可以放多个外键字段,可以连好多张表eg:
select_related(外键字段1__外键字段2__外键字段3__...) """
prefetch_related 子查询
示例：
from django.test import TestCase # Create your tests here. import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() from app01 import models # prefetch_related res = models.Book.objects.prefetch_related("publish") # 子查询 """ prefetch_related该方法内部其实就是子查询 将子查询查询出来的所有结果也给你封装到对象中 给你的感觉好像也是一次性搞定的 """ for i in res: print(i.publish.name)
浙公网安备 33010602011771号