本篇文章给人人带来的内容是关于django模子层之多表操纵的细致引见（代码示例），有肯定的参考价值，有须要的朋侪能够参考一下，愿望对你有所协助。
一 竖立模子
表和表之间的关联
一对一、多对一、多对多 ，用book表和publish表本身来想一想关联，想一想内里的操纵，加外键束缚和不加外键束缚的区分，一对一的外键束缚是在一对多的束缚上加上唯一束缚。
实例：我们来假定下面这些观点，字段和关联
作者模子：一个作者有姓名和岁数。
作者细致模子：把作者的概况放到概况表，包括生日，手机号，家庭住址等信息。作者概况模子和作者模子之间是一对一的关联（one-to-one）
出书商模子：出书商有称号，地点都市以及email。
书本模子： 书本有书名和出书日期，一本书能够会有多个作者，一个作者也能够写多本书，所以作者和书本的关联就是多对多的关联关联(many-to-many);一本书只应该由一个出书商出书，所以出书商和书本是一对多关联关联(one-to-many)。
模子竖立以下：
from django.db import models
# Create your models here.
class Author(models.Model): #比较经常运用的信息放到这个表内里
nid = models.AutoField(primary_key=True)
name=models.CharField( max_length=32)
age=models.IntegerField()
# 与AuthorDetail竖立一对一的关联，一对一的这个关联字段写在两个表的恣意一个表内里都能够
authorDetail=models.OneToOneField(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE) #就是foreignkey+unique，只不过不须要我们本身来写参数了，<br>而且orm会自动帮你给这个字段名字拼上一个_id，数据库中字段称号为authorDetail_id
class AuthorDetail(models.Model):#不经常运用的放到这个表内里
nid = models.AutoField(primary_key=True)
birthday=models.DateField()
telephone=models.BigIntegerField()
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()
#多对多的表关联，我们学mysql的时刻是怎样竖立的，是否是手动竖立一个第三张表，然后写上两个字段，每一个字段外键关联到别的两张多对多关联的表，orm的manytomany自动帮我们竖立第三张表，<br>两种体式格局竖立关联都能够，今后的进修我们临时用orm自动竖立的第三张表，由于手动竖立的第三张表我们举行orm操纵的时刻，许多关于多对多关联的表之间的orm语句要领没法运用
#假如你想删除某张表，你只须要将这个表注销掉，然后实行那两个数据库同步指令就能够了，自动就删除了。
class Book(models.Model):
nid = models.AutoField(primary_key=True)
title = models.CharField( max_length=32)
publishDate=models.DateField()
price=models.DecimalField(max_digits=5,decimal_places=2)
# 与Publish竖立一对多的关联,外键字段竖立在多的一方，字段publish假如是外键字段，那末它自动是int范例
publish=models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE) #foreignkey内里能够加许多的参数，都是须要我们进修的，慢慢来，to指向表，<br>to_field指向你关联的字段，不写这个，默许会自动关联主键字段，on_delete级联删除
字段称号不须要写成publish_id，orm在翻译foreignkey的时刻会自动给你这个字段拼上一个_id,这个字段称号在数据库内里就自动变成了publish_id
# 与Author表竖立多对多的关联,ManyToManyField能够建在两个模子中的恣意一个，自动竖立第三张表，而且注重一点，你检察book表的时刻，你看不到这个字段，由于这个字段就是竖立第三<br>张表的意义，不是竖立字段的意义，所以只能说这个book类内里有authors这个字段属性
authors=models.ManyToManyField(to='Author',) #注重不管是一对多照样多对多，写to这个参数的时刻，末了背面的值是个字符串，不然你就须要将你要关联的谁人表放到这个表的上面
关于多对多表的三种竖立体式格局(现在你先作为相识)
体式格局一：自行竖立第三张表
class Book(models.Model):
title = models.CharField(max_length=32, verbose_name="书名")
class Author(models.Model):
name = models.CharField(max_length=32, verbose_name="作者姓名")
# 本身竖立第三张表，离别经由过程外键关联书和作者
class Author2Book(models.Model):
author = models.ForeignKey(to="Author")
book = models.ForeignKey(to="Book")
class Meta:
unique_together = ("author", "book")
体式格局二：经由过程ManyToManyField自动竖立第三张表
class Book(models.Model):
title = models.CharField(max_length=32, verbose_name="书名")
# 经由过程ORM自带的ManyToManyField自动竖立第三张表
class Author(models.Model):
name = models.CharField(max_length=32, verbose_name="作者姓名")
books = models.ManyToManyField(to="Book", related_name="authors")
体式格局三：设置ManyTomanyField并指定自行竖立的第三张表
class Book(models.Model):
title = models.CharField(max_length=32, verbose_name="书名")
# 本身竖立第三张表，并经由过程ManyToManyField指定关联
class Author(models.Model):
name = models.CharField(max_length=32, verbose_name="作者姓名")
books = models.ManyToManyField(to="Book", through="Author2Book", through_fields=("author", "book"))
# through_fields接收一个2元组（'field1'，'field2'）：
# 个中field1是定义ManyToManyField的模子外键的名（author），field2是关联目的模子（book）的外键名。
class Author2Book(models.Model):
author = models.ForeignKey(to="Author")
book = models.ForeignKey(to="Book")
class Meta:
unique_together = ("author", "book")
注重：
当我们须要在第三张关联表中存储分外的字段时，就要运用第三种体式格局。
然则当我们运用第三种体式格局竖立多对多关联关联时，就没法运用orm供应的set、add、remove、clear要领来治理多对多的关联了，须要经由过程第三张表的model来治理多对多关联。
#竖立一对一关联字段时的一些参数
to
设置要关联的表。
to_field
设置要关联的字段。
on_delete
同ForeignKey字段。
竖立一对多关联字段时的一些参数
to
设置要关联的表
to_field
设置要关联的表的字段
related_name
反向操纵时，运用的字段名，用于替代原反向查询时的'表名_set'。
related_query_name
反向查询操纵时，运用的衔接前缀，用于替代表名。
on_delete
当删除关联表中的数据时，当前表与其关联的行的行动。
竖立多对多字段时的一些参数
to
设置要关联的表
related_name
同ForeignKey字段。
related_query_name
同ForeignKey字段。
through
在运用ManyToManyField字段时，Django将自动生成一张表来治理多对多的关联关联。
但我们也能够手动竖立第三张表来治理多对多关联，此时就须要经由过程through来指定第三张表的表名。
through_fields 设置关联的字段。 db_table 默许竖立第三张表时，数据库中表的称号。
竖立表时的一些元信息设置
元信息
ORM对应的类内里包括另一个Meta类，而Meta类封装了一些数据库的信息。重要字段以下:
class Author2Book(models.Model):
author = models.ForeignKey(to="Author")
book = models.ForeignKey(to="Book")
class Meta:
unique_together = ("author", "book")
db_table
ORM在数据库中的表名默许是 app_类名，能够经由过程db_table能够重写表名。
index_together
团结索引。
unique_together
团结唯一索引。
ordering
指定默许按什么字段排序。
只要设置了该属性，我们查询到的结果才能够被reverse()。
竖立完这个表，我们本身能够经由过程navicat东西来看看数据库内里的那些表，出书社这个表内里没有任何的关联字段，这类单表的数据，我们能够先增加几条数据，在举行下面的增编削查的操纵。
生成表以下：
注重事项：
- 表的称号
myapp_modelName，是依据 模子中的元数据自动生成的，也能够覆写为别的称号 id字段是自动增加的- 关于外键字段，Django 会在字段名上增加"_id" 来竖立数据库中的列名
- 这个例子中的
CREATE TABLESQL 语句运用PostgreSQL 语法花样，要注重的是Django 会依据settings 中指定的数据库范例来运用响应的SQL 语句。 - 定义好模子以后，你须要通知Django _运用_这些模子。你要做的就是修正配置文件中的INSTALL_APPSZ中设置，在个中增加
models.py地点运用的称号。 - 外键字段 ForeignKey 有一个 null=True 的设置(它许可外键接收空值 NULL)，你能够赋给它空值 None 。
我们的表内里包括了一对一、一对多、多对多的关联，我们基于这几个表来演习，未来不管有若干张表，都逃脱不了这三个关联，操纵起来都是一样的。
关于on_delete
on_delete 当删除关联表中的数据时，当前表与其关联的行的行动。 models.CASCADE 删除关联数据，与之关联也删除 models.DO_NOTHING 删除关联数据，激发毛病IntegrityError models.PROTECT 删除关联数据，激发毛病ProtectedError models.SET_NULL 删除关联数据，与之关联的值设置为null（条件FK字段须要设置为可空） models.SET_DEFAULT 删除关联数据，与之关联的值设置为默许值（条件FK字段须要设置默许值） models.SET 删除关联数据， a. 与之关联的值设置为指定值，设置：models.SET(值) b. 与之关联的值设置为可实行对象的返回值，设置：models.SET(可实行对象)
二 增加表记载
操纵前先简朴的录入一些数据：照样create和save两个要领，和单表的区分就是看看怎样增加关联字段的数据
publish表：
author表：
authordetail表:
一对多
体式格局1: publish_obj=Publish.objects.get(nid=1) #拿到nid为1的出书社对象 book_obj=Book.objects.create(title="金瓶煤",publishDate="2012-12-12",price=100,publish=publish_obj) #出书社对象作为值给publish，实在就是自动将publish字段<br>变成publish_id,然后将publish_obj的id给取出来赋值给publish_id字段，注重你假如不是publish类的对象肯定会报错的，别乱昂 体式格局2: book_obj=Book.objects.create(title="金瓶煤",publishDate="2012-12-12",price=100,publish_id=1) #直接能够写id值，注重字段属性的写法和上面差别，这个是<br>publish_id=xxx，上面是publish=xxx。
中心：book_obj.publish与book_obj.publish_id是什么？
一对多的编削和单表的编削是一样的，别忘了删除表的时刻，我们是做了级联删除的。
多对多
体式格局一： 多对多平常在前端页面上运用的时刻是多选下拉框的模样来给用户挑选多个数据，这里能够让用户挑选多个书本，多个作者
# 当前生成的书本对象
book_obj=Book.objects.create(title="追鹞子的人",price=200,publishDate="2012-11-12",publish_id=1)
# 为书本绑定的作者对象
yuan=Author.objects.filter(name="yuan").first() # 在Author表中主键为2的记载，注重取的是author的model对象
egon=Author.objects.filter(name="alex").first() # 在Author表中主键为1的记载
#有人能够会说，我们能够直接给第三张表增加数据啊，这个自动生成的第三张表你能经由过程models猎取到吗，是猎取不到的，用不了的，固然假如你知道了这个表的名字，那末你经由过程原生sql语句<br>能够举行书的增加，所以要经由过程orm间接的给第三张表增加数据，假如是你手动增加的第三张表你是能够直接给第三张表增加数据
# 绑定多对多关联,即向关联表book_authors中增加记载，给书增加两个作者，下面的语法就是通知orm给第三张表增加两条数据
book_obj.authors.add(yuan,egon) # 将某些特定的 model 对象增加到被关联对象鸠合中。 ======= book_obj.authors.add(*[])
#book_obj是书本对象，authors是book表内里谁人多对多的关联字段称号。
#实在orm就是先经由过程book_obj的authors属性找到第三张表，然后将book_obj的id值和两个作者对象的id值组合成两条记载增加到第三张表内里去
体式格局二
book_obj.authors.add(1，2)
book_obj.authors.add(*[1，2]) #这类体式格局用的最多，由于平常是给用户来挑选，用户挑选是多选的，选完给你发送过来的就是一堆的id值
数据库表记载生成以下：
book表
book_authors表
中心:book_obj.authors.all()是什么？
多对多关联别的经常运用API：
book_obj.authors.remove() # 将某个特定的对象从被关联对象鸠合中去除。 ====== book_obj.authors.remove(*[1，2])，将多对多的关联数据删除 book_obj.authors.clear() #清空被关联对象鸠合 book_obj.authors.set() #先清空再设置 =====
删除示例：
book_obj = models.Book.objects.filter(nid=4)[0]
# book_obj.authors.remove(2) #将第三张表中的这个book_obj对象对应的谁人作者id为2的那条记载删除
# book_obj.authors.clear()
# book_obj.authors.set('2') #先清撤除一切的关联数据，然后只给这个书对象绑定这个id为2的作者，所以只剩下一条记载 3---2，比方用户编辑数据的时刻，挑选作者发生了变化，<br>那末须要从新挑选，所以我们就能够先清空，然后再从新绑定关联数据,注重这里写的是字符串，数字范例不能够
book_obj.authors.set(*['1',]) #这么写也能够，然则注重列表中的元素是字符串
三 基于对象的跨表查询
跨表查询是分组查询的基本，F和Q查询是最简朴的，所以认真进修跨表查询
一对多查询（Publish 与 Book）
正向查询(按字段：publish)：关联属性字段地点的表查询被关联表的记载就是正向查询，反之就是反向查询
# 查询主键为1的书本的出书社地点的都市 book_obj=Book.objects.filter(pk=1).first() # book_obj.publish 是主键为1的书本对象关联的出书社对象，book对象.外键字段称号 print(book_obj.publish.city)
反向查询(按表名：book_set,由于加上_set是由于反向查询的时刻，你查询出来的多是多条记载的鸠合)：
publish=Publish.objects.get(name="苹果出书社")
#publish.book_set.all() : 与苹果出书社关联的一切书本对象鸠合，写法：小写的表名_set.all()，获得queryset范例数据
book_list=publish.book_set.all()
for book_obj in book_list:
print(book_obj.title)
一对一查询(Author与AuthorDetail)
正向查询(按字段：authorDetail)：
egon=Author.objects.filter(name="egon").first() print(egon.authorDetail.telephone) egon.authorDeail就拿到了这个对象，由于一对一找到的就是一条记载，注重写法：作者对象.字段名,就拿到了谁人关联对象
反向查询(按表名：author)：不须要_set，由于一对一正向反向都是找到一条记载
# 查询一切住址在北京的作者的姓名 authorDet=AuthorDetail.objects.filter(addr="beijing")[0] authorDet.author.name
多对多查询(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)
注重：
你能够经由过程在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的称号。比方，假如 Article model 中做一下变动：
publish = ForeignKey(Book, related_name='bookList')
那末接下来就会如我们看到这般：
# 查询 人民出书社出书过的一切书本 publish=Publish.objects.get(name="人民出书社") book_list=publish.bookList.all() # 与人民出书社关联的一切书本对象鸠合
在这里我们补充一点，由于你很快就要打仗到了，那就是form表单内里的button按钮和form表单表面的button按钮的区分，form表单内里的button按钮实在和input type='submit'的标签是有一样的结果的，都能够提交form表单的数据，然则假如放在form表单表面的button按钮，那就只是个一般的按钮了。<button>提交</button>，另有一点，input type='submit'按钮放到form表单表面那就成了一个一般的按钮。
四 基于双下划线的跨表查询（基于join完成的）
Django 还供应了一种直观而高效的体式格局在查询(lookups)中示意关联关联，它能自动确认 SQL JOIN 联络。要做跨关联查询，就运用两个下划线来链接模子(model)间关联字段的称号，直到终究链接到你想要的model 为止。
''' 基于双下划线的查询就一句话：正向查询按字段,反向查询按表名小写用来通知ORM引擎join哪张表,一对一、一对多、多对多都是一个写法，注重，我们写orm查询的时刻，哪一个表在前哪一个表在后<br>都没题目，由于走的是join连表操纵。 '''
一对多查询
# 例: 查询苹果出书社出书过的一切书本的名字与价钱(一对多)
# 正向查询 按字段:publish
queryResult=Book.objects
.filter(publish__name="苹果出书社") #经由过程__通知orm将book表和publish表举行join，然后找到一切记载中publish.name='苹果出书社'的记载<br>（注重publish是属性称号），然后select book.title,book.price的字段值
.values_list("title","price") #values或许values_list
# 反向查询 按表名:book
queryResult=Publish.objects
.filter(name="苹果出书社")
.values_list("book__title","book__price")
多对多查询
# 例: 查询yuan出过的一切书本的名字(多对多)
# 正向查询 按字段:authors:
queryResult=Book.objects
.filter(authors__name="yuan")
.values_list("title")
# 反向查询 按表名:book
queryResult=Author.objects
.filter(name="yuan")
.values_list("book__title","book__price")
一对一查询
# 查询yuan的手机号
# 正向查询
ret=Author.objects.filter(name="yuan").values("authordetail__telephone")
# 反向查询
ret=AuthorDetail.objects.filter(author__name="yuan").values("telephone")
五 聚合查询、分组查询、F查询和Q查询
聚合
aggregate(*args, **kwargs)
# 盘算一切图书的均匀价钱
>>> from django.db.models import Avg
>>> Book.objects.all().aggregate(Avg('price')) #或许给它起名字：aggretate(a=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')) #count('id'),count(1)也能够统计个数,Book.objects.all().aggregete和Book.objects.<br> aggregate()，都能够
{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}
分组
###################################－－单表分组查询－－#######################################################
查询每一个部门称号以及对应的员工数
emp:
id name age salary dep
1 alex 12 2000 销售部
2 egon 22 3000 人事部
3 wen 22 5000 人事部
sql语句:
select dep,Count(*) from emp group by dep;
ORM:
emp.objects.values("dep").annotate(c=Count("id") #注重：annotate内里必需写个聚合函数，不然没有意义，而且必需有个别号=，别号随意写，然则必需有，用哪一个字段分组，<br>values内里就写哪一个字段,annotate实在就是对分组结果的统计，统计你须要什么。
'''
select dep,count('id') as c from emp grouby dep; #原生sql语句中的as c，不是必需有的
'''
###################################－－多表分组查询－－###########################
多表分组查询：
查询每一个部门称号以及对应的员工数
emp:
id name age salary dep_id
1 alex 12 2000 1
2 egon 22 3000 2
3 wen 22 5000 2
dep
id name
1 销售部
2 人事部
emp－dep:
id name age salary dep_id id name
1 alex 12 2000 1 1 销售部
2 egon 22 3000 2 2 人事部
3 wen 22 5000 2 2 人事部
sql语句:
select dep.name,Count(*) from emp left join dep on emp.dep_id=dep.id group by dep.id
ORM:
dep.objetcs.values("id").annotate(c=Count("emp")).values("name","c")
ret = models.Emp.objects.values('dep_id','name').annotate(a=Count(1))
'''
SELECT `app01_emp`.`dep_id`, `app01_emp`.`name`, COUNT(1) AS `a` FROM `app01_emp` GROUP BY `app01_emp`.`dep_id`, `app01_emp`.`name`
'''
#<QuerySet [{'dep_id': 1, 'name': 'alex', 'a': 1}, {'dep_id': 2, 'name': 'egon', 'a': 1}, {'dep_id': 2, 'name': 'wen', 'a': 1}]>,注重，这里假如你写了其他<br>字段，那末只要这两个字段反复，才算一组，合并到一同来统计个数
class Emp(models.Model):
name=models.CharField(max_length=32)
age=models.IntegerField()
salary=models.DecimalField(max_digits=8,decimal_places=2)
dep=models.CharField(max_length=32)
province=models.CharField(max_length=32)
annotate()为挪用的QuerySet中每一个对象都生成一个自力的统计值（统计要领用聚合函数）。
总结 ：跨表分组查询实质就是将关联表join成一张表，再按单表的思绪举行分组查询,，既然是join连表，就能够运用我们的双下划线举行连表了。
#单表：
#查询每一个部门的id以及对应员工的均匀薪水
ret = models.Emp.objects.values('dep_id').annotate(s=Avg('salary'))
#查询每一个部门的id以及对对应的员工的最大岁数
ret = models.Emp.objects.values('dep_id').annotate(a=Max('age'))
#Emp示意表，values中的字段示意根据哪一个字段group by，annotate内里是显现分组统计的是什么
#连表：
# 查询每一个部门的称号以及对应的员工个数和员工最大岁数
ret = models.Emp.objects.values('dep__name').annotate(a=Count('id'),b=Max('age')) #注重，正向与反向的结果能够差别，假如反向查的时刻，有的部门还没有员工，<br>那末他的数据也会被统计出来，只不过值为0，然则正向查的话只能统计出来有员工的部门的相干数据，由于经由过程你是员工找部门，而不是经由过程部门找员工，结果集内里的数据个数差别，然则你想要的统计<br>结果是一样的
#<QuerySet [{'a': 1, 'dep__name': '销售部', 'b': 12}, {'a': 3, 'dep__name': '人事部', 'b': 22}]>
#运用双下划线举行连表，然后根据部门称号举行分组，然后统计员工个数和最大岁数，末了结果内里显现的是部门称号、个数、最大岁数。
#注重：假如values内里有多个字段的状况：
ret = models.Emp.objects.values('dep__name','age').annotate(a=Count('id'),b=Max('age')) #是根据values内里的两个字段举行分组，两个字段同时雷同才算是一组，<br>看下面的sql语句
'''
SELECT `app01_dep`.`name`, `app01_emp`.`age`, COUNT(`app01_emp`.`id`) AS `a`, MAX(`app01_emp`.`age`) AS `b` FROM `app01_emp` INNER JOIN `app01_dep`<br> ON (`app01_emp`.`dep_id` = `app01_dep`.`id`) GROUP BY `app01_dep`.`name`, `app01_emp`.`age`;
'''
下面是书本表和出书社表的一个连表分组的sql语句写法：
F查询与Q查询
F查询
在上面一切的例子中，我们组织的过滤器都只是将字段值与某个常量做比较。假如我们要对两个字段的值做比较，那该怎样做呢？我们在book表内里加上两个字段：批评数：commentNum，珍藏数：KeepNum
Django 供应 F() 来做如许的比较。F() 的实例能够在查询中援用字段，来比较同一个 model 实例中两个差别字段的值。
# 查询批评数大于珍藏数的书本
from django.db.models import F
Book.objects.filter(commentNum__gt=F('keepNum'))
Django 支撑 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操纵。
# 查询批评数大于珍藏数2倍的书本
Book.objects.filter(commentNum__gt=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) 查询：
bookList=Book.objects.filter(Q(authors__name="yuan") & ~Q(publishDate__year=2017)).values_list("title")
bookList=Book.objects.filter(Q(Q(authors__name="yuan") & ~Q(publishDate__year=2017))&Q(id__gt=6)).values_list("title") #能够举行Q嵌套，多层Q嵌套等，<br>实在工作中比较经常运用
查询函数能够夹杂运用Q 对象和关键字参数。一切供应给查询函数的参数（关键字参数或Q 对象）都将"AND”在一同。然则，假如涌现Q 对象，它必需位于一切关键字参数的前面。比方：
bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017),
title__icontains="python" #也是and的关联，然则Q必需写在前面
)
六 Python剧本中挪用Django环境(django外部剧本运用models)
假如你想经由过程本身竖立的python文件在django项目中运用django的models，那末就须要挪用django的环境：
import os
if __name__ == '__main__':
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")
import django
django.setup()
from app01 import models #引入也要写在上面三句以后
books = models.Book.objects.all()
print(books
以上就是django模子层之多表操纵的细致引见（代码示例）的细致内容，更多请关注ki4网别的相干文章！
