Django QuestSet API （官方文档）

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查询，并返回被删除的对象数量和每个对象类型的删除数量字典。