1、返回新查询集的方法
（1）filter()：滤指定条件的结果
Entry.objects.filter(pub_date__gt=datetime.date(2005, 1, 3), headline=‘Hello‘)SQL语句：
SELECT ... WHERE (pub_date > ‘2005-1-3‘ AND headline = ‘Hello‘)
（2）exclude()：排除指定条件的结果
Entry.objects.exclude(pub_date__gt=datetime.date(2005, 1, 3), headline=‘Hello‘)SQL语句：
SELECT ... WHERE NOT (pub_date > ‘2005-1-3‘ AND headline = ‘Hello‘)
（3）annotate()：用提供的查询表达式列表注释QuerySet中的每个对象。表达式可以是一个简单的值，对模型(或任何相关模型)上的字段的引用，
或者是对与QuerySet中的对象相关的对象进行计算的聚合表达式(平均值、和等)。annotate()的每个参数都是一个注释，它将被
添加到返回的QuerySet中的每个对象中。
>>> from django.db.models import Count >>> q = Blog.objects.annotate(Count(‘entry‘)) # The name of the first blog >>> q[0].name ‘Blogasaurus‘ # The number of entries on the first blog >>> q[0].entry__count 42 # 没有指定关键字参数，列和聚合函数的名字决定别名 >>> q = Blog.objects.annotate(number_of_entries=Count(‘entry‘)) # The number of entries on the first blog, using the name provided >>> q[0].number_of_entries 42 # 指定关键字参数，聚合别名为关键字参数
（4）order_by()：指定字段排序
默认升序，字段名前加负号降序，？代表随机排序（浪费时间与性能，主要看你用的后端）
Entry.objects.filter(pub_date__year=2005).order_by(‘-pub_date‘, ‘headline‘) # 先按照pub_date 降序排列，然后headline升序排列
要按不同模型中的字段排序，使用与查询模型关系相同的语法。也就是说，字段名后面跟着双下划线(__)，后面跟着新模型中的字段名，等等。
Entry.objects.order_by(‘blog__name‘, ‘headline‘)
如果您尝试按与另一个模型相关的字段排序，Django将在相关模型上使用默认的顺序，如果没有元数据，则使用相关模型的主键排序。指定排序。
例如，由于博客模型没有指定默认的排序
Entry.objects.order_by(‘blog‘) 等同于 Entry.objects.order_by(‘blog__id‘)
如果博客模型指定排序 ordering = [‘name‘]
Entry.objects.order_by(‘blog__id‘)
如果不希望对查询应用任何排序，甚至不希望对默认排序应用任何排序，那么可以不带参数地调用order_by()。
可以通过检查QuerySet来判断查询是否有序。有序属性，如果查询集以任何方式被排序，则该属性为True。
每个order_by()调用将清除以前的任何排序。例如，该查询将按pub_date排序，而不是按标题
Entry.objects.order_by("headline").order_by("-pub_date”)
（5）reverse()：排序后的结果顺序反转（必须是已经排好序的结果集）
取出最后五个对象
my_queryset.reverse()[:5]
与序列的分片[-5:]不一样，分片首先看到的是倒数第五个，reverse首先看到的是最后一个。
Django不支持这种访问模式(从末尾开始分段)，因为在SQL中不可能有效地做到这一点。
（6）dictinct()：返回一个新的QuerySet，它在SQL查询中使用SELECT DISTINCT。这从查询结果中消除了重复的行。
Author.objects.distinct()
（7）values()：返回一个QuerySet，当作为迭代使用时，它返回字典而不是模型实例。这些字典中的每一个都代表一个对象，其键对应于模型对象的属性名。
位置参数指定需要在select中查询的值。values()方法还接受可选的关键字参数，这些参数传递给annotate():
>>> Blog.objects.filter(name__startswith=‘Beatles‘).values()
<QuerySet [{‘id‘: 1, ‘name‘: ‘Beatles Blog‘, ‘tagline‘: ‘All the latest Beatles news.‘}]>
>>> Blog.objects.values(‘id‘, ‘name‘)
<QuerySet [{‘id‘: 1, ‘name‘: ‘Beatles Blog‘}]>
>>> from django.db.models.functions import Lower
>>> Blog.objects.values(lower_name=Lower(‘name‘))
<QuerySet [{‘lower_name‘: ‘beatles blog‘}]>
在values()子句中的其他参数之前应用values()子句中的聚合。如果需要按另一个值进行分组，则将其添加到前面的values()子句中。
>>> from django.db.models import Count
>>> Blog.objects.values(‘entry__authors‘, entries=Count(‘entry‘))
<QuerySet [{‘entry__authors‘: 1, ‘entries‘: 20}, {‘entry__authors‘: 1, ‘entries‘: 13}]>
>>> Blog.objects.values(‘entry__authors‘).annotate(entries=Count(‘entry‘))
<QuerySet [{‘entry__authors‘: 1, ‘entries‘: 33}]>
如果有一个名为foo的字段是ForeignKey，那么默认值()调用将返回一个名为foo_id的字典键，因为这是存储实际值的隐藏模型属性的名称(foo属性引用相关模型)。
当您调用values()并传入字段名时，您可以传入foo或foo_id，您将得到相同的结果(dictionary键将匹配您传入的字段名)。
>>> Entry.objects.values()
<QuerySet [{‘blog_id‘: 1, ‘headline‘: ‘First Entry‘, ...}, ...]>
>>> Entry.objects.values(‘blog‘)
<QuerySet [{‘blog‘: 1}, ...]>
>>> Entry.objects.values(‘blog_id‘)
<QuerySet [{‘blog_id‘: 1}, ...]>
最后，注意，您可以在values()调用之后调用filter()、order_by()等，这意味着这两个调用是相同的
Blog.objects.values().order_by(‘id‘) Blog.objects.order_by(‘id‘).values()
（8）：value_list()：返回元组而不是字典，如果只在单个字段中传递，也可以传递平面参数。如果为真，这将意味着返回的结果是单个值，
而不是一个元组。多与两个字段是不要传递flat参数，一个例子应该可以使区别变得更清楚:
>>> Entry.objects.values_list(‘id‘).order_by(‘id‘) <QuerySet[(1,), (2,), (3,), ...]> >>> Entry.objects.values_list(‘id‘, flat=True).order_by(‘id‘) <QuerySet [1, 2, 3, ...]>
传递named=True，获得命名元组（Django 2.0新增）
>>> Entry.objects.values_list(‘id‘, ‘headline‘, named=True) <QuerySet [Row(id=1, headline=‘First entry‘), ...]>
从查询的结果集中获取指定条件的对象
>>> Entry.objects.values_list(‘headline‘, flat=True).get(pk=1) ‘First entry‘
（9）none()：创建一个空的查询集，EmptyQuerySet的子集
（10）all()：返回所有结果
（11）union()：两个结果集的并集
intersection()：两个结果集的交集
difference()：两个届国际的差集
（12）selected_related()：预先查询外键关系。查询略复杂，但是使用外键时不需要再次访问数据库
select_related工作方式是创建SQL连接，并在SELECT语句中包含相关对象的字段。因此，select_related获取相同数据库查询中的相关对象。
然而，为了避免由于跨“多”关系连接而导致更大的结果集，select_related仅限于单值关系——外键和一对一关系。
# Hits the database. e = Entry.objects.get(id=5) # Hits the database again to get the related Blog object. b = e.blog # Hits the database. e = Entry.objects.select_related(‘blog‘).get(id=5) # Doesn‘t hit the database, because e.blog has been prepopulated # in the previous query. b = e.blog
（13）prefetch_releated()：返回一个QuerySet，它将在单个批处理中为每个指定查找自动检索相关对象。
prefetch_related为每个关系执行单独的查找，并在Python中执行“连接”。这允许它预取多对多和多对一对象，这是不能使用select_related实现的，
除了select_related支持的外键和一对一关系之外。它还支持GenericRelation和GenericForeignKey的预抓取，但是，它必须被限制为同构的结果集。
例如，只在查询限制为一个ContentType时才支持GenericForeignKey引用的预抓取对象。具体请查阅Django官网。
（14）defer()：延迟加载
在一些复杂的数据建模情况下，您的模型可能包含许多字段，其中一些可能包含许多数据(例如文本字段)，或者需要昂贵的处理才能将它们转换为Python对象。
如果在最初获取数据时不知道是否需要这些特定字段的情况下使用queryset的结果，那么可以告诉Django不要从数据库中检索它们。
这是通过传递字段的名称来完成的，以便不加载以延迟()
Entry.objects.defer("headline", "body")
如果您想清除延迟字段的集合，请将None作为参数传递给defer()
（15）only()：惟一的()方法或多或少与defer()相反。使用在检索模型时不应该延迟的字段调用它。如果您有一个模型，其中几乎所有字段都需要延迟，
那么使用only()来指定补充字段集可以得到更简单的代码。无论何时调用only()，它都会替换要立即加载的字段集。因此，连续调用only()只会导致只考虑最后的字段
（16）raw()：获取原始SQL查询，执行它，并返回django.db.models.query。RawQuerySet实例。这个RawQuerySet实例可以像普通的QuerySet一样遍历，以提供对象实例。
2、返回新查询结果集的操作
（1）AND（&）组合的查询集必须使用两个相同的模型
Model.objects.filter(x=1) & Model.objects.filter(y=2) Model.objects.filter(x=1, y=2) from django.db.models import Q Model.objects.filter(Q(x=1) & Q(y=2))
SELECT ... WHERE x=1 AND y=2
（2）OR（|）
Model.objects.filter(x=1) | Model.objects.filter(y=2) from django.db.models import Q Model.objects.filter(Q(x=1) | Q(y=2))
SELECT ... WHERE x=1 OR y=2
3、不返回查询集的方法
（1）get() ：返回匹配给定查找参数的对象，查找参数的格式应与字段查找中描述的格式相同。
返回一个以上对象时引起MUultipleObjectReturned异常
返回为空时引起ObjectDoesNotExist异常
（2）create()：创建一个对象并保存，等价于实例化一个模型，载调用save方法
（3）get_or_create(defaults=None，**kwargs)：查找或创建，返回一个元组(对象，已创建)，其中对象是检索的或已创建的对象，并创建一个布尔值，指定是否创建了新对象。
传递给get_or_create()的任何关键字参数——除了一个可选的称为默认值的参数——将在get()调用中使用。如果找到一个对象，get_or_create()将返回该对象的一个元组，
并返回False。如果找到多个对象，get_or_create()会引发返回的multipleobjectsreturn。如果没有找到对象，get_or_create()将实例化并保存一个新对象，返回新对象和True的元组。
obj, created = Person.objects.get_or_create(
first_name=‘John‘,
last_name=‘Lennon‘,
defaults={‘birthday‘: date(1940, 10, 9)},
)
（4）update_or_create(defaults=None，**kwargs)：更新或创建。返回一个元组(对象，已创建)，其中对象是已创建或更新的对象，并创建一个布尔值，指定是否创建了新对象
obj, created = Person.objects.update_or_create(
first_name=‘John‘, last_name=‘Lennon‘,
defaults={‘first_name‘: ‘Bob‘},
)
（5）count()：返回一个整数，该整数表示数据库中与QuerySet匹配的对象的数量。
（6）iterator(chunk_size=2000)：放回一个迭代器，对于数据量大的结果集，显著地减少内存消耗。注意，在已经求值的QuerySet上使用iterator()将迫使它再次求值，重复查询。chunk_size参数控制
从数据库驱动程序检索的批处理的大小。较大的批处理减少了与数据库驱动程序通信的开销，而内存消耗则略有增加。
（7）latest()：根据数据字段返回最新的结果，还可以根据几个字段选择最新的。例如，当两个条目有相同的pub_date时，选择最早的expire_date条目:
earlist()：返回最早的结果
Entry.objects.latest(‘pub_date‘, ‘-expire_date‘)
（8）first()：返回由queryset匹配的第一个对象，如果没有匹配的对象，则返回None。如果QuerySet没有定义任何排序，那么QuerySet将由主键自动排序。
last()：返回最后一个结果。
（9）aggregate()：聚合查询，可以通过使用关键字参数指定聚合函数，您可以控制返回的聚合值的名称。
>>> from django.db.models import Count
>>> q = Blog.objects.aggregate(Count(‘entry‘))
{‘entry__count‘: 16}
q = Blog.objects.aggregate(number_of_entries=Count(‘entry‘))
{‘number_of_entries‘: 16}
（10）exists()：是否存在。如果QuerySet包含任何结果，返回True;如果不包含结果，返回False。尝试以尽可能简单和最快的方式执行查询，但它执行的查询与
普通的QuerySet查询几乎相同。
（11）update(**kwargs)：更新对象，对指定的字段执行SQL update查询，并返回匹配的行数(如果某些行已经具有新值，则可能不等于更新的行数)。
只能更新主表中的列，不能更新外键的表的列
（12）delete()：删除对象，对QuerySet中的所有行执行SQL delete查询，并返回被删除的对象数量和每个对象类型的删除数量字典。
原文地址：https://www.cnblogs.com/SunQi-Tony/p/9911034.html