Web框架之Django_05 模型层了解（单表查询、多表查询、聚合查询、分组查询）
程序员文章站
2022-03-12 08:05:37
摘要： 单表查询 多表查询 聚合查询 分组查询 单表查询 多表查询 聚合查询 分组查询 一、Django ORM 常用字段和参数： AutoField(Field) - int自增列，必须填入参数 primary_key=True BigAutoField(AutoField) - bigint自增 ......
摘要：
-
单表查询
-
多表查询
-
聚合查询
-
分组查询
一、django orm 常用字段和参数：
-
常用字段：
#autofield
int自增列，必须填入参数primary_key = true,当model中如果没有自增列，则会自动创建一个列名为id的列
#integerfield
一个整数类型，范围在--2147483648 to 2147483647。(一般不用它来存手机号(位数也不够)，直接用字符串存)
#charfield
字符类型，必须提供max_length参数，max_length表示字符长度
tips：django的charfield对应的mysql数据库中的varchar类型，没有设置对应char类型的字段，但是django允许我们自定义新的字段，下面我来自定义对应于数据库的char类型
需要注意的是：自定义字段在实际项目应用中可能会经常用到，所以这里需要留意。#应用上面自定义的char类型 class class(models.model): id=models.autofield(primary_key=true) title=models.charfield(max_length=32) class_name=realcharfield(max_length=16) gender_choice=((1,'男'),(2,'女'),(3,'保密')) gender=models.smallintegerfield(choices=gender_choice,default=3)
#datefield
日期字段，日期格式 yyyy-mm-md，例如：2019-6-12，相当于python中的datetime.date()实例。
#datetimefield
日期格式字段，格式 yyyy-mm-dd hh:mm[:ss[.uuuuuu]][tz]，相当于python中的datetime.datetime()实例。
-
字段合集：
autofield(field) - int自增列，必须填入参数 primary_key=true bigautofield(autofield) - bigint自增列，必须填入参数 primary_key=true 注：当model中如果没有自增列，则自动会创建一个列名为id的列 from django.db import models class userinfo(models.model): # 自动创建一个列名为id的且为自增的整数列 username = models.charfield(max_length=32) class group(models.model): # 自定义自增列 nid = models.autofield(primary_key=true) name = models.charfield(max_length=32) smallintegerfield(integerfield): - 小整数 -32768 ～ 32767 positivesmallintegerfield(positiveintegerreldbtypemixin, integerfield) - 正小整数 0 ～ 32767 integerfield(field) - 整数列(有符号的) -2147483648 ～ 2147483647 positiveintegerfield(positiveintegerreldbtypemixin, integerfield) - 正整数 0 ～ 2147483647 bigintegerfield(integerfield): - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807 booleanfield(field) - 布尔值类型 nullbooleanfield(field): - 可以为空的布尔值 charfield(field) - 字符类型 - 必须提供max_length参数， max_length表示字符长度 textfield(field) - 文本类型 emailfield(charfield)： - 字符串类型，django admin以及modelform中提供验证机制 ipaddressfield(field) - 字符串类型，django admin以及modelform中提供验证 ipv4 机制 genericipaddressfield(field) - 字符串类型，django admin以及modelform中提供验证 ipv4和ipv6 - 参数： protocol，用于指定ipv4或ipv6， 'both',"ipv4","ipv6" unpack_ipv4， 如果指定为true，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启此功能，需要protocol="both" urlfield(charfield) - 字符串类型，django admin以及modelform中提供验证 url slugfield(charfield) - 字符串类型，django admin以及modelform中提供验证支持 字母、数字、下划线、连接符（减号） commaseparatedintegerfield(charfield) - 字符串类型，格式必须为逗号分割的数字 uuidfield(field) - 字符串类型，django admin以及modelform中提供对uuid格式的验证 filepathfield(field) - 字符串，django admin以及modelform中提供读取文件夹下文件的功能 - 参数： path, 文件夹路径 match=none, 正则匹配 recursive=false, 递归下面的文件夹 allow_files=true, 允许文件 allow_folders=false, 允许文件夹 filefield(field) - 字符串，路径保存在数据库，文件上传到指定目录 - 参数： upload_to = "" 上传文件的保存路径 storage = none 存储组件，默认django.core.files.storage.filesystemstorage imagefield(filefield) - 字符串，路径保存在数据库，文件上传到指定目录 - 参数： upload_to = "" 上传文件的保存路径 storage = none 存储组件，默认django.core.files.storage.filesystemstorage width_field=none, 上传图片的高度保存的数据库字段名（字符串） height_field=none 上传图片的宽度保存的数据库字段名（字符串） datetimefield(datefield) - 日期+时间格式 yyyy-mm-dd hh:mm[:ss[.uuuuuu]][tz] datefield(datetimecheckmixin, field) - 日期格式 yyyy-mm-dd timefield(datetimecheckmixin, field) - 时间格式 hh:mm[:ss[.uuuuuu]] durationfield(field) - 长整数，时间间隔，数据库中按照bigint存储，orm中获取的值为datetime.timedelta类型 floatfield(field) - 浮点型 decimalfield(field) - 10进制小数 - 参数： max_digits，小数总长度 decimal_places，小数位长度 binaryfield(field) - 二进制类型对应关系： 'autofield': 'integer auto_increment', 'bigautofield': 'bigint auto_increment', 'binaryfield': 'longblob', 'booleanfield': 'bool', 'charfield': 'varchar(%(max_length)s)', 'commaseparatedintegerfield': 'varchar(%(max_length)s)', 'datefield': 'date', 'datetimefield': 'datetime', 'decimalfield': 'numeric(%(max_digits)s, %(decimal_places)s)', 'durationfield': 'bigint', 'filefield': 'varchar(%(max_length)s)', 'filepathfield': 'varchar(%(max_length)s)', 'floatfield': 'double precision', 'integerfield': 'integer', 'bigintegerfield': 'bigint', 'ipaddressfield': 'char(15)', 'genericipaddressfield': 'char(39)', 'nullbooleanfield': 'bool', 'onetoonefield': 'integer', 'positiveintegerfield': 'integer unsigned', 'positivesmallintegerfield': 'smallint unsigned', 'slugfield': 'varchar(%(max_length)s)', 'smallintegerfield': 'smallint', 'textfield': 'longtext', 'timefield': 'time', 'uuidfield': 'char(32)', -
字段参数：
#null ：用于表示某个字段可以为空
#unique ：如果设置为unique = true 则该字段在此表中必须是唯一的
# db_index ：如果db_index = true 则代表着为此字段设置索引
# default ：为该字段设置默认值
-
datefield和datetimefield：
#auto_now_add
配置auto_now_add = true，创建数据记录的时候会把当前时间添加到数据库，后续操作数据不自动更新
#auto_now
配置上auto_now = true，每次更新数据记录的时候会更新该字段
-
关系字段：
#①foreignkey
外键类型在orm中用表示外键关联关系，一般吧foreignkey字段设置在‘一段多’中的多的一方，foreignkey可以和其它表做关联关系同时也可以和自身做关联关系。
#字段参数：
##to 设置要关联的表
##to_field 设置要关联的表的字段
##on_delete 当删除关联表中的数据时，当前表与其关联的行的行为
models.cascade （django2.x版本必须要设置，1.x版本默认就设置了）
删除关联数据，与之关联也删除
##db_constraint 是否在数据库中创建外键约束，默认为true
models.do_nothing 删除关联数据，引发错误integrityerror models.protect 删除关联数据，引发错误protectederror models.set_null 删除关联数据，与之关联的值设置为null（前提fk字段需要设置为可空） models.set_default 删除关联数据，与之关联的值设置为默认值（前提fk字段需要设置默认值） models.set 删除关联数据， a. 与之关联的值设置为指定值，设置：models.set(值) b. 与之关联的值设置为可执行对象的返回值，设置：models.set(可执行对象)
示例：
def func(): return 10 class mymodel(models.model): user = models.foreignkey( to="user", to_field="id"， # 不写默认关联对方关联表的primary_key on_delete=models.set(func) )#②onetoonefield
#字段参数：
一对一字段
通常一对一字段用来扩展已有字段。(通俗的说就是一个人的所有信息不是放在一张表里面的，简单的信息一张表，隐私的信息另一张表，之间通过一对一外键关联)
##to 设置要关联的表
##to_field 设置要关联的表的字段
##on_delete 当删除关联表中的数据时，当前与其关联的行的行为（参考foreignkey）
#③manytomanyfield
多对多字段
#字段参数：
##to 设置要关联的表
##to_field 设置要关联的表的字段
##on_delete 当删除关联表中的数据时，当前与其关联的行的行为（参考foreignkey）
分别以图书管理系统的book、publish、author三张表直接的关系来举例 from django.db import models class book(models.model): title = models.charfield(max_length=32) price = models.decimalfield(max_digits=6, decimal_places=1) publish = models.foreignkey(to='publish') author = models.manytomanyfield(to='author') class publish(models.model): name = models.charfield(max_length=32) email = models.charfield(max_length=32) class author(models.model): name = models.charfield(max_length=32) age = models.integerfield(default=18)
二、单表查询
-
准备
为了更方便的测试表查询的结果，我们需要先配置一下参数，可以是我们直接在django页面中运行我们的测试表查询代码，快速显示结果，所以需要做如下操作：
项目根目录创建一个test.py测试文件>>>>在项目的manage.py文件中复制一段代码>>>>将复制的代码粘贴到test.py文件中，然后再加入几段代码，这样就可以在test文件中进行数据库表数据操作了，当然，连接数据库的过程不能少，表的创建也是。manage.py文件复制的代码： import os if __name__ == "__main__": os.environ.setdefault("django_settings_module", "created_by_pycharm.settings") 添加的代码：（在main下面） import django django.setup() from app01 import models # 注意这句话必须在这里，不能放最上面
这里需要建一张表，用于单表查询：（models文件内）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(auto_now_add=true)项目settings里面将mysql数据库连入： databases = { 'default': { 'engine': 'django.db.backends.mysql', 'name': 'orm_test', 'host': '127.0.0.1', 'port': 3306, 'user': 'root', 'password': '123', } } 同时不要忘了在项目程序文件夹中init文件添加代码： import pymysql pymysql.install_as_mysqldb() 这样才代表数据库已经和django项目对接完毕当然新建完要生效，需要进行数据库迁移（同步）操作 python3 manage.py makemigrations python3 manage.py migrate
-
新增表数据
# 基于create创建 models.user.objects.create(name='sgt', age=18) # 基于对象的绑定方法创建 user_obj = models.user(name='王大锤', age=12) user_obj.save() -
修改表数据
# 基于queryset models.user.objects.filter(name='ttt').update(age=100) # 基于对象 user_obj = models.user.objects.filter(name='sss').first() user_obj.age = 99 user_obj.save() -
删除表数据
总结一下单表操作的一些方法：
# 基于queryset models.user.objects.filter(name='ggg').delete() # 基于对象 user_obj = models.user.objects.filter(name='ttt').first() user_obj.delete()
<1> all(): 查询所有的结果，返回queryset对象们的列表
res = models.user.objects.all() print(res) <queryset [<user: user object>, <user: user object>, <user: user object>, <user: user object>]>
<2> filter(**kwargs): 通过括号中的条件查询到匹配的对象，返回queryset对象们的列表
res = models.user.objects.filter(name='sgt') print(res) <queryset [<user: user object>, <user: user object>, <user: user object>]> 这里提一下：filter筛选条件是可以有多个的，多个条件是与关系，必须全部满足才会得到查询结果
<3> get(**kwargs): 返回与所给筛选条件匹配的object对象，且返回结果只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
res1 = models.user.objects.get(name='sgt') # app01.models.multipleobjectsreturned: get() returned more than one user -- it returned 3! res2 = models.user.objects.get(name='孙悟空') # app01.models.doesnotexist: user matching query does not exist. res3 = models.user.objects.get(name='王大锤') # user object
<4> exclude(**kwargs): 返回筛选条件不匹配的queryset对象们的列表（取反筛选）
res1 = models.user.objects.exclude(name='sgt') <queryset [<user: user object>, <user: user object>, <user: user object>]>
<5> order_by(*field): 对查询结果通过某一字段进行排序（默认升序），返回queryset对象们的列表
res1 = models.user.objects.filter(name='sgt').order_by('age') # 排序默认是升序，如果这里的age前加上一个负号‘-’,怎会进行降序排序。 # res1 = models.user.objects.filter(name='sgt').order_by('-age') print(res1) # <queryset [<user: user object>, <user: user object>, <user: user object>]> # 为了让结果更清晰，遍历下得到排好序的queryset对象们列表，以其age显示顺序 users = [] for user_obj in res1: users.append(user_obj.age) print(users) # [18, 22, 32]<6> reverse(): 对查询的排序结果进行反向排列，记住，不是反向排序，而是反向排列，返回queryset对象们的列表
res1 = models.user.objects.filter(name='sgt').order_by('age').reverse() users = [] for user_obj in res1: users.append(user_obj.age) print(users) # 结果反过来排列了：[32, 22, 18]<7> count(): queryset方法，返回查询到的queryset对象的数量，该方法只能对返回的查询结果为queryset对象使用，如果返回的对象是一个普通的对象，那么结果跟res3一样
res1 = models.user.objects.filter(name='sgt').count() print(res1) # 3 res2 = models.user.objects.filter(name='hahaha').count() print(res2) # 0 res3 = models.user.objects.get(name='王大锤').count() # 抛出错误：attributeerror: 'user' object has no attribute 'count'
<8> first(): 返回查询结果的第一个对象，返回一个普通对象(user object)
res = models.user.objects.filter(name='sgt').first() print(res) # user object
<9> last(): 返回查询结果的最后一个对象，返回一个普通对象(user object)
res = models.user.objects.filter(name='sgt').last() print(res) # user object
<10> exists(): queryset方法， 如果queryset包含数据，就返回true，否则返回false
res = models.user.objects.filter(name='sgt').exists() print(res) # true res = models.user.objects.filter(name='sgg').exists() print(res) # false
<11> values(*field): 返回一个特殊的queryset对象，对象里面是一个列表套字典（model的实例化对象，而是一个可迭代的字典序列）
res = models.user.objects.filter(name='sgt').values('age') print(res) print(res.order_by('age')) print(res.order_by('age').reverse()) print(res.count()) print(res[0]) print(res.first(), res.last()) <queryset [{'age': 18}, {'age': 32}, {'age': 22}]> # values方法返回结果 <queryset [{'age': 18}, {'age': 32}, {'age': 22}]> # 通过age来反向排列，无效，说明该方法只能用在order_by之后，才能进行反向排列 <queryset [{'age': 18}, {'age': 22}, {'age': 32}]> # order_by <queryset [{'age': 32}, {'age': 22}, {'age': 18}]> # order_by后再reverse 3 # 使用count方法 {'age': 18} # 可以用索引取出对应索引的字典 {'age': 18} {'age': 22} # 使用first和last方法<12> values_list(*field): 它与values()非常相似，它返回的是一个元组序列的queryset对象
res = models.user.objects.filter(name='sgt').values_list('age') print(res) print(res.order_by('age')) print(res.order_by('age').reverse()) print(res.count()) print(res[0]) print(res.first(), res.last()) <queryset [(18,), (32,), (22,)]> <queryset [(18,), (22,), (32,)]> <queryset [(32,), (22,), (18,)]> 3 (18,) (18,) (22,) 结果和values方法差不多，只是把字典序列变成了元祖序列<13> distinct(): 从返回结果中剔除重复纪录，注意必须是所有数据都相同才满足去重条件，但是一个表中的每一条数据是不会完全重复的，因为有primary_key的存在，就不会完全相同，所以此方法的主要是在上面的values和values_list方法的基础上用的话会实现一些我们想要的结果。返回特殊的queryset对象
res1 = models.user.objects.filter(name='sgt') res2 = models.user.objects.filter(name='sgt').distinct() print(res1) print(res2) # <queryset [<user: user object>, <user: user object>, <user: user object>, <user: user object>]> # <queryset [<user: user object>, <user: user object>, <user: user object>, <user: user object>]> # 结果数量不变，说明没有去重的项目，主要原因：id没有相同的，肯定无法去重
# 我们用values方法的基础上使用distinct方法： res1 = models.user.objects.filter(name='sgt').values('age') res2 = res1.distinct() print(res1) print(res2) # <queryset [{'age': 18}, {'age': 32}, {'age': 22}, {'age': 22}]> # <queryset [{'age': 18}, {'age': 32}, {'age': 22}]> # 发现这样去重的意义就出来了 - 只要是queryset对象都可以无线的点其中的方法，点下去...
-
基于双下划线的单表查询：
大于(__gt)、小于(__lt)、大于等于(__gte)、小于等于(__lte)
# 将结果再使用values方法，更直接显示 res1 = models.user.objects.filter(age__gt=12).values('name', 'age') print(res1) # <queryset [{'name': '王大锤', 'age': 18}, {'name': '王大炮', 'age': 66}, {'name': '黄飞鸿', 'age': 88}]> res2 = models.user.objects.filter(age__lt=12).values('name', 'age') print(res2) # <queryset [{'name': '米小圈', 'age': 8}, {'name': '铁头', 'age': 9}]> res3 = models.user.objects.filter(age__gte=12).values('name', 'age') print(res3) # <queryset [{'name': '王大锤', 'age': 18}, {'name': '佩奇', 'age': 12}, {'name': '王大炮', 'age': 66}, {'name': '黄飞鸿', 'age': 88}]> res4 = models.user.objects.filter(age__lte=12).values('name', 'age') print(res4) # <queryset [{'name': '米小圈', 'age': 8}, {'name': '铁头', 'age': 9}, {'name': '佩奇', 'age': 12}]>包含（区分大小写__contains|不区分大小写__icontains),以xx开头(__startswith),以xx结尾(__endswith)
res1 = models.user.objects.filter(name__contains='i').values('name', 'age') print(res1) # <queryset [{'name': 'igon', 'age': 55}, {'name': 'igon', 'age': 66}]> res2 = models.user.objects.filter(name__contains='n').values('name', 'age') print(res2) # <queryset [{'name': 'igon', 'age': 66}]> res0 = models.user.objects.filter(name__icontains='j').values('name', 'age') print(res0) # <queryset [{'name': 'json', 'age': 11}, {'name': 'jason', 'age': 16}]> res3 = models.user.objects.filter(name__startswith='j').values('name', 'age') print(res3) # <queryset [{'name': 'json', 'age': 11}]> res4 = models.user.objects.filter(name__endswith='t').values('name', 'age') print(res4) # <queryset [{'name': 'sgt', 'age': 18}]>时间为2018年的记录：(__year=2017)
res = models.user.objects.filter(register_time__year=2018).values('name', 'age', 'register_time') print(res) # <queryset [{'name': 'json', 'age': 11, 'register_time': datetime.date(2018, 6, 21)}]>在指定容器内__in=[a,b,c]，在指定范围内__range=[m,n],首尾都包括在内
res1 = models.user.objects.filter(age__in=[66, 88]).values('name', 'age') print(res1) # <queryset [{'name': '王大炮', 'age': 66}, {'name': '黄飞鸿', 'age': 88}, {'name': 'igon', 'age': 66}]> res2 = models.user.objects.filter(age__range=[9, 12]).values('name', 'age') print(res2) # <queryset [{'name': '铁头', 'age': 9}, {'name': '佩奇', 'age': 12}, {'name': 'json', 'age': 11}]>
三、多表查询
-
表与表之间的关系
#一对一(onetoonefield):一对一字段无论建在哪张关系表里面都可以，但是推荐建在查询频率比较高的那张表里面
#一对多(foreignkey):一对多字段建在多的那一方
#多对多(manytomanyfield):多对多字段无论建在哪张关系表里面都可以，但是推荐建在查询频率比较高的那张表里面
多对多操作：
添加add(),
修改set(),
移除remove() 注意不能接收可迭代对象,
清空clear() 无需传参如何判断表与表之间到底是什么关系 换位思考 a能不能有多个b b能不能有多个a -
多表的增删改查：
======增删改：一对多======from django.db import models # 多表查询示例表 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') # 多对多： author = models.manytomanyfield(to='author') # 这是一个虚拟字段， 信号字段 class publish(models.model): name = models.charfield(max_length=32) addr = models.charfield(max_length=32) email = models.emailfield() # 对应的就是varchar类型 class author(models.model): name = models.charfield(max_length=32) age = models.integerfield() # 一对一关系 authordetail = models.onetoonefield(to='authordetail') class authordetail(models.model): phone = models.charfield(max_length=32) addr = models.charfield(max_length=32)
book与publish 一对多关系
新增：
# 一对多新增： # 由于book表和publish表示多对一的关系，所以我们需要先建立publish相关数据才能进行book记录新增 models.publish.objects.create(name='东方出版社', addr='北京', email='123@163.com') models.publish.objects.create(name='西方出版社', addr='内蒙', email='456@163.com') models.publish.objects.create(name='南方出版社', addr='武汉', email='789@163.com') models.publish.objects.create(name='北方出版社', addr='上海', email='546@163.com')
# 新增book记录（直接添加写id） models.book.objects.create(title='西游记', price=66, publish_id=1) models.book.objects.create(title='红楼梦', price=266, publish_id=2) models.book.objects.create(title='西厢记', price=166, publish_id=3) models.book.objects.create(title='金屏梅', price=366, publish_id=4)
修改：# 一对多新增，传输数据对象 publish_obj = models.publish.objects.filter(pk=1).first() models.book.objects.create(title='三国志', price=48, publish=publish_obj)
删除：（默认情况下）# 一对多修改 # queryset方法修改 ① models.book.objects.filter(pk=1).update(publish_id=2) ② publish_obj = models.publish.objects.filter(pk=4).first() models.book.objects.filter(pk=1).update(publish=publish_obj) # 对象方法修改 ① book_obj = models.book.objects.filter(pk=1).first() book_obj.publish_id = 3 # 点表中真实存在的字段名 book_obj.save() ② book_obj = models.book.objects.filter(pk=1).first() publish_obj = models.publish.objects.filter(pk=1).first() book_obj.publish = publish_obj book_obj.save()
======增删改：多对多======# 多对一删除 ①queryset方法 # 当删除'多'的表数据，则那张'一'的表无影响 models.book.objects.filter(pk=1).delete() # 当删除'一'的表数据，则那张'多'的表对应的记录会删除 models.publish.objects.filter(pk=2).delete() ②对象方法： book_obj = models.book.objects.filter(pk=2).first() book_obj.delete()
book与author表之间是多对多关系
新增
# 多对多关系表的新增 # 过程：先新增数据，后绑定关系 # 先新增author数据和book数据（假设作者信息已经存在对应detail表） models.author.objects.create(name='萧鼎', age=66, authordetail_id=1) models.author.objects.create(name='路遥', age=56, authordetail_id=2) models.author.objects.create(name='三毛', age=77, authordetail_id=3) models.author.objects.create(name='金庸', age=95, authordetail_id=4) book_obj = models.book.objects.create(title='画江湖', price=99, publish_id=1) book_obj.author.add(2, 3) 当然新增也支持传对象的方式 author_obj1 = models.author.objects.filter(pk=1).first() author_obj2 = models.author.objects.filter(pk=2).first() book_obj.author.add(author_obj1, author_obj2)
修改
删除：默认情况下删除一方表记录，连带的会删除其绑定关系，但是另一边记录无影响，仅仅是绑定关系没有了# 修改book和author记录及其关系：set()方法，必须传可迭代对象 book_obj = models.book.objects.filter(pk=3).first() # 修改方法和新增类似，也是修改自身数据后再修改关系 # 可以传数字和对象，并且也支持传多个 # 传id book_obj.author.set((1,)) # 传一个 book_obj.author.set((1,2,3)) # 传多个 # 传对象 author_list = models.author.objects.all() book_obj = models.book.objects.filter(pk=3).first() book_obj.author.set(author_list)
# 多对多删除 # queryset方法 models.book.objects.filter(pk=4).delete() # 删除id为4的书，同时会自动删除此书与作者之间的关系，此时绑定关系会自动删除 # 对象方法 book_obj = models.book.objects.filter(pk=5).first() book_obj.author.remove(2) # 先删除关系不会删除book记录数据 book_obj = models.book.objects.filter(pk=6).first() book_obj.delete() # 删除book对象，会自动触发删除绑定关系 # 假设一本书有多个作者 book_obj = models.book.objects.filter(pk=1).first() author_list = models.author.objects.all() book_obj.author.remove(*author_list) # 注意这里的queryset需要打散才行
======增删改：一对一======
删除：新增：# 一对一，author表创建外键绑定关系到authordetail表，删除创建外键的那张author表的记录，另一方无影响 models.author.objects.filter(pk=1).delete() # 一对一，删除非外键的那张authordetail表记录，则绑定关系以及对应的author表记录都会随之删除 models.authordetail.objects.filter(pk=2).delete()
修改：# 一对一新增：创建外键的表author中新增记录，对应的外键必须未用占且存在，因为是一对一关系，否则报错 models.author.objects.create(name='王锤', age=88, authordetail_id=1) # 一对一新增，authordetail表中新增记录，author表无影响. models.authordetail.objects.create(phone='123', addr='毛里求斯')
# 一对一修改， models.author.objects.filter(pk=8).update(name='汤勺') models.authordetail.objects.filter(pk=4).update(addr='伊拉克') # 一对一修改 关联外键值： # 外键值必须未占用，且存在，不然报错 models.author.objects.filter(pk=8).update(authordetail_id=5)
======清空clear()======
book_obj = models.book.objects.filter(pk=3).first() book_obj.authors.clear() # 清空当前书籍对应的所有作者的绑定关系
-
正向查询：通过一张表a查询另一张表b，如果a与b之间的关系外键是建在a中，那么我们从a中能通过这个外键字段查询到b表中的对应数据的过程就叫做正向查询
反向查询：上面的正向查询，如果从b表去找a表的数据，外键还是建在a表中，这时候b表中就没有与a表关联的字段，此时b查到a就需要用另外的手段来实现，这种就叫反向查询
正向、反向查询方法：
原则：正向查询按字段，反向查询按表名小写# 一对一
author表和authordetail表是一对一关系：（外键在author表中）
## 正向查询：从author查到authordetail： res = models.author.objects.filter(pk=3).first().authordetail.addr print(res) # 冥王星 ## 反向查询：从authordetail 查到author res1 = models.authordetail.objects.filter(pk=3).first().author.name print(res1) # 三毛
# 一对多
# book到publish res = models.book.objects.filter(pk=1).first().publish.name print(res) # 东方出版社 # publish到book res1 = models.publish.objects.filter(pk=2).first().book_set.all() print(res1) # <queryset [<book: book object>, <book: book object>]> res2 = models.publish.objects.filter(pk=2).first().book_set.all().values('title') print(res2) # <queryset [{'title': '红楼梦'}, {'title': '西游记'}]># 多对多
# 正向查询 res1 = models.book.objects.filter(pk=2).first().author.all() print(res1) # <queryset [<author: author object>, <author: author object>]> res2 = models.book.objects.filter(pk=2).first().author.all().values('name') print(res2) # <queryset [{'name': '金庸'}, {'name': '汤勺'}]> # 反向查询 res3 = models.author.objects.filter(pk=3).first().book_set.all() print(res3) # <queryset [<book: book object>, <book: book object>]> res4 = models.author.objects.filter(pk=3).first().book_set.all().values('title') print(res4) # <queryset [{'title': '西厢记'}, {'title': '红楼梦'}]>规律：一对多、多对多 反向查询的时候要加_set.all()
一对一 反向查询不用加 -
基于双下划线的多表查询
-
用例子来说明：
① 查询书籍为红楼梦的出版社名：res = models.book.objects.filter(title='红楼梦').values('publish__name') print(res) # <queryset [{'publish__name': '南方出版社'}]>② 查询书籍为西游记的作者的姓名：
res = models.book.objects.filter(title='西游记').values('author__name') print(res) # <queryset [{'author__name': '三毛'}, {'author__name': '唐唐'}]>③ 查询南方出版社初版的书名：
res = models.publish.objects.filter(name='南方出版社').values('book__title') print(res) # <queryset [{'book__title': '红楼梦'}, {'book__title': '西游记'}]>④ 查询电话号码是911的作者写的书名：
res = models.authordetail.objects.filter(phone='911').values('author__book__title') print(res) # <queryset [{'author__book__title': '三国志'}, {'author__book__title': '西厢记'}]>⑤ 查询作者名字为金庸写的书的书名：
res = models.author.objects.filter(name='金庸').values('book__title') print(res) # <queryset [{'book__title': '三国志'}, {'book__title': '西厢记'}]>⑥ 查询书籍为西游记的作者的电话号码：
res = models.book.objects.filter(title='西游记').values('author__name', 'author__authordetail__phone') print(res) # <queryset [{'author__name': '三毛', 'author__authordetail__phone': '119'}, # {'author__name': '唐唐', 'author__authordetail__phone': '110'}]>⑦ 通过作者细节表 查询作者叫金庸的电话号码
res = models.authordetail.objects.filter(author__name='金庸').values('phone') print(res) # <queryset [{'phone': '911'}]>⑧ 从书这张表 查询出版社为南方出版社的所有图书的名字和价格
res = models.book.objects.filter(publish__name='南方出版社').values('title', 'price') print(res) # <queryset [{'title': '红楼梦', 'price': decimal('67.00')}, {'title': '西游记', 'price': decimal('87.00')}]>⑨ 查询东方出版社初版的书的价格大于45的书
res = models.publish.objects.filter(name='东方出版社', book__price__gt=45).values('book__title', 'book__price') print(res) # <queryset [{'book__title': '三国志', 'book__price': decimal('48.00')}]>
四、聚合查询和分组查询
-
聚合查询
aggregate()，它是queryset的一个终止子句，意思就是，会返回一个包含一些键值对的字典
键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的
用到的内置函数：from django.db.models import avg, sum, max, min, count
示例：
from django.db.models import avg,sum,max,min,count、 查询所有书籍的平均价格，最大价格，书的数量 res = models.book.objects.all().aggregate(avg('price'), max('price'), count('title')) print(res) # {'price__avg': 56.6, 'price__max': decimal('87.00'), 'title__count': 5}可以给聚合值指定一个名称，用于使用该聚合值
如果你想要为聚合值指定一个名称，可以向聚合子句提供它。 >>> models.book.objects.aggregate(average_price=avg('price')) {'average_price': 13.233333} -
分组查询
示例：
统计每一个出版社的出版的书平均价格res = models.publish.objects.annotate(avg_price=avg('book__price')).values('name', 'avg_price') print(res) # <queryset [{'name': '东方出版社', 'avg_price': 46.0}, {'name': '南方出版社', 'avg_price': 77.0}, {'name': '北方出版社', 'avg_price': 37.0}]>
统计出每个出版社买的最便宜的书的价格# <queryset [{'name': '东方出版社', 'avg_price': 46.0}, {'name': '南方出版社', 'avg_price': 77.0}, {'name': '北方出版社', 'avg_price': 37.0}]> res = models.publish.objects.annotate(min_price=min('book__price')).values('name', 'min_price' ) print(res) # <queryset [{'name': '东方出版社', 'min_price': decimal('44.00')}, {'name': '南方出版社', 'min_price': decimal('67.00')}, {'name': '北方出版社', 'min_price': decimal('37.00')}]>统计不止一个作者的图书
res = models.book.objects.annotate(author_num=count('author')).filter(author_num__gt=1).values('title') print(res) # <queryset [{'title': '西厢记'}]>