Django多表操作

一、一对多操作、多对多操作

二、基于对象的跨表查询

三、基于双下划线的查询

 

一、一对多操作

先在app目录下手撸orm

#创建模型分析

实例：我们来假定下面这些概念，字段和关系

作者模型：一个作者有姓名和年龄。

作者详细模型：把作者的详情放到详情表，包含生日，手机号，家庭住址等信息。作者详情模型和作者模型之间是一对一的关系（one-to-one）

出版商模型：出版商有名称，所在城市以及email。

书籍模型： 书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联关系(one-to-many)。

读者们的支持是我原创的动力
支付宝
微信
扫描二维码打赏支付宝打赏不要等待机会，而要创造机会博客园新随笔管理Django模型层之多表操作 本文目录
一 创建模型
二 添加表记录
三 基于对象的跨表查询
四 基于双下划线的跨表查询
五 聚合查询与分组查询
六 F查询与Q查询
七 查询练习
回到目录
一 创建模型
实例：我们来假定下面这些概念，字段和关系
作者模型：一个作者有姓名和年龄。
作者详细模型：把作者的详情放到详情表，包含生日，手机号，家庭住址等信息。作者详情模型和作者模型之间是一对一的关系（one-to-one）
出版商模型：出版商有名称，所在城市以及email。
书籍模型： 书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联关系(one-to-many)。Bookid    title   price  publish    1      php     100   人民出版社  2      python  200   老男孩出版社   3      go      100   人民出版社  4      java    300   人民出版社  为了存储出版社的邮箱，地址，在第一个表后面加字段Bookid    title   price  publish    email    addr    1      php     100   人民出版社   111      北京2      python  200   老男孩出版社 222      上海3      go      100   人民出版社   111      北京4      java    300   人民出版社   111      北京这样会有大量重复的数据，浪费空间####################################################################################
一对多：一个出版社对应多本书（关联信息建在多的一方，也就是book表中）Bookid    title   price     publish_id   1      php     100         12      python  200         13      go      100         2  4      java    300         1Publishid    name       email    addr    1    人民出版社   111      北京       2    沙河出版社   222      沙河总结：一旦确定表关系是一对多：在多对应的表中创建关联字段（在多的表里创建关联字段）  ，publish_id查询python这本书的出版社的邮箱(子查询)select publish_id from Book where title=“python”select email from Publish where id=1####################################################################################
多对多：一本书有多个作者，一个作者出多本书Bookid    title   price     publish_id    1      php     100         1               2      python  200         13      go      100         2  4      java    300         1Authorid  name  age   addr1    alex  34   beijing2    egon  55   nanjingBook2Authorid    book_id  author_id1       2         12       2         23       3         2总结：一旦确定表关系是多对多：创建第三张关系表（创建中间表，中间表就三个字段，自己的id，书籍id和作者id） ：id      book_id   author_id# alex出版过的书籍名称(子查询)

select id from Author where name='alex'select book_id from Book2Author where  author_id=1select title from Book where id =book_id####################################################################################
一对一：对作者详细信息的扩展（作者表和作者详情表）Authorid  name  age     ad_id(UNIQUE) 1    alex  34       1     2    egon  55       2     AuthorDetailid    addr      gender    tel   gf_name   author_id(UNIQUE)1   beijing    male      110   小花           12   nanjing    male      911   杠娘           2总结： 一旦确定是一对一的关系：在两张表中的任意一张表中建立关联字段＋Unique====================================Publish  
Book
Author
AuthorDetail
Book2AuthorCREATE TABLE publish(id INT PRIMARY KEY auto_increment ,name VARCHAR (20));CREATE TABLE book(id INT PRIMARY KEY auto_increment ,title VARCHAR (20),price DECIMAL (8,2),pub_date DATE ,publish_id INT ,FOREIGN KEY (publish_id) REFERENCES publish(id));CREATE TABLE authordetail(id INT PRIMARY KEY auto_increment ,tel VARCHAR (20));CREATE TABLE author(id INT PRIMARY KEY auto_increment ,name VARCHAR (20),age INT,authordetail_id INT UNIQUE ,FOREIGN KEY (authordetail_id) REFERENCES authordetail(id));CREATE  TABLE book2author(id INT PRIMARY KEY auto_increment ,book_id INT ,author_id INT ,FOREIGN KEY (book_id) REFERENCES book(id),FOREIGN KEY (author_id) REFERENCES author(id)
)注意：关联字段与外键约束没有必然的联系（建管理字段是为了进行查询，建约束是为了不出现脏数据）
在Models创建如下模型class Book(models.Model):nid = models.AutoField(primary_key=True)name = models.CharField(max_length=32)price = models.DecimalField(max_digits=5, decimal_places=2)publish_date = models.DateField()# 阅读数# reat_num=models.IntegerField(default=0)# 评论数# commit_num=models.IntegerField(default=0)
publish = models.ForeignKey(to='Publish',to_field='nid',on_delete=models.CASCADE)authors=models.ManyToManyField(to='Author')def __str__(self):return self.nameclass Author(models.Model):nid = models.AutoField(primary_key=True)name = models.CharField(max_length=32)age = models.IntegerField()author_detail = models.OneToOneField(to='AuthorDatail',to_field='nid',unique=True,on_delete=models.CASCADE)class AuthorDatail(models.Model):nid = models.AutoField(primary_key=True)telephone = models.BigIntegerField()birthday = models.DateField()addr = models.CharField(max_length=64)class Publish(models.Model):nid = models.AutoField(primary_key=True)name = models.CharField(max_length=32)city = models.CharField(max_length=32)email = models.EmailField()生成的表如下：注意事项：表的名称myapp_modelName，是根据 模型中的元数据自动生成的，也可以覆写为别的名称　　id 字段是自动添加的对于外键字段，Django 会在字段名上添加"_id" 来创建数据库中的列名这个例子中的CREATE TABLE SQL 语句使用PostgreSQL 语法格式，要注意的是Django 会根据settings 中指定的数据库类型来使用相应的SQL 语句。定义好模型之后，你需要告诉Django _使用_这些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中设置，在其中添加models.py所在应用的名称。
外键字段 ForeignKey 有一个 null=True 的设置(它允许外键接受空值 NULL)，你可以赋给它空值 None 。
回到目录
二 添加表记录
一对多的方式1:publish_obj=Publish.objects.get(nid=1)book_obj=Book.objects.create(title="",publishDate="2012-12-12",price=100,publish=publish_obj)方式2:book_obj=Book.objects.create(title="",publishDate="2012-12-12",price=100,publish_id=1)核心：book_obj.publish与book_obj.publish_id是什么？ 关键点:一 book_obj.publish=Publish.objects.filter(id=book_obj.publish_id).first()二 book_obj.authors.all()关键点:book.authors.all()  # 与这本书关联的作者集合1 book.id=32 book_authorsid  book_id  author_ID3      3             14      3             23  authorid   name1   alex2   egonbook_obj.authors.all()    ------->   [alex,egon]View Code
多对多# 当前生成的书籍对象book_obj=Book.objects.create(title="追风筝的人",price=200,publishDate="2012-11-12",publish_id=1)# 为书籍绑定的做作者对象yuan=Author.objects.filter(name="yuan").first() # 在Author表中主键为2的纪录egon=Author.objects.filter(name="alex").first() # 在Author表中主键为1的纪录# 绑定多对多关系,即向关系表book_authors中添加纪录book_obj.authors.add(yuan,egon)    #  将某些特定的 model 对象添加到被关联对象集合中。   =======    book_obj.authors.add(*[])
View Code
核心:book_obj.authors.all()是什么？
多对多关系其它常用API：
book_obj.authors.remove()      # 将某个特定的对象从被关联对象集合中去除。    ======   book_obj.authors.remove(*[])
book_obj.authors.clear()       #清空被关联对象集合
book_obj.authors.set()         #先清空再设置　
回到目录
三 基于对象的跨表查询
一对多查询（publish与book）
正向查询（按字段：publish）
# 查询主键为1的书籍的出版社所在的城市
book_obj=Book.objects.filter(pk=1).first()
# book_obj.publish 是主键为1的书籍对象关联的出版社对象
print(book_obj.publish.city)
反向查询（按表名：book_set）
publish=Publish.objects.get(name="苹果出版社")
#publish.book_set.all() : 与苹果出版社关联的所有书籍对象集合
book_list=publish.book_set.all()    
for book_obj in book_list:print(book_obj.title)View Code
一对一查询（Author 与 AuthorDetail）
正向查询(按字段：authorDetail)：
egon=Author.objects.filter(name="egon").first()
print(egon.authorDetail.telephone)
反向查询(按表名：author)：
# 查询所有住址在北京的作者的姓名
 
authorDetail_list=AuthorDetail.objects.filter(addr="beijing")
for obj in authorDetail_list:print(obj.author.name)View Code
多对多查询 (Author 与 Book)
正向查询(按字段：authors)：
# 眉所有作者的名字以及手机号
 
book_obj=Book.objects.filter(title="眉").first()
authors=book_obj.authors.all()
for author_obj in authors:print(author_obj.name,author_obj.authorDetail.telephone)
反向查询(按表名：book_set)：
# 查询egon出过的所有书籍的名字
 author_obj=Author.objects.get(name="egon")book_list=author_obj.book_set.all()        #与egon作者相关的所有书籍for book_obj in book_list:print(book_obj.title)View Code注意：
你可以通过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如，如果 Article model 中做一下更改：
publish = ForeignKey(Book, related_name='bookList')那么接下来就会如我们看到这般:
# 查询 人民出版社出版过的所有书籍
 
publish=Publish.objects.get(name="人民出版社")
book_list=publish.bookList.all()  # 与人民出版社关联的所有书籍对象集合
 
回到目录
四 基于双下划线的跨表查询
Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系，它能自动确认 SQL JOIN 联系。要做跨关系查询，就使用两个下划线来链接模型(model)间关联字段的名称，直到最终链接到你想要的model 为止。
'''正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表
'''
一对多查询# 练习:  查询苹果出版社出版过的所有书籍的名字与价格(一对多)# 正向查询 按字段:publish
queryResult=Book.objects.filter(publish__name="苹果出版社").values_list("title","price")# 反向查询 按表名:book
queryResult=Publish.objects.filter(name="苹果出版社").values_list("book__title","book__price")
查询的本质一样，就是select from的表不一样View Code
多对多查询　# 练习: 查询alex出过的所有书籍的名字(多对多)# 正向查询 按字段:authors:queryResult=Book.objects.filter(authors__name="yuan").values_list("title")# 反向查询 按表名:bookqueryResult=Author.objects.filter(name="yuan").values_list("book__title","book__price")View Code一对一查询# 查询alex的手机号# 正向查询ret=Author.objects.filter(name="alex").values("authordetail__telephone")# 反向查询ret=AuthorDetail.objects.filter(author__name="alex").values("telephone")View Code
进阶练习(连续跨表)# 练习: 查询人民出版社出版过的所有书籍的名字以及作者的姓名# 正向查询queryResult=Book.objects.filter(publish__name="人民出版社").values_list("title","authors__name")# 反向查询queryResult=Publish.objects.filter(name="人民出版社").values_list("book__title","book__authors__age","book__authors__name")# 练习: 手机号以151开头的作者出版过的所有书籍名称以及出版社名称# 方式1:queryResult=Book.objects.filter(authors__authorDetail__telephone__regex="151").values_list("title","publish__name")# 方式2:    ret=Author.objects.filter(authordetail__telephone__startswith="151").values("book__title","book__publish__name")View Code
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替换表名，例如：
回到目录
五 聚合查询与分组查询
聚合
aggregate(*args, **kwargs)
# 计算所有图书的平均价格from django.db.models import AvgBook.objects.all().aggregate(Avg('price'))
#{'price__avg': 34.35}
 
aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定一个名称，可以向聚合子句提供它。
Book.objects.aggregate(average_price=Avg('price'))
#{'average_price': 34.35}
 
如果你希望生成不止一个聚合，你可以向aggregate()子句中添加另一个参数。所以，如果你也想知道所有图书价格的最大值和最小值，可以这样查询：
from django.db.models import Avg, Max, Min
Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))
#{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}
 View Code
分组
annotate()为调用的QuerySet中每一个对象都生成一个独立的统计值（统计方法用聚合函数）。
总结 ：跨表分组查询本质就是将关联表join成一张表，再按单表的思路进行分组查询。　
查询练习
练习：统计每一本书作者个数from django.db.models import Avg, Max, Sum, Min, Max, Count
book_list = models.Book.objects.all().annotate(author_num=Count("authors"))
for book in book_list:print(book.name)print(book.author_num)
book_list = models.Book.objects.all().annotate(author_num=Count("authors")).values('name','author_num')
print(book_list)练习：统计每一个出版社的最便宜的书
publishList=Publish.objects.annotate(MinPrice=Min("book__price"))
for publish_obj in publishList:print(publish_obj.name,publish_obj.MinPrice)
annotate的返回值是querySet，如果不想遍历对象，可以用上valuelist：
queryResult= Publish.objects.annotate(MinPrice=Min("book__price")).values_list("name","MinPrice")
print(queryResult)练习：统计每一本以py开头的书籍的作者个数：queryResult=Book.objects.filter(title__startswith="Py").annotate(num_authors=Count('authors'))练习：统计不止一个作者的图书：（作者数量大于一）
ret=models.Book.objects.annotate(author_num=Count("authors")).filter(author_num__gt=1).values('name','author_num')
print(ret)练习：根据一本图书作者数量的多少对查询集 QuerySet进行排序:
Book.objects.annotate(num_authors=Count('authors')).order_by('num_authors')练习：查询各个作者出的书的总价格:
ret=models.Author.objects.annotate(sum_price=Sum("book__price")).values("name", "sum_price")
print(ret)练习：查询每个出版社的名称和书籍个数
ret=models.Publish.objects.all().annotate(c=Count('book__name')).values('name','c')
print(ret)View Code
回到目录
六 F查询与Q查询
F查询
在上面所有的例子中，我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较，那该怎么做呢？
Django 提供 F() 来做这样的比较。F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。
# 查询评论数大于收藏数的书籍from django.db.models import FBook.objects.filter(commnetNum__lt=F('keepNum'))
Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。
# 查询评论数大于收藏数2倍的书籍
Book.objects.filter(commnetNum__lt=F('keepNum')*2)
修改操作也可以使用F函数,比如将每一本书的价格提高30元：
Book.objects.all().update(price=F("price")+30)　
Q查询
filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR 语句），你可以使用Q 对象。
from django.db.models import Q
Q(title__startswith='Py')
Q 对象可以使用& 和| 操作符组合起来。当一个操作符在两个Q 对象上使用时，它产生一个新的Q 对象。
bookList=Book.objects.filter(Q(authors__name="yuan")|Q(authors__name="egon"))
等同于下面的SQL WHERE 子句：
WHERE name ="yuan" OR name ="egon"
你可以组合& 和|  操作符以及使用括号进行分组来编写任意复杂的Q 对象。同时，Q 对象可以使用~ 操作符取反，这允许组合正常的查询和取反(NOT) 查询：查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起。但是，如果出现Q 对象，它必须位于所有关键字参数的前面。例如：
bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017), title__icontains="python")View Code
回到目录
七 查询练习
查找所有书名里包含红楼的书
查找出版日期是2017年的书
查找出版日期是2017年的书名
查找价格大于10元的书
查找价格大于10元的书名和价格查找在北京的出版社
查找名字以沙河开头的出版社查找作者名字里面带“小”字的作者
查找年龄大于30岁的作者
查找手机号是155开头的作者
查找手机号是155开头的作者的姓名和年龄查找书名是“红楼梦”的书的出版社
查找书名是“红楼梦”的书的出版社所在的城市
查找书名是“红楼梦”的书的出版社的名称查找书名是“红楼梦”的书的所有作者
查找书名是“红楼梦”的书的作者的年龄
查找书名是“红楼梦”的书的作者的手机号码查找书名是“红楼梦”的书的作者的地址
查找书名是“红楼梦”的书的作者的邮箱练习：好文要顶 已关注 收藏该文   刘清政
关注 - 1
粉丝 - 155 我在关注他 取消关注 
1 
0 « 上一篇：异常处理
» 下一篇：Django从入门到放弃
posted @ 2018-08-18 23:25 刘清政 阅读(891) 评论(0)  编辑 收藏刷新评论刷新页面返回顶部
发表评论
昵称： 
评论内容：退出 订阅评论 [Ctrl+Enter快捷键提交] 【推荐】超50万VC++源码: 大型组态工控、电力仿真CAD与GIS源码库！
【推荐】专业便捷的企业级代码托管服务 - Gitee 码云相关博文：
· django 模型
· Django学习——模型
· django学习笔记<六>：模型
· 20121025 The django book 笔记 模型
· django常用操作最新新闻：
· 大疆等在美被诉专利侵权 起诉方疑似NPE机构
· 特朗普的《AI 倡议》存在一个致命问题：海外AI人才的政策依然欠缺
· 人类能找到长寿密钥？消灭自由基、服用二甲双胍、激活端粒酶
· 巴菲特四季度持仓报告：减持苹果1.1% 清仓甲骨文
· 外媒称阿里巴巴正在谈判入股麦德龙的中国业务 双方不予置评
» 更多新闻...Git：github.com/liuqingzheng
邮箱：616564099@qq.com
微信（QQ）：616564099
昵称：刘清政
园龄：11个月
粉丝：155
关注：1
已关注 -取消随笔分类
Go 
Python 
前端 
数据库(1) 
微服务(1) 
随笔档案
2019年1月 (2) 
2018年12月 (5) 
2018年11月 (7) 
2018年10月 (4) 
2018年8月 (7) 
2018年5月 (3) 
文章分类
Golang(3) 
Others 
Python-Web框架(3) 
Python--基础(5) 
Python--爬虫(3) 
RabbitMQ 
SVN--Git(3) 
前端(4) 
数据结构和算法 
数据库(3) 
微服务 
最新评论
1. Re:刘老师手撸系列
期待之后的撸点,哈哈
--Maple_feng
2. Re:刘老师手撸系列
裤子都脱了，你给我看这个？
--hua_zhong
3. Re:刘老师手撸系列
然后，就没有然后了？
--yyxxff
4. Re:5-Python与设计模式--代理模式
厉害了呀，十年架构lqz
--yyxxff
5. Re:详解HTTP协议
沙发
--iii123
阅读排行榜
1. Python从入门到放弃系列（Django/Flask/爬虫）(3427)
2. Python内部类，内部类调用外部类属性，方法(1337)
3. 浅谈CSRF（Cross-site request forgery）跨站请求伪造（写的非常好）(1064)
4. Python创建virtualenv（虚拟环境）方法(719)
5. 仿优酷作业(711)
评论排行榜
1. 刘老师手撸系列(3)
2. 详解HTTP协议(1)Copyright ©2019 刘清政 

注意：关联字段与外键约束没有必然的联系（建管理字段是为了进行查询，建约束是为了不出现脏数据）

#案例models.py

from django.db import models# Create your models here.
class Book(models.Model):nid = models.AutoField(primary_key=True)name = models.CharField(max_length=32,null=True)price = models.DecimalField(max_digits=5, decimal_places=2)publish_date = models.DateField()# 新增或者删除字段（写一个属性/注释掉）# default 指定默认值# null 这个字段你可以为空# xxaa=models.CharField(max_length=32,null=True)# 一对多的关系一旦确立，关联关系写在多的一方publish = models.ForeignKey(to='Publish',to_field='nid',on_delete=models.CASCADE)# 多对多的关系需要创建第三张表（自动创建第三张表）authors=models.ManyToManyField(to='Author')def __str__(self):return self.nameclass Author(models.Model):nid = models.AutoField(primary_key=True)name = models.CharField(max_length=32)age = models.IntegerField()# unique=True 唯一性约束author_detail = models.OneToOneField(to='AuthorDatail',to_field='nid',on_delete=models.CASCADE)# author_detail = models.ForeignKey(to='AuthorDatail',to_field='nid',unique=True,on_delete=models.CASCADE)class AuthorDatail(models.Model):nid = models.AutoField(primary_key=True)# BigIntegerField 大整形# telephone = models.BigIntegerField()# birthday = models.DateField()addr = models.CharField(max_length=64,unique=True)class Publish(models.Model):nid = models.AutoField(primary_key=True)name = models.CharField(max_length=32)city = models.CharField(max_length=32)# EmailField ：邮箱格式，EmailField用在admin中email = models.EmailField()

 

#再在工程路径下创建test.py文件

一对一增加：

import osif __name__ == '__main__':os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day82.settings")import djangodjango.setup()from app01 import models# 一对多增加
    # publish:可以传一个publish对象publish=models.Publish.objects.get(pk=1)print(publish.name)# ret=models.Book.objects.create(name='西游记',price=88,publish_date='2018-09-12',publish=publish)# publish_id 传一个idret=models.Book.objects.create(name='三国演义',price=32,publish_date='2018-07-12',publish_id=publish.pk)print(type(ret.publish))# 就是当前图书出版社的对象print(ret.publish)print(type(ret.publish_id))print(ret.publish.pk)print(ret.publish_id)

 生成的表如下：

注意事项：

　　1.表的名称myapp_modelName,是根据模型中元数据自动生成的，也可以覆写为别的名称

　　2.id字段时自动添加的

　　3.对于外键字段，Django会在字段上添加“_id”来创建数据库的列名

　　4.这个例子中create table SQL语句使用PsetgreSQL语法格式，要注意的是Django会根据setting中指定的数据库类型来使用相应的sql语句

　　5.定义好模型后，你需要高数django_使用_这学模型，你要做的就是修改配置文件中的INSTALL_APPSZ中设置，在其中添加models.py所在应用的名称

　　6.外检字段ForegnKey有一个null=True的设置（它允许外键接受空值null），你可以赋给它空值None

 

一对一修改：

    #一对多修改#book=models.Book.objects.get(pk=3)#book.publish_id=2#book.publish=出版社对象#book.save()#ret=models.Book.objects.filter(pk=2).update(publish=publish对象)#ret=models.Book.objects.filter(pk=2).update(publish_id=2)

 

一对一增加：

# 一对一增加
# authordetail=models.AuthorDatail.objects.create(addr='南京')
# author=models.Author.objects.create(name='恩公',age=17,author_detail=authordetail)
# author=models.Author.objects.create(name='小猴',age=16,author_detail_id=authordetail.pk)

 

多对多新增：

# 给红楼梦这本书添加两个作者（lqz,egon）book = models.Book.objects.get(pk=1)
# 相当于拿到了第三张表
# 往第三章表中添加纪录（问题来了？要传对象还是传id）,都支持
# book.authors.add(1,2)lqz = models.Author.objects.get(pk=1)egon = models.Author.objects.get(pk=2)# book.authors.add(lqz,egon)

  book = Book.objects.filter(name='红楼梦').first()egon=Author.objects.filter(name='egon').first()lqz=Author.objects.filter(name='lqz').first()# 1 没有返回值，直接传对象
    book.authors.add(lqz,egon)# 2 直接传作者idbook.authors.add(1,3)# 3 直接传列表,会打散book.authors.add(*[1,2])# 解除多对多关系book = Book.objects.filter(name='红楼梦').first()# 1 传作者idbook.authors.remove(1)# 2 传作者对象egon = Author.objects.filter(name='egon').first()book.authors.remove(egon)#3 传*列表book.authors.remove(*[1,2])#4 删除所有
    book.authors.clear()# 5 拿到与 这本书关联的所有作者，结果是queryset对象，作者列表ret=book.authors.all()# print(ret)# 6 queryset对象，又可以继续点（查询红楼梦这本书所有作者的名字）ret=book.authors.all().values('name')print(ret)# 以上总结：# （1）# book=Book.objects.filter(name='红楼梦').first()# print(book)# 在点publish的时候，其实就是拿着publish_id又去app01_publish这个表里查数据了# print(book.publish)# （2）book.authors.all()

多对多关系其它常用API：

book_obj.authors.remove()      # 将某个特定的对象从被关联对象集合中去除。    ======   book_obj.authors.remove(*[])
book_obj.authors.clear()       #清空被关联对象集合
book_obj.authors.set()         #先清空再设置　

 

 

二、基于对象的跨表查询

删除、修改及清空操作：

 # 红楼梦这本书egon这个作者删掉# book.authors.remove(2)# book.authors.remove(egon,lqz)# book.authors.remove(1,2)# book.authors.remove(*[1,2])# book.authors.remove(*[lqz,egon])# 修改红楼梦这本书的作者为lqz和egon# 清空（清空这本的所有作者记录）# book.authors.clear()# book.authors.add(1,2)# book.authors.set(*[6,])   #这样不行# book.authors.set([6,])   #需要这样传# lqz=models.Author.objects.get(pk=2)# set 必须传一个可迭代对象# book.authors.set([lqz,])   #需要这样传

 

1.一对多查询（publish与book）

    # 一对多# 查询红楼梦这本书的出版社名字（正向,按字段）# book=models.Book.objects.get(pk=1)# 出版社对象 book.publish# print(book.publish.name)# 查询北京出版社出版的所有书名(反向查询按 表名小写_set.all())# publish=models.Publish.objects.get(pk=1)# 结果是queryset对象# books=publish.book_set.all()# for book in books:#     print(book.name)# 查询以红开头的# books=publish.book_set.all().filter(name__startswith='红')# for book in books:#     print(book.name)

 

正向查询（按字段：publish）

# 查询主键为1的书籍的出版社所在的城市
book_obj=Book.objects.filter(pk=1).first()
# book_obj.publish 是主键为1的书籍对象关联的出版社对象
print(book_obj.publish.city)

反向查询（按表名:book_set）

publish=Publish.objects.get(name="苹果出版社")
#publish.book_set.all() : 与苹果出版社关联的所有书籍对象集合
book_list=publish.book_set.all()    
for book_obj in book_list:print(book_obj.title)

 

2.一对一查询

    # 一对一查询# 补充一个概念：正向  反向# 正向：关联关系在当前表中，从当前表去另一个表# 反向：关联关系不在当前表，从当前表去另一个表# 查询lqz作者的地址(正向查询，按字段)# lqz=models.Author.objects.filter(name='lqz').first()# # 作者详情对象# print(lqz.author_detail.addr)# 查询地址为上海的，作者的名字（反向查询，按表名小写）# authordetail=models.AuthorDatail.objects.filter(addr='上海').first()# 拿到的是作者对象authordetail.author# print(authordetail.author.name)

 

3.多对多查询

    # 红楼梦这本书所有的作者(正向 字段)# book=models.Book.objects.get(pk=1)# # book.authors.all()拿到所有的作者，是一个queryset对象# authors=book.authors.all()# for author in authors:#     print(author.name)# 查询egon写的所有书(反向 表名小写_set.all())# egon=models.Author.objects.get(pk=2)# 拿到的是queryset对象# books=egon.book_set.all()# for book in books:# print(book.name)

 

三、基于双下划线的查询

 

一对一

　　 # 查询lqz作者的名字，地址(正向查询，按字段)# ret=models.Author.objects.filter(name='lqz').values('name','author_detail__addr')# print(ret)# 查询地址为上海的作者的名字(反向，按表名小写)# ret=models.AuthorDatail.objects.filter(addr='上海').values('addr','author__name','author__age')# print(ret.query)# print(ret)

 

一对多

 #查询红楼梦这本书的出版社的名字(正向  按字段)# ret=models.Book.objects.filter(name='红楼梦').values('name','publish__name')# print(ret)# 查询北京出版社出版的所有书的名字(反向  按表名小写)# ret=models.Publish.objects.filter(name='北京出版社').values('book__name')# print(ret)

  

多对多

　　 # 红楼梦这本书所有的作者名字(正向  按字段)# ret=models.Author.objects.filter(book__name='红楼梦').values('name')# print(ret)# ret=models.Book.objects.filter(name='红楼梦').values('authors__name')# print(ret)# egon出版的所有书的名字(反向 表名小写)# ret=models.Book.objects.filter(authors__name='egon').values('name')# print(ret)# ret=models.Author.objects.filter(name='egon').values('book__name')# print(ret)# 查询北京出版社出版过的所有书籍的名字以及作者的姓名# ret=models.Publish.objects.filter(name='北京出版社').values('book__name','book__authors__name')# print(ret)# ret=models.Book.objects.filter(publish__name='北京出版社').values('name','authors__name')# print(ret)# ret=models.Author.objects.filter(book__publish__name='北京出版社').values('book__name','name')# print(ret)# 地址是以北开头的作者出版过的所有书籍名称以及出版社名称# ret = models.AuthorDatail.objects.filter(addr__startswith='北').values('author__book__name',#                                                                       'author__book__publish__name')# print(ret)
ret=models.Book.objects.filter(authors__author_detail__addr__startswith='北').values('name','publish__name')print(ret.query)ret=models.Author.objects.filter(author_detail__addr__startswith='北').values('book__name','book__publish__name')print(ret.query)