QuerySet API 参考Link to this heading#该文档描述了 QuerySet API 的细节。它是建立在 模型 和 数据库查询 指南的材料基础上的，因此，在阅读这篇文档之前，你可能需要阅读和理解这些文档。
在整个参考资料中，我们将使用在 数据库查询指南 中提出的 示例博客模型。
\nQuerySet 被执行Link to this heading#QuerySet 本身可以被构造，过滤，切片，或者复制赋值等，是无需访问数据库的。只有在你需要从数据库取出数据或者，向数据库存入数据时才需要访问数据库。
你可以用以下方式执行一个 QuerySet：
迭代。 一个 QuerySet 是可迭代的，当你第一次迭代它时，它就会执行其数据库查询。例如，这将打印数据库中所有条目的标题：
for e in Entry.objects.all():\n print(e.headline)\n注意：如果你想做的只是确定至少一个结果是否存在，不要使用这个。使用 exists() 会更有效。
异步迭代。可以使用 async for 来迭代一个 QuerySet：
async for e in Entry.objects.all():\n results.append(e)\nQuerySets 的同步和异步迭代器共享相同的底层缓存。
\n切片。 正如在 限制 QuerySet 条目数 中所解释的那样，QuerySet 可以使用 Python 的数组切片语法进行切片。切片一个未执行的 QuerySet 通常会返回另一个未执行的 QuerySet，但如果使用切片语法的 step 参数，Django 会执行数据库查询，并返回一个列表。切片一个已经执行过的 QuerySet 也会返回一个列表。
还要注意的是，即使对一个未执行的 QuerySet 进行切片，返回另一个未执行的 QuerySet，也不允许进一步修改它（例如，添加更多的过滤器，或修改排序），因为这不能很好地翻译成 SQL，也没有明确的含义。
Pickle 序列化／缓存。 关于 pickling QuerySets 时涉及的细节，请参见下一节。就本节而言，重要的是，结果是从数据库中读取的。
repr()。 当你调用 repr() 时，所在 QuerySet 会被执行。这是为了方便 Python 交互式解释器，所以当你交互式使用 API 时，可以立即看到你的结果。
len()。 当你调用 len() 时，会执行 QuerySet。正如你所期望的，这将返回结果列表的长度。
注意：如果你只需要确定集合中的记录数（而不需要实际的对象），那么使用 SQL 的 SELECT COUNT(*) 在数据库层面上处理计数会更有效率。Django 提供了一个 count() 方法正是为了这个原因。
list()。 通过调用 list() 强制执行 QuerySet。例如：
entry_list = list(Entry.objects.all())\nbool()。 在布尔语境中测试 QuerySet，如使用 bool()、or、and 或 if 语句，将导致查询被执行。如果至少有一个结果，则 QuerySet 为 True，否则为 False。例如：
if Entry.objects.filter(headline="Test"):\n print("There is at least one Entry with the headline Test")\n注意：如果你只想确定至少一个结果是否存在（而不需要实际的对象），使用 exists() 更高效。
QuerySetLink to this heading#如果你 pickle 序列化一个 QuerySet，这将迫使所有结果在 pickle 序列化之前加载到内存中。Pickle 序列化通常被用作缓存的前奏，当缓存的查询集被重新加载时，你希望结果已经存在并可以使用（从数据库读取可能需要一些时间，这就违背了缓存的目的）。这意味着，当你取消缓存一个 QuerySet 时，它包含的是它被缓存时的结果，而不是当前在数据库中的结果。
如果你只想要将必要的信息存储为 pickle，在以后的时间从数据库中重新创建 QuerySet，可以 pickle QuerySet 的 query 属性。然后，可以使用类似以下的代码重新创建原始的 QuerySet （不加载任何结果）：
>>> import pickle\n>>> query = pickle.loads(s) # Assuming 's' is the pickled string.\n>>> qs = MyModel.objects.all()\n>>> qs.query = query # Restore the original 'query'.\nquery 属性是一个不透明的对象。它代表了查询结构的内部结构，不是公共 API 的一部分。但是，如这里所述，可以安全地（并完全支持）pickle 序列化和反序列化该属性的内容。
QuerySet APILink to this heading#这里是 QuerySet 的正式声明：
通常当你与 QuerySet 交互时，你会通过 链式过滤器 来使用它。为了实现这一目的，大多数 QuerySet 方法都会返回新的查询集。这些方法将在本节后面详细介绍。
QuerySet 类具有以下公共属性，可以用于自省：
True if the QuerySet is ordered — i.e. has an\norder_by() clause or a default ordering on the model.\nFalse otherwise.
Returns True if the QuerySet is ordered and the ordering is\ndeterministic. This requires that the ordering includes a field\n(or set of fields) that is unique and non-nullable.
For queries involving a GROUP BY clause, the model's default\nordering is ignored. Ordering specified via .extra(order_by=...)\nis also ignored.
如果现在执行这个查询，将使用的数据库。
\nQuerySet 的方法Link to this heading#Django 提供了一系列的 QuerySet 细化方法，这些方法可以修改 QuerySet 返回的结果类型或其 SQL 查询的执行方式。
filter()Link to this heading#返回一个新的 QuerySet，其中包含与给定查找参数相匹配的对象。
查询参数（**kwargs）的格式应在下文 Field lookups 中描述。多个参数通过底层 SQL 语句中的 AND 连接。
If you need to execute more complex queries (for example, queries with OR\nstatements), you can use Q() 对象 (*args).
exclude()Link to this heading#返回一个新的 QuerySet，其中包含与给定查找参数不匹配的对象。
查询参数（**kwargs）的格式应在下文 Field lookups 中描述。多个参数通过底层 SQL 语句中的 AND 连接，整个过程用 NOT() 括起来。
这个例子排除了所有 pub_date 晚于 2005-1-3 且 headline 为“Hello”的条目：
Entry.objects.exclude(pub_date__gt=datetime.date(2005, 1, 3), headline="Hello")\n用 SQL 术语来说，它的值是：
\nSELECT ...\nWHERE NOT (pub_date > '2005-1-3' AND headline = 'Hello')\n这个例子不包括所有 pub_date 晚于 2005-1-3 或 headline 为“Hello”的条目：
Entry.objects.exclude(pub_date__gt=datetime.date(2005, 1, 3)).exclude(headline="Hello")\n用 SQL 术语来说，它的值是：
\nSELECT ...\nWHERE NOT pub_date > '2005-1-3'\nAND NOT headline = 'Hello'\n请注意，第二个例子的限制性更强。
\n如果你需要执行更复杂的查询（例如，带有 OR 语句的查询），你可以使用 Q 对象 （*args）。
annotate()Link to this heading#Annotates each object in the QuerySet with the provided list of query\nexpressions or Q() 对象. Each object can be\nannotated with:
a simple value, via Value();
a reference to a field on the model (or any related models), via F();
a boolean, via Q(); or
a result from an aggregate expression (averages, sums, etc.) computed over\nthe objects that are related to the objects in the QuerySet.
annotate() 的每个参数都是一个注解，将被添加到返回的 QuerySet 中的每个对象。
Django 提供的聚合函数在下面的 聚合函数 中介绍。
\n使用关键字参数指定的注解将使用关键字作为注解的别名。匿名参数将根据聚合函数的名称和被聚合的模型字段为其生成一个别名。只有引用单个字段的聚合表达式才能成为匿名参数。其他一切都必须是关键字参数。
\n例如，如果你正在操作一个博客列表，你可能想确定每个博客中有多少条条目：
\n>>> from django.db.models import Count\n>>> q = Blog.objects.annotate(Count("entry"))\n# The name of the first blog\n>>> q[0].name\n'Blogasaurus'\n# The number of entries on the first blog\n>>> q[0].entry__count\n42\nBlog 模型本身没有定义 entry__count 属性，但通过使用关键字参数来指定聚合函数，你可以控制注释的名称：
>>> q = Blog.objects.annotate(number_of_entries=Count("entry"))\n# The number of entries on the first blog, using the name provided\n>>> q[0].number_of_entries\n42\n关于聚合的深入讨论，见 关于聚合的专题指南。
\nalias()Link to this heading#与 annotate() 相同，但不是注解中的 QuerySet 对象，而是保存表达式，以便以后与其他 QuerySet 方法重复使用。当不需要表达式本身的结果，但用于过滤、排序或作为复杂表达式的一部分时，这很有用。不查找未使用的值可以从数据库中移除多余的工作，这应该会带来更好的性能。
例如，如果你想查找具有超过 5 条条目的博客，但不关心具体的条目数量，你可以这样做：
\n>>> from django.db.models import Count\n>>> blogs = Blog.objects.alias(entries=Count("entry")).filter(entries__gt=5)\nalias() can be used in conjunction with annotate(), exclude(),\nfilter(), order_by(), and update(). To use an aliased\nexpression with other methods (e.g. aggregate()), you must promote it to\nan annotation:
Blog.objects.alias(entries=Count("entry")).annotate(\n entries=F("entries"),\n).aggregate(Sum("entries"))\nfilter() and order_by() can take expressions directly, but\nexpression construction and usage often does not happen in the same place (for\nexample, QuerySet method creates expressions, for later use in views).\nalias() allows building complex expressions incrementally (possibly\nspanning multiple methods and modules), referring to the expression parts by\ntheir aliases, and only using annotate() for the final result.
order_by()Link to this heading#默认情况下，QuerySet 返回的结果是按照模型 Meta 中的 ordering 选项给出的排序元组排序的。你可以通过使用 order_by 方法在每个 QuerySet 的基础上覆盖这一点。
举例：
\nEntry.objects.filter(pub_date__year=2005).order_by("-pub_date", "headline")\n上述结果将按 pub_date 降序排列，然后按 headline 升序排列。"-pub_date" 前面的负号表示 降序。升序是隐含的。要随机排序，使用 "?"，如：
Entry.objects.order_by("?")\n注意：order_by('?') 查询可能会很贵，而且速度很慢，这取决于你使用的数据库后端。
要按不同模型中的字段排序，使用与跨模型关系查询时相同的语法。也就是说，字段的名称，后面是双下划线（__），再后面是新模型中的字段名称，以此类推，想加入多少模型就加入多少。例如：
Entry.objects.order_by("blog__name", "headline")\n如果你试图通过与另一个模型有关系的字段进行排序，Django 将使用相关模型上的默认排序，如果没有指定 Meta.ordering，则通过相关模型的主键进行排序。例如，由于 Blog 模型没有指定默认排序：
Entry.objects.order_by("blog")\n...等同于：
\nEntry.objects.order_by("blog__id")\n如果 Blog 有 ordering = ['name']，那么第一个查询集将与以下内容相同：
Entry.objects.order_by("blog__name")\n你也可以通过在表达式上调用 asc() 或 esc()，按 查询表达式 排序：
Entry.objects.order_by(Coalesce("summary", "headline").desc())\nasc() 和 esc() 有参数（nulls_first 和 nulls_last）来控制如何对空值进行排序。
Be cautious when ordering by fields in related models if you are also using\ndistinct(). See the note in distinct() for an explanation of how\nrelated model ordering can change the expected results.
没有办法指定排序是否应该区分大小写。关于大小写敏感，Django 会按照数据库后台的正常排序方式来排序。
\n你可以用 Lower 将一个字段转换为小写，从而实现大小写一致的排序：
Entry.objects.order_by(Lower("headline").desc())\nIf you don't want any ordering to be applied to a query, not even the default\nordering, call order_by() with no parameters.
你可以通过检查 QuerySet.ordered 属性来判断一个查询是否被排序，如果 QuerySet 以任何方式被排序，则该属性为 True。
每次 order_by() 调用都将清除以前的任何排序。例如，此查询将按 pub_date 而不是 headline 排序：
Entry.objects.order_by("headline").order_by("pub_date")\n使用 reverse() 方法来反向返回查询集元素的顺序。第二次调用 reverse() 会将顺序恢复到正常方向。
要检索一个查询集中的“最后”五个项目，你可以这样做：
\nmy_queryset.reverse()[:5]\n请注意，这与 Python 中从一个序列的末尾切分不太一样。上面的例子会先返回最后一项，然后返回倒数第二项，以此类推。如果我们有一个 Python 序列，看 seq[-5:]，我们会先看到倒数第五项。Django 不支持这种访问模式（从末尾切分），因为在 SQL 中不可能有效地做到这一点。
Also, note that reverse() should generally only be called on a QuerySet\nwhich has a defined ordering (e.g., when querying against a model which defines\na default ordering, or when using order_by()). If no such ordering is\ndefined for a given QuerySet, calling reverse() on it has no real\neffect (the ordering was undefined prior to calling reverse(), and will\nremain undefined afterward).
distinct()Link to this heading#返回一个新的 QuerySet，在其 SQL 查询中使用 SELECT DISTINCT。这将消除查询结果中的重复记录。
默认情况下，QuerySet 不会消除重复的记录。在实践中，这很少是一个问题，因为简单的查询，如 Blog.objects.all() 不会引入重复结果行的可能性。但是，如果你的查询跨越了多个表，当 QuerySet 被执行时，就有可能得到重复的结果。这时就应该使用 distinct()。
仅在 PostgreSQL 上，你可以传递位置参数（*fields），以指定 DISTINCT 应适用的字段名称。这相当于一个 SELECT DISTINCT ON 的 SQL 查询。这其中的区别是，对于普通的 distinct() 调用，数据库在确定哪些行是不同的时候，会比较每行中的 每个 字段。对于带有指定字段名的 distinct() 调用，数据库将只比较指定的字段名。
示例（在第一个示例之后，只能在 PostgreSQL 上运行）：
\n>>> Author.objects.distinct()\n<QuerySet [...]>\n>>> Entry.objects.order_by("pub_date").distinct("pub_date")\n<QuerySet [...]>\n>>> Entry.objects.order_by("blog").distinct("blog")\n<QuerySet [...]>\n>>> Entry.objects.order_by("author", "pub_date").distinct("author", "pub_date")\n<QuerySet [...]>\n>>> Entry.objects.order_by("blog__name", "mod_date").distinct("blog__name", "mod_date")\n<QuerySet [...]>\n>>> Entry.objects.order_by("author", "pub_date").distinct("author")\n<QuerySet [...]>\nvalues()Link to this heading#返回一个 QuerySet，当用作可迭代对象时，返回字典，而不是模型实例。
其中每一个字典都代表一个对象，键与模型对象的属性名相对应。
\n这个示例比较了 values() 的字典与普通的模型对象：
# This list contains a Blog object.\n>>> Blog.objects.filter(name__startswith="Beatles")\n<QuerySet [<Blog: Beatles Blog>]>\n\n# This list contains a dictionary.\n>>> Blog.objects.filter(name__startswith="Beatles").values()\n<QuerySet [{'id': 1, 'name': 'Beatles Blog', 'tagline': 'All the latest Beatles news.'}]>\nvalues() 方法接受可选的位置参数 *fields，它指定了 SELECT 应该被限制的字段名。如果你指定了字段，每个字典将只包含你指定字段的字段键／值。如果不指定字段，每个字典将包含数据库表中每个字段的键和值。
例如：
\n>>> Blog.objects.values()\n<QuerySet [{'id': 1, 'name': 'Beatles Blog', 'tagline': 'All the latest Beatles news.'}]>\n>>> Blog.objects.values("id", "name")\n<QuerySet [{'id': 1, 'name': 'Beatles Blog'}]>\nvalues() 方法还接受可选的关键字参数 **expressions，这些参数将传递给 annotate()：
>>> from django.db.models.functions import Lower\n>>> Blog.objects.values(lower_name=Lower("name"))\n<QuerySet [{'lower_name': 'beatles blog'}]>\n你可以在排序中使用内置和 自定义查找。例如：
\n>>> from django.db.models import CharField\n>>> from django.db.models.functions import Lower\n>>> CharField.register_lookup(Lower)\n>>> Blog.objects.values("name__lower")\n<QuerySet [{'name__lower': 'beatles blog'}]>\n在 values() 子句内部的聚合在同一 values() 子句内的其他参数之前应用。如果需要按另一个值进行分组，请将其添加到较早的 values() 子句中。例如：
>>> from django.db.models import Count\n>>> Blog.objects.values("entry__authors", entries=Count("entry"))\n<QuerySet [{'entry__authors': 1, 'entries': 20}, {'entry__authors': 1, 'entries': 13}]>\n>>> Blog.objects.values("entry__authors").annotate(entries=Count("entry"))\n<QuerySet [{'entry__authors': 1, 'entries': 33}]>\n有几个微妙的地方值得一提：
\n如果你有一个名为 foo 的字段是一个 ForeignKey，默认的 values() 调用将返回一个名为 foo_id 的字典键，因为这是存储实际值的隐藏模型属性的名称（foo 属性指的是相关模型）。当你调用 values() 并传递字段名时，你可以传递 foo 或 foo_id，你将得到同样的东西（字典键将与你传递的字段名匹配）。
例如：
\n>>> Entry.objects.values()\n<QuerySet [{'blog_id': 1, 'headline': 'First Entry', ...}, ...]>\n\n>>> Entry.objects.values("blog")\n<QuerySet [{'blog': 1}, ...]>\n\n>>> Entry.objects.values("blog_id")\n<QuerySet [{'blog_id': 1}, ...]>\nWhen using values() together with distinct(), be aware that\nordering can affect the results. See the note in distinct() for\ndetails.
If you use a values() clause after an extra() call,\nany fields defined by a select argument in the extra() must\nbe explicitly included in the values() call. Any extra() call\nmade after a values() call will have its extra selected fields\nignored.
Calling only() and defer() after values() doesn't make\nsense, so doing so will raise a TypeError.
组合转换和聚合需要使用两个 annotate() 调用，可以显式地使用它们，也可以作为 values() 的关键字参数。与上面一样，如果转换已经在相关字段类型上注册，第一个 annotate() 可以省略，因此以下示例是等效的：
>>> from django.db.models import CharField, Count\n>>> from django.db.models.functions import Lower\n>>> CharField.register_lookup(Lower)\n>>> Blog.objects.values("entry__authors__name__lower").annotate(entries=Count("entry"))\n<QuerySet [{'entry__authors__name__lower': 'test author', 'entries': 33}]>\n>>> Blog.objects.values(entry__authors__name__lower=Lower("entry__authors__name")).annotate(\n... entries=Count("entry")\n... )\n<QuerySet [{'entry__authors__name__lower': 'test author', 'entries': 33}]>\n>>> Blog.objects.annotate(entry__authors__name__lower=Lower("entry__authors__name")).values(\n... "entry__authors__name__lower"\n... ).annotate(entries=Count("entry"))\n<QuerySet [{'entry__authors__name__lower': 'test author', 'entries': 33}]>\n当你知道你只需要一小部分可用字段的值，而且你不需要模型实例对象的功能时，它就很有用。只选择你需要使用的字段会更高效。
\n最后要注意的是，你可以在调用 values() 之后调用 filter()、order_by() 等，也就是说这两个调用是相同的：
Blog.objects.values().order_by("id")\nBlog.objects.order_by("id").values()\n制作 Django 的人喜欢把所有影响 SQL 的方法放在前面，后面（可选的）是任何影响输出的方法（比如 values()），但这并不重要。这是你真正炫耀自己个性的机会。
你还可以通过 OneToOneField、ForeignKey 和 ManyToManyField 属性引用反向关系上的相关模型的字段：
>>> Blog.objects.values("name", "entry__headline")\n<QuerySet [{'name': 'My blog', 'entry__headline': 'An entry'},\n {'name': 'My blog', 'entry__headline': 'Another entry'}, ...]>\nvalues_list()Link to this heading#这与 values() 类似，不同之处在于在迭代时，它返回元组而不是字典。每个元组包含传递给 values_list() 调用的相应字段或表达式的值 — 因此第一个项是第一个字段，依此类推。例如：
>>> Entry.objects.values_list("id", "headline")\n<QuerySet [(1, 'First entry'), ...]>\n>>> from django.db.models.functions import Lower\n>>> Entry.objects.values_list("id", Lower("headline"))\n<QuerySet [(1, 'first entry'), ...]>\n如果只传入一个字段，你还可以传递 flat 参数。如果设置为 True，则返回的结果将是单个值，而不是 1 元组。一个示例可以更清楚地说明区别：
>>> Entry.objects.values_list("id").order_by("id")\n<QuerySet[(1,), (2,), (3,), ...]>\n\n>>> Entry.objects.values_list("id", flat=True).order_by("id")\n<QuerySet [1, 2, 3, ...]>\n当有多个字段时，传入 flat 是错误的。
你可以传递 named=True 以将结果作为 namedtuple() 返回：
>>> Entry.objects.values_list("id", "headline", named=True)\n<QuerySet [Row(id=1, headline='First entry'), ...]>\n使用命名元组可能会使使用结果更易读，但代价是将结果转化为命名元组时要付出很小的性能代价。
\n如果你不向 values_list() 传递任何值，它将按照声明的顺序返回模型中的所有字段。
一个常见的需求是获取特定模型实例的特定字段值。要实现这一点，使用 values_list() 后跟一个 get() 调用：
>>> Entry.objects.values_list("headline", flat=True).get(pk=1)\n'First entry'\nvalues() 和 values_list() 都是针对特定用例的优化：检索数据的子集，而不需要创建一个模型实例的开销。当处理多对多和其他多值关系（如反向外键的一对多关系）时，这个隐喻就失效了，因为“一行一对象”的假设不成立。
例如，请注意在查询跨越 ManyToManyField 时的行为：
>>> Author.objects.values_list("name", "entry__headline")\n<QuerySet [('Noam Chomsky', 'Impressions of Gaza'),\n ('George Orwell', 'Why Socialists Do Not Believe in Fun'),\n ('George Orwell', 'In Defence of English Cooking'),\n ('Don Quixote', None)]>\n有多个条目的作者出现多次，没有任何条目的作者的条目标题为 None。
类似地，当查询反向外键时，对于没有任何作者的条目，会显示为 None：
>>> Entry.objects.values_list("authors")\n<QuerySet [('Noam Chomsky',), ('George Orwell',), (None,)]>\ndates()Link to this heading#返回一个 QuerySet，它的值是一个 datetime.date 对象的列表，代表 QuerySet 内容中所有可用的特定日期。
field 应该是你的模型的 DateField 的名称。kind 应该是``"year"、"month"、"week"`` 或 "day"。结果列表中的每个 datetime.date 对象都被“截断”为给定的` type`。
"year" 返回字段的所有不同年份值的列表。
"month" 返回该字段所有不同年／月值的列表。
"week" 返回该字段的所有不同年份／星期值的列表。所有日期都是星期一。
"day" 返回该字段的所有不同年／月／日值的列表。
order，默认为 'ASC'，应该是 'ASC' 或 'DESC'。这指定了如何对结果进行排序。
举例：
\n>>> Entry.objects.dates("pub_date", "year")\n[datetime.date(2005, 1, 1)]\n>>> Entry.objects.dates("pub_date", "month")\n[datetime.date(2005, 2, 1), datetime.date(2005, 3, 1)]\n>>> Entry.objects.dates("pub_date", "week")\n[datetime.date(2005, 2, 14), datetime.date(2005, 3, 14)]\n>>> Entry.objects.dates("pub_date", "day")\n[datetime.date(2005, 2, 20), datetime.date(2005, 3, 20)]\n>>> Entry.objects.dates("pub_date", "day", order="DESC")\n[datetime.date(2005, 3, 20), datetime.date(2005, 2, 20)]\n>>> Entry.objects.filter(headline__contains="Lennon").dates("pub_date", "day")\n[datetime.date(2005, 3, 20)]\ndatetimes()Link to this heading#返回一个 QuerySet，它的值是一个 datetime.datetime 对象的列表，代表 QuerySet 内容中所有可用的特定日期。
field_name 应该是你的模型中 DateTimeField 的名称。
kind 应该是 "year"、"month"、"week"、"day"、"hour"、"minute" 或 "second"。结果列表中的每个 datetime.datetime 对象都被“截断”为给定的 type。
order，默认为 'ASC'，应该是 'ASC' 或 'DESC'。这指定了如何对结果进行排序。
tzinfo 定义了在截断之前将日期时间转换为的时区。事实上，一个给定的日期时间根据使用的时区有不同的表示方式。这个参数必须是一个 datetime.tzinfo 对象。如果是 None，Django 会使用 current time zone。当 USE_TZ 为 False 时，它没有效果。
none()Link to this heading#调用 none() 将创建一个永远不会返回任何对象的查询集，在访问结果时将不执行任何查询。qs.none() 查询集是 EmptyQuerySet 的一个实例。
举例：
\n>>> Entry.objects.none()\n<QuerySet []>\n>>> from django.db.models.query import EmptyQuerySet\n>>> isinstance(Entry.objects.none(), EmptyQuerySet)\nTrue\nall()Link to this heading#Returns a copy of the current QuerySet (or QuerySet subclass). This\ncan be useful in situations where you might want to pass in either a model\nmanager or a QuerySet and do further filtering on the result. After calling\nall() on either object, you'll definitely have a QuerySet to work with.
当一个 QuerySet 被 执行 时，它通常会缓存其结果。如果数据库中的数据可能在 QuerySet 被评估后发生了变化，你可以通过调用 all() 对以前执行过的 QuerySet 进行更新。
union()Link to this heading#使用 SQL 的 UNION 操作符来组合两个或多个 QuerySet 的结果。例如：
>>> qs1.union(qs2, qs3)\nUNION 操作符默认只选择不同的值。要允许重复的值，使用 all=True 参数。
union(), intersection(), 和 difference() 返回第一个 QuerySet 类型的模型实例，即使参数是其他模型的 QuerySet。只要所有 QuerySet 中的 SELECT 列表相同（至少类型相同，名称不重要，只要类型的顺序相同），就可以传递不同的模型。在这种情况下，必须在应用于结果 QuerySet 的 QuerySet 方法中使用来自第一个 QuerySet 的列名。例如：
>>> qs1 = Author.objects.values_list("name")\n>>> qs2 = Entry.objects.values_list("headline")\n>>> qs1.union(qs2).order_by("name")\nIn addition, only LIMIT, OFFSET, COUNT(*), ORDER BY, and\nspecifying columns (i.e. slicing, count(), exists(),\norder_by(), and values()/values_list()) are allowed\non the resulting QuerySet. Further, databases place restrictions on\nwhat operations are allowed in the combined queries. For example, most\ndatabases don't allow LIMIT or OFFSET in the combined queries.
intersection()Link to this heading#使用 SQL 的 INTERSECT 操作符来返回两个或多个 QuerySet 的共享元素。例如：
>>> qs1.intersection(qs2, qs3)\n一些限制见 union()。
difference()Link to this heading#使用 SQL 的 EXCEPT 运算符，只保留在一个 QuerySet 中存在而在其他某些 QuerySet 中不存在的元素。例如：
>>> qs1.difference(qs2, qs3)\n一些限制见 union()。
fetch_mode()Link to this heading#Returns a QuerySet that sets the given fetch mode for all model instances\ncreated by this QuerySet. The fetch mode controls on-demand loading of\nfields when they are accessed, such as for foreign keys and deferred fields.\nFor example, to use the FETCH_PEERS mode to\nbatch-load all related objects on first access:
from django.db import models\n\nbooks = Book.objects.fetch_mode(models.FETCH_PEERS)\nSee more in the fetch mode topic guide.
\nextra()Link to this heading#有时候，Django 查询语法本身并不能很容易地表达一个复杂的 WHERE 子句。对于这些边缘情况，Django 提供了 extra() QuerySet 修饰符——用于将特定的子句注入到由 QuerySet 生成的 SQL 中。
根据定义，这些额外的查找可能无法移植到不同的数据库引擎中（因为你明确地编写了 SQL 代码），并且违反了 DRY 原则，所以你应该尽可能地避免它们。
\n指定 params、select、where 或 tables 中的一个或多个参数。这些参数都不是必须的，但你应该至少使用其中的一个。
select
The select argument lets you put extra fields in the SELECT\nclause. It should be a dictionary mapping attribute names to SQL\nclauses to use to calculate that attribute.
举例：
\nEntry.objects.extra(select={"is_recent": "pub_date > '2006-01-01'"})\n因此，每个 Entry 对象将有一个额外的属性，is_recent，一个布尔值，表示该条目的 pub_date 是否大于 2006 年 1 月 1 日。
Django 将给定的 SQL 片段直接插入到 SELECT 语句中，所以上面例子的 SQL 结果将是这样的。
SELECT blog_entry.*, (pub_date > '2006-01-01') AS is_recent\nFROM blog_entry;\n下一个例子更高级；它做了一个子查询，给每个结果的 Blog 对象一个 entry_count 属性，一个相关 Entry 对象的整数：
Blog.objects.extra(\n select={\n "entry_count": "SELECT COUNT(*) FROM blog_entry WHERE blog_entry.blog_id = blog_blog.id"\n },\n)\n在这个特殊的情况下，我们利用了这样一个事实，即查询在其 FROM 子句中已经包含 blog_blog 表。
上述例子的 SQL 结果是：
\nSELECT blog_blog.*, (SELECT COUNT(*) FROM blog_entry WHERE blog_entry.blog_id = blog_blog.id) AS entry_count\nFROM blog_blog;\n请注意，Django 的 select 子句中不需要大多数数据库引擎在子查询周围所需的括号。
在一些罕见的情况下，你可能希望在 extra(select=...) 中给 SQL 片段传递参数。为此，使用 select_params 参数。
这样做就可以了，比如：
\nBlog.objects.extra(\n select={"a": "%s", "b": "%s"},\n select_params=("one", "two"),\n)\n如果你需要在选择字符串中使用 %s，请使用序列 %%s。
where／tables
你可以通过使用 where 来定义明确的 SQL WHERE 子句——也许是为了执行非明确的连接。你可以通过使用 tables 手动添加表到 SQL FROM 子句中。
where 和 tables 都采用一个字符串列表。所有 where 参数都与任何其他搜索标准“AND”在一起。
举例：
\nEntry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])\n...翻译成（大致）下面的 SQL：
\nSELECT * FROM blog_entry WHERE (foo='a' OR bar='a') AND (baz='a')\n如果使用 tables 参数时，要注意指定查询中已经使用过的表，当你通过 tables 参数添加额外的表时，Django 会认为你希望额外包含该表，如果已经包含的话。当你通过 tables 参数添加额外的表时，Django 会认为你希望额外地包含该表，如果它已经被包含了。这就会产生一个问题，因为表名会被赋予一个别名。如果一个表在一条 SQL 语句中多次出现，那么第二次和后续的表必须使用别名，这样数据库才能区分它们。如果你指的是你在额外的 where 参数中添加的额外表，这就会造成错误。
一般情况下，你只会添加查询中还没有出现的额外表。但是，如果确实出现了上面概述的情况，有几种解决办法。首先，看看是否可以不包含额外的表，而使用已经在查询中出现的表。如果不可能的话，把你的 extra() 调用放在查询集构造的前面，这样你的表就是那个表的第一次使用。最后，如果所有其他方法都失败了，看一下产生的查询，重写你的 where 加法，使用给你的额外表的别名。每次以同样的方式构造查询集时，别名都会是一样的，所以你可以信赖别名不会改变。
order_by
If you need to order the resulting queryset using some of the new\nfields or tables you have included via extra() use the order_by\nparameter to extra() and pass in a sequence of strings. These\nstrings should either be model fields (as in the normal\norder_by() method on querysets), of the form\ntable_name.column_name or an alias for a column that you specified\nin the select parameter to extra().
例子：
\nq = Entry.objects.extra(select={"is_recent": "pub_date > '2006-01-01'"})\nq = q.extra(order_by=["-is_recent"])\n这将把 is_recent 为真的所有项目排在结果集的前面（True 按降序排列在 False 之前）。
顺便说一下，这表明你可以多次调用 extra()，它将按照你的期望行事（每次增加新的约束）。
params
上面描述的 where 参数可以使用标准的 Python 数据库字符串占位符——'%s' 来表示数据库引擎应该自动引用的参数。params 参数是一个要被替换的额外参数的列表。
举例：
\nEntry.objects.extra(where=["headline=%s"], params=["Lennon"])\n始终使用 params 而不是直接将值嵌入 where，因为 params 将确保根据你的特定后台正确引用值。例如，引号将被正确转义。
不好的：
\nEntry.objects.extra(where=["headline='Lennon'"])\n正确的：
\nEntry.objects.extra(where=["headline=%s"], params=["Lennon"])\ndefer()Link to this heading#在一些复杂的数据建模情况下，你的模型可能包含很多字段，其中一些字段可能包含很多数据（例如，文本字段），或者需要昂贵的处理来将它们转换为 Python 对象。如果你在某些情况下使用查询集的结果，在最初获取数据时不知道是否需要这些特定的字段，你可以告诉 Django 不要从数据库中检索这些字段。
\n通过将不加载的字段名称传递给 defer()：
Entry.objects.defer("headline", "body")\n一个有递延字段的查询集仍然会返回模型实例。如果你访问每个递延字段，将从数据库中检索该字段（一次一个，而不是同时访问所有的递延字段）。
\n\n你可以多次调用 defer()。每次调用都会在推迟的集合中增加新的字段：
# Defers both the body and headline fields.\nEntry.objects.defer("body").filter(rating=5).defer("headline")\n字段被添加到递延集的顺序并不重要。用已经被递延的字段名调用 defer() 是无害的（该字段仍将被递延）。
You can defer loading of fields in related models (if the related models are\nloading via select_related()) by using the standard double-underscore\nnotation to separate related fields:
Blog.objects.select_related().defer("entry__headline", "entry__body")\n如果你想清除一组递延字段，将 None 作为参数传递给 defer()：
# Load all fields immediately.\nmy_queryset.defer(None)\nSome fields in a model won't be deferred, even if you ask for them. You can\nnever defer the loading of the primary key. If you are using\nselect_related() to retrieve related models, you shouldn't defer the\nloading of the field that connects from the primary model to the related\none, doing so will result in an error.
Similarly, calling defer() (or its counterpart only()) including an\nargument from an aggregation (e.g. using the result of annotate())\ndoesn't make sense: doing so will raise an exception. The aggregated values\nwill always be fetched into the resulting queryset.
only()Link to this heading#only() 方法实际上是 defer() 的相反。只有传递到此方法中的字段，并且尚未指定为延迟加载的字段，在查询集评估时会立即加载。
如果你有一个几乎所有字段都需要延迟加载的模型，使用 only() 来指定补充的字段集合可以简化代码。
假设你有一个模型，其字段为 name、age 和 biography。就递延字段而言，以下两个查询集是相同的：
Person.objects.defer("age", "biography")\nPerson.objects.only("name")\n每当你调用 only() 时，它就会 替换 要立即加载的字段集。该方法的名称是记号式的：仅 那些字段被立即加载；其余的字段被推迟。因此，连续调用 only() 的结果是只考虑最后的字段：
# This will defer all fields except the headline.\nEntry.objects.only("body", "rating").only("headline")\n由于 defer() 以递增的方式行事（将字段添加到递延列表中），你可以将对 only() 和 defer() 的调用结合起来，事情就会符合逻辑：
# Final result is that everything except "headline" is deferred.\nEntry.objects.only("headline", "body").defer("body")\n\n# Final result loads headline immediately.\nEntry.objects.defer("body").only("headline", "body")\ndefer() 文档注释中的所有注意事项也适用于 only()。谨慎使用，只有在用尽其他选项后才能使用。
使用 only() 并省略使用 select_related() 请求的字段也是错误的。另一方面，如果在没有任何参数的情况下调用 only()，将返回查询集提取的每个字段（包括注释）。
与 defer() 一样，你不能从异步代码中访问未加载的字段并期望它们加载。相反，你将得到一个 SynchronousOnlyOperation 异常。确保你可能访问的所有字段都在你的 only() 调用中。
using()Link to this heading#This method is for controlling which database the QuerySet will be\nevaluated against if you are using more than one database. The only argument\nthis method takes is the alias of a database, as defined in\nDATABASES.
例如：
\n# queries the database with the 'default' alias.\n>>> Entry.objects.all()\n\n# queries the database with the 'backup' alias\n>>> Entry.objects.using("backup")\nselect_for_update()Link to this heading#返回一个查询集，该查询集将锁定行直到事务结束，从而在受支持的数据库上生成 SELECT ... FOR UPDATE SQL 语句。
例子：
\nfrom django.db import transaction\n\nentries = Entry.objects.select_for_update().filter(author=request.user)\nwith transaction.atomic():\n for entry in entries:\n ...\n当查询集被执行时（这里是 for entry in entries），所有匹配的条目将被锁定，直到事务块结束，这意味着其他事务将被阻止改变或获取它们的锁。
通常情况下，如果另一个事务已经获得了所选行的锁，那么查询将被阻塞，直到锁被释放。如果这不是你想要的行为，调用 select_for_update(nowait=True)。这将使调用非阻塞。如果一个冲突的锁已经被另一个事务获取，那么当查询集被评估时，将引发 DatabaseError。你也可以通过使用 select_for_update( skip_locked=True) 来忽略锁定的记录。nowait 和 skip_locked 是相互排斥的，在启用这两个选项的情况下调用 select_for_update() 会导致一个 ValueError。
默认情况下，select_for_update() 锁定所有被查询选择的行。例如，在 select_related() 中指定的相关对象的行，除了查询集模型的行之外，也会被锁定。如果不希望这样，可以在 select_for_update(of=(...)) 中使用与 select_related() 相同的字段语法指定你要锁定的相关对象。使用 'self' 来表示查询集的模型。
仅在 PostgreSQL 上，你可以通过 no_key=True 来获得一个较弱的锁，这仍然允许在锁存在的情况下，创建仅仅引用锁定的行（例如，通过外键）。PostgreSQL 文档中有更多关于 行级锁模式的细节 。
你不能在可空关联上使用 select_for_update()：
>>> Person.objects.select_related("hometown").select_for_update()\nTraceback (most recent call last):\n...\ndjango.db.utils.NotSupportedError: FOR UPDATE cannot be applied to the nullable side of an outer join\n为了避免这个限制，如果你不关心空对象，可以将它们排除在外：
\n>>> Person.objects.select_related("hometown").select_for_update().exclude(hometown=None)\n<QuerySet [<Person: ...>, ...]>\nThe postgresql, oracle, and mysql database backends support\nselect_for_update(). However, MariaDB only supports the nowait and\nskip_locked arguments, and MySQL supports the nowait, skip_locked,\nand of arguments. The no_key argument is only supported on PostgreSQL.
在使用不支持这些选项的数据库后端（如 MySQL）向 select_for_update()``传递 ``nowait=True、skip_locked=True、no_key=True 或 of，会产生一个 NotSupportedError。这可以防止代码意外地阻塞。
在支持 SELECT ... FOR UPDATE 的后端上，用 select_for_update() 在自动提交模式下执行一个查询集是一个 TransactionManagementError 错误，因为在这种情况下行没有被锁定。如果允许这样做，这将促进数据损坏，并且很容易通过调用期望在一个事务之外的事务中运行的代码而引起。
在不支持 SELECT ... FOR UPDATE 的后端（比如 SQLite）使用 select_for_update() 不会有任何影响。SELECT ... FOR UPDATE 不会被添加到查询中，如果 select_for_update() 在自动提交模式下使用，也不会出现错误。
raw()Link to this heading#获取一个原始 SQL 查询，执行它，并返回一个 django.db.models.query.RawQuerySet 实例。这个 RawQuerySet 实例可以像普通的 QuerySet 一样进行迭代，提供对象实例。
更多信息请参见 执行原生 SQL 查询。
\n\nQuerySet 的操作符Link to this heading#组合的查询集必须使用相同的模型。
\n&）Link to this heading#使用 SQL 的 AND 运算符以类似于链接过滤器的方式合并两个 QuerySet。
以下的都是相同的：
\nModel.objects.filter(x=1) & Model.objects.filter(y=2)\nModel.objects.filter(x=1).filter(y=2)\nSQL 等价于：
\nSELECT ... WHERE x=1 AND y=2\n|）Link to this heading#使用 SQL OR 操作符将两个 QuerySet 组合起来。
以下的都是相同的：
\nModel.objects.filter(x=1) | Model.objects.filter(y=2)\nfrom django.db.models import Q\n\nModel.objects.filter(Q(x=1) | Q(y=2))\nSQL 等价于：
\nSELECT ... WHERE x=1 OR y=2\n| 不是一个换元运算，因为可能会产生不同的（虽然是等价的）查询。
^)Link to this heading#使用 SQL 的 XOR 运算符合并两个 QuerySet。XOR 表达式匹配由奇数个操作数匹配的行。
以下的都是相同的：
\nModel.objects.filter(x=1) ^ Model.objects.filter(y=2)\nfrom django.db.models import Q\n\nModel.objects.filter(Q(x=1) ^ Q(y=2))\nSQL 等价于：
\nSELECT ... WHERE x=1 XOR y=2\nQuerySet 的方法Link to this heading#以下 QuerySet 方法执行 QuerySet，并返回 QuerySet 以外的东西。
这些方法不使用缓存（参见 缓存和 QuerySet）。相反，它们每次被调用时都会查询数据库。
\n因为这些方法评估了 QuerySet，它们是阻塞调用，因此它们的主要（同步）版本不能从异步代码中调用。因此，每个方法都有一个带有 a 前缀的相应异步版本 - 例如，你可以使用 await aget(…) 而不是 get(…)。
通常，除了它们的异步性质之外，它们的行为没有太大区别，但任何差异都在下面的方法旁边进行了说明。
\nget()Link to this heading#异步版本: aget()
返回与给定的查找参数相匹配的对象，其格式应该在 Field lookups 中描述。你应该使用保证唯一的查询，比如主键或唯一约束中的字段。例如：
\nEntry.objects.get(id=1)\nEntry.objects.get(Q(blog=blog) & Q(entry_number=1))\n如果你希望一个查询集已经返回一条记录，你可以在没有任何参数的情况下使用 get() 来返回该行的对象：
Entry.objects.filter(pk=1).get()\n如果 get() 没有找到任何对象，它会引发一个 Model.DoesNotExist 异常：
Entry.objects.get(id=-999) # raises Entry.DoesNotExist\n如果 get() 发现多个对象，会引发一个 Model.MultipleObjectsReturned 异常：
Entry.objects.get(name="A Duplicated Name") # raises Entry.MultipleObjectsReturned\n这两个异常类都是模型类的属性，并且特定于该模型。如果你想对不同模型的多个 get() 调用处理这样的异常，可以使用它们的通用基类。例如，你可以使用 django.core.exceptions.ObjectDoesNotExist 来处理 DoesNotExist 来自多个模型的异常：
from django.core.exceptions import ObjectDoesNotExist\n\ntry:\n blog = Blog.objects.get(id=1)\n entry = Entry.objects.get(blog=blog, entry_number=1)\nexcept ObjectDoesNotExist:\n print("Either the blog or entry doesn't exist.")\ncreate()Link to this heading#异步版本: acreate()
A convenience method for creating an object and saving it all in one step.\nThus:
\np = Person.objects.create(first_name="Bruce", last_name="Springsteen")\n和：
\np = Person(first_name="Bruce", last_name="Springsteen")\np.save(force_insert=True)\n是等效的。
\nforce_insert 参数在其他地方有说明，但它的意思是总是会创建一个新的对象。通常情况下，你不需要担心这个问题。但是，如果你的模型中包含了一个你设置的手动主键值，而且如果这个值已经存在于数据库中，那么对 create() 的调用就会以一个 IntegrityError 失败，因为主键必须是唯一的。如果使用手动主键，要做好处理异常的准备。
get_or_create()Link to this heading#异步版本: aget_or_create()
一个方便的方法，用于查找具有给定 kwargs 的对象（如果你的模型对所有字段都有默认值，则可能为空），必要时创建一个对象。
返回 (object, created) 的元组，其中 object 是检索或创建的对象，created 是指定是否创建新对象的布尔值。
这是为了防止在并行进行请求时创建重复的对象，并作为样板代码的快捷方式。 例如：
\ntry:\n obj = Person.objects.get(first_name="John", last_name="Lennon")\nexcept Person.DoesNotExist:\n obj = Person(first_name="John", last_name="Lennon", birthday=date(1940, 10, 9))\n obj.save()\n在这里，如果是并发请求，可能会多次尝试用相同的参数保存一个 Person。为了避免这种竞争条件，可以使用 get_or_create() 重写上面的例子，比如：
obj, created = Person.objects.get_or_create(\n first_name="John",\n last_name="Lennon",\n defaults={"birthday": date(1940, 10, 9)},\n)\nAny keyword arguments passed to get_or_create() — except an optional one\ncalled defaults — will be used in a get() call. If an object is\nfound, get_or_create() returns a tuple of that object and False.
You can specify more complex conditions for the retrieved object by chaining\nget_or_create() with filter() and using Q() 对象. For example,\nto retrieve Robert or Bob Marley if either exists, and create the latter\notherwise:
from django.db.models import Q\n\nobj, created = Person.objects.filter(\n Q(first_name="Bob") | Q(first_name="Robert"),\n).get_or_create(last_name="Marley", defaults={"first_name": "Bob"})\n如果找到多个对象，get_or_create() 会引发 MultipleObjectsReturned。如果没有找到对象，get_or_create() 将实例化并保存一个新对象，返回一个新对象的元组和 True。新对象将大致按照以下算法创建：
params = {k: v for k, v in kwargs.items() if "__" not in k}\nparams.update({k: v() if callable(v) else v for k, v in defaults.items()})\nobj = self.model(**params)\nobj.save()\n在英语中，这意味着从任何不包含双下划线的非 'defaults' 关键字参数开始（这将表明一个非精确的查找）。然后添加 defaults 的内容，必要时覆盖任何键，并将结果作为模型类的关键字参数。如果 defaults 中存在任何可调用对象，则对其进行评估。正如上面所提示的，这是对所使用算法的简化，但它包含了所有相关的细节。内部实现有比这更多的错误检查，并处理一些额外的边缘条件；如果你感兴趣，请阅读代码。
如果你有一个名为 defaults 的字段，并且想在 get_or_create() 中使用它作为精确查询，使用 'defaults__exact'，像这样：
Foo.objects.get_or_create(defaults__exact="bar", defaults={"defaults": "baz"})\nThe get_or_create() method has similar error behavior to create()\nwhen you're using manually specified primary keys. If an object needs to be\ncreated and the key already exists in the database, an\nIntegrityError will be raised.
最后，关于在 Django 视图中使用 get_or_create() 的一些建议。请确保只在 POST 请求中使用它，除非你有充分的理由不这样做。GET 请求不应该对数据产生任何影响。相反，只有当对页面的请求对数据产生副作用时，才使用 POST。有关更多信息，请参阅 HTTP 规范中的 Safe methods。
update_or_create()Link to this heading#异步版本: aupdate_or_create()
一个方便的方法，用于使用给定的 kwargs 更新对象，如果需要的话创建一个新对象。create_defaults 和 defaults 都是 (字段, 值) 对的字典。create_defaults 和 defaults 中的值可以是可调用的。defaults 用于更新对象，而 create_defaults 用于创建操作。如果未提供 create_defaults，则将使用 defaults 进行创建操作。
返回 (object, created) 的元组，其中 object 是创建或更新的对象，created 是一个布尔值，指定是否创建了一个新对象。
update_or_create 方法根据给定的 kwargs 尝试从数据库中获取一个对象。如果找到了匹配的对象，它就会更新 defaults 字典中传递的字段。
这是作为一个快捷方式来处理样板代码。例如：
\ndefaults = {"first_name": "Bob"}\ncreate_defaults = {"first_name": "Bob", "birthday": date(1940, 10, 9)}\ntry:\n obj = Person.objects.get(first_name="John", last_name="Lennon")\n for key, value in defaults.items():\n setattr(obj, key, value)\n obj.save()\nexcept Person.DoesNotExist:\n new_values = {"first_name": "John", "last_name": "Lennon"}\n new_values.update(create_defaults)\n obj = Person(**new_values)\n obj.save()\n当模型中的字段数量增加时，这种模式就会变得很笨重。上面的例子可以使用 update_or_create() 重写，就像这样：
obj, created = Person.objects.update_or_create(\n first_name="John",\n last_name="Lennon",\n defaults={"first_name": "Bob"},\n create_defaults={"first_name": "Bob", "birthday": date(1940, 10, 9)},\n)\n关于如何解决在 kwargs 中传递名字的详细描述，见 get_or_create()。
如上文 get_or_create() 中所述，这种方法容易出现竞争条件，如果不在数据库层面强制执行唯一性，就会导致同时插入多条记录。
就像 get_or_create() 和 create() 一样，如果你使用的是手动指定的主键，需要创建一个对象，但该键已经存在于数据库中，就会引发 IntegrityError。
bulk_create()Link to this heading#异步版本: abulk_create()
这个方法以高效的方式将提供的对象列表插入数据库中（通常只有 1 个查询，无论有多少对象），并以与提供的顺序相同的顺序返回已创建的对象列表：
\n>>> objs = Entry.objects.bulk_create(\n... [\n... Entry(headline="This is a test"),\n... Entry(headline="This is only a test"),\n... ]\n... )\n不过这有一些注意事项：
\nThe model's save() method will not be called, and the pre_save and\npost_save signals will not be sent.
在多表继承的情况下，它不能与子模型一起工作。
If the model's primary key is an AutoField or has\na db_default value, and ignore_conflicts\nis False, the primary key attribute can only be retrieved on certain\ndatabases (currently PostgreSQL, MariaDB, and SQLite). On other databases, it\nwill not be set.
对于多对多的关系，它是行不通的。
它将 objs 转换为一个列表，如果 objs 是一个生成器，则完全执行 objs。这种转换允许检查所有对象，因此任何具有手动设置主键的对象都可以首先插入。如果你想分批插入对象，而不一次性执行整个生成器，你可以使用这种技术，只要对象没有任何手动设置的主键：
from itertools import islice\n\nbatch_size = 100\nobjs = (Entry(headline="Test %s" % i) for i in range(1000))\nwhile True:\n batch = list(islice(objs, batch_size))\n if not batch:\n break\n Entry.objects.bulk_create(batch, batch_size)\nThe batch_size parameter controls how many objects are created in a single\nquery. The default is to create as many objects in one batch as the database\nwill allow. (SQLite and Oracle limit the number of parameters in a query.)
在支持的数据库上（除了 Oracle），将 ignore_conflicts 参数设置为 True 告诉数据库忽略插入失败的行，例如违反唯一值约束的行。
在支持它的数据库上（除了 Oracle），将 update_conflicts 参数设置为 True，告诉数据库在冲突时更新 update_fields。在 PostgreSQL 和 SQLite 上，除了 update_fields，还必须提供可能冲突的 unique_fields 列表。
启用 ignore_conflicts 参数会禁用在每个模型实例上设置主键（如果数据库通常支持它）。
bulk_update()Link to this heading#异步版本: abulk_update()
这个方法高效地更新提供的模型实例上的给定字段，通常只需一个查询，并返回更新的对象数量：
\n>>> objs = [\n... Entry.objects.create(headline="Entry 1"),\n... Entry.objects.create(headline="Entry 2"),\n... ]\n>>> objs[0].headline = "This is entry 1"\n>>> objs[1].headline = "This is entry 2"\n>>> Entry.objects.bulk_update(objs, ["headline"])\n2\nQuerySet.update() 用于保存更改，所以这比遍历模型列表并对每个模型调用 save() 更有效，但它有一些注意事项：
你不能更新模型的主键。
Each model's save() method isn't called, and the\npre_save and\npost_save signals aren't sent.
如果更新大量行中的大量列，生成的 SQL 可能非常大。通过指定一个合适的 batch_size 来避免这种情况。
When updating a large number of objects, be aware that bulk_update()\nprepares all of the WHEN clauses for every object across all batches\nbefore executing any queries. This can require more memory than expected. To\nreduce memory usage, you can use an approach like this:
from itertools import islice\n\nbatch_size = 100\nids_iter = iter(range(1000))\nwhile ids := list(islice(ids_iter, batch_size)):\n batch = Entry.objects.filter(id__in=ids)\n for entry in batch:\n entry.headline = f"Updated headline {entry.pk}"\n Entry.objects.bulk_update(batch, ["headline"], batch_size=batch_size)\n更新定义在多表继承祖先上的字段将给每个祖先带来额外的查询。
当一个单独的批次包含重复的内容时，只有该批次的第一个实例会导致更新。
该函数返回的更新对象的数量可能少于传入的对象的数量。这可能是由于传入的对象重复，在同一批次中被更新，或者是竞赛条件，如对象在数据库中不再存在。
batch_size 参数控制一次查询中保存多少对象。默认值是在一个批次中更新所有对象，但 SQLite 和 Oracle 除外，它们对查询中使用的变量数量有限制。
count()Link to this heading#异步版本: acount()
返回一个整数，表示数据库中与 QuerySet 匹配的对象数量。
举例：
\n# Returns the total number of entries in the database.\nEntry.objects.count()\n\n# Returns the number of entries whose headline contains 'Lennon'\nEntry.objects.filter(headline__contains="Lennon").count()\ncount() 调用在幕后执行 SELECT COUNT(*)，所以你应该总是使用 count() 而不是将所有的记录加载到 Python 对象中，然后在结果上调用 len() （除非你需要将对象加载到内存中，在这种情况下 len() 会更快）。
请注意，如果你想知道 QuerySet 中的项数，并且也要从它中检索模型实例（例如，通过迭代它），那么使用 len(queryset) 可能更有效，因为它不会像 count() 那样引起额外的数据库查询。
如果查询集已经被完全检索到，count() 将使用该长度，而不是执行额外的数据库查询。
in_bulk()Link to this heading#异步版本: ain_bulk()
接收一个字段值的列表（id_list）和这些值的 field_name，并返回一个字典，将每个值映射到具有给定字段值的对象实例。in_bulk 不会引发任何 django.core.exceptions.ObjectDoesNotExist 异常；也就是说，任何不匹配任何实例的 id_list 值将被简单地忽略掉。如果没有提供 id_list，将返回查询集的所有对象。field_name 必须是一个唯一字段或一个独立的字段（如果只有一个字段在 distinct() 中指定）。field_name 默认为主键。
例如：
\n>>> Blog.objects.in_bulk([1])\n{1: <Blog: Beatles Blog>}\n>>> Blog.objects.in_bulk([1, 2])\n{1: <Blog: Beatles Blog>, 2: <Blog: Cheddar Talk>}\n>>> Blog.objects.in_bulk([])\n{}\n>>> Blog.objects.in_bulk()\n{1: <Blog: Beatles Blog>, 2: <Blog: Cheddar Talk>, 3: <Blog: Django Weblog>}\n>>> Blog.objects.in_bulk(["beatles_blog"], field_name="slug")\n{'beatles_blog': <Blog: Beatles Blog>}\n>>> Blog.objects.distinct("name").in_bulk(field_name="name")\n{'Beatles Blog': <Blog: Beatles Blog>, 'Cheddar Talk': <Blog: Cheddar Talk>, 'Django Weblog': <Blog: Django Weblog>}\n如果你传递 in_bulk() 一个空列表，你将得到一个空字典。
iterator()Link to this heading#异步版本: aiterator()
Evaluates the QuerySet (by performing the query) and returns an\niterator over the results, or an asynchronous\niterator if you call its asynchronous version aiterator.
A QuerySet typically caches its results internally so that repeated\nevaluations do not result in additional queries. In contrast, iterator()\nwill read results directly, without doing any caching at the QuerySet\nlevel. For a QuerySet which returns a large number of objects that you\nonly need to access once, this can result in better performance and a\nsignificant reduction in memory.
请注意，在已经被执行的 QuerySet 上使用 iterator() 会迫使它再次执行，重复查询。
iterator() 与之前对 prefetch_related() 的调用兼容，只要提供了 chunk_size。较大的值将需要更少的查询来完成预取操作，但代价是更多的内存使用。
在某些数据库（例如 Oracle，SQLite）中，SQL 中的 IN 子句中的最大项数可能会受到限制。因此，应使用低于此限制的值。特别是在跨两个或多个关系进行预取的情况下，chunk_size 应该足够小，以便每个预取关系的预期结果数量仍然保持在限制以下。
只要 QuerySet 不预取任何相关对象，不为 chunk_size 提供值，Django 将使用默认的隐式值 2000。
根据数据库后端，查询结果将被一次性加载或使用服务器端的游标从数据库中流转。
\nOracle 和 PostgreSQL 使用服务器端的游标从数据库流式传输结果，而不需要将整个结果集加载到内存中。
\nOracle 数据库驱动程序总是使用服务器端的游标。
\n对于服务器端的游标，chunk_size 参数指定了要在数据库驱动层缓存的结果数量。获取更大的块数会减少数据库驱动和数据库之间的往返次数，但会牺牲内存。
在 PostgreSQL 上，只有当 DISABLE_SERVER_SIDE_CURSORS 设置为 False 时，才会使用服务器端游标。如果你使用的是配置在事务池模式下的连接池器，请阅读 事务池和服务器端游标。当禁用服务器端游标时，其行为与不支持服务器端游标的数据库相同。
MySQL 不支持流式结果，因此 Python 数据库驱动将整个结果集加载到内存中。然后数据库适配器使用 PEP 249 中定义的 fetchmany() 方法将结果集转化为 Python 行对象。
SQLite 可以使用 fetchmany() 分批获取结果，但由于 SQLite 不提供连接内查询之间的隔离，所以在向被迭代的表写入时要小心。参见 使用 QuerySet.iterator() 时的隔离 了解更多信息。
chunk_size 参数控制 Django 从数据库驱动中获取的批次大小。批量越大，就会减少与数据库驱动通信的开销，但代价是略微增加内存消耗。
只要查询集不预取任何相关对象，不提供 chunk_size 的值将导致 Django 使用隐式默认值 2000，这个值是从 psycopg 邮件列表上的计算 推导出的。
\n\n假设行数为 10-20 列，文字数据和数字数据混合，2000 要取不到 100KB 的数据，这似乎是一个很好的折中方案，在传输的行数和提前退出循环时丢弃的数据之间。
\n
latest()Link to this heading#异步版本: alatest()
根据给定的字段，返回表中最新的对象。
\n这个例子根据 pub_date 字段返回表中最新的 Entry：
Entry.objects.latest("pub_date")\n你也可以根据几个字段选择最新的。例如，当两个条目具有相同的 pub_date 时，要选择最早的 expire_date 条目：
Entry.objects.latest("pub_date", "-expire_date")\n'-expire_date' 中的负号表示按 降 序排列 expire_date。由于 latest() 得到的是最后一个结果，所以选择了最早的 expire_date 的 Entry。
如果你模型的 Meta 指定了 get_latest_by，你可以省略 earliest() 或 latest() 的任何参数。get_latest_by 中指定的字段将被默认使用。
Like get(), earliest() and latest() raise\nDoesNotExist if there is no object with the\ngiven parameters.
请注意，earliest() 和 latest() 的存在纯粹是为了方便和可读性。
earliest()Link to this heading#异步版本: aearliest()
除了方向改变外，其他工作方式都像 last()。
first()Link to this heading#异步版本: afirst()
Returns the first object matched by the queryset, or None if there\nis no matching object. If the QuerySet has no ordering defined (and has not\nhad ordering forcibly cleared by calling order_by() with no arguments),\nthen the queryset is automatically ordered by the primary key. This can affect\naggregation results as described in Interaction with order_by().
举例：
\np = Article.objects.order_by("title", "pub_date").first()\n请注意，first() 是一个方便的方法，下面的代码示例相当于上面的例子：
try:\n p = Article.objects.order_by("title", "pub_date")[0]\nexcept IndexError:\n p = None\nlast()Link to this heading#异步版本: alast()
Works like first(), but returns the last object in the queryset.
aggregate()Link to this heading#异步版本: aaggregate()
返回对 QuerySet 计算的聚合值（平均值、总和等）的字典。aggregate() 的每个参数都指定了一个将被包含在返回的字典中的值。
Django 提供的聚合函数在下面的 Aggregation Functions 中介绍。由于聚合函数也是 查询表达式，所以你可以将聚合函数与其他聚合函数或值结合起来，创建复杂的聚合函数。
\n使用关键字参数指定的聚合将使用关键字作为注解的名称。匿名参数将根据聚合函数的名称和被聚合的模型字段为其生成一个名称。复杂的聚合不能使用匿名参数，必须指定一个关键字参数作为别名。
\n例如，当你处理博客条目时，你可能想要知道有多少位作者贡献了博客条目：
\n>>> from django.db.models import Count\n>>> Blog.objects.aggregate(Count("entry__authors"))\n{'entry__authors__count': 16}\n通过使用关键字参数来指定聚合函数，你可以控制返回的聚合值的名称：
\n>>> Blog.objects.aggregate(number_of_authors=Count("entry__authors"))\n{'number_of_authors': 16}\n关于聚合的深入讨论，见 关于聚合的专题指南。
\nexists()Link to this heading#异步版本: aexists()
如果 QuerySet 包含任何结果，则返回 True，如果不包含，则返回 False。该函数试图以最简单、最快速的方式执行查询，但它 执行 的查询与普通的 QuerySet 查询几乎相同。
existence() 对于与 QuerySet 中任何对象的存在有关的搜索很有用，特别是在一个大的 QuerySet 的背景下。
要查找一个查询集是否包含任何项目：
\nif some_queryset.exists():\n print("There is at least one object in some_queryset")\n这种方法比下面的方法更快：
\nif some_queryset:\n print("There is at least one object in some_queryset")\n...但程度不高（因此需要大量的查询集才能获得效率提升）。
\n此外，如果一个 some_queryset 还没有被执行，但你知道它会在某个时候被执行，那么使用 some_queryset.exences() 比使用 bool(some_queryset) 会做更多的总体工作（一个存在性检查的查询加上一个额外的查询，以便以后检索结果），后者检索结果，然后检查是否有任何返回。
contains()Link to this heading#异步版本: acontains()
如果 QuerySet 包含 obj，返回 True，如果不包含 False。这试图以最简单和最快的方式执行查询。
contains() 对于检查一个对象在 QuerySet 中的成员资格很有用，特别是在一个大的 QuerySet 的情况下。
要检查一个查询集是否包含一个特定的项目：
\nif some_queryset.contains(obj):\n print("Entry contained in queryset")\n这将比以下需要执行和迭代整个查询集的方法更快：
\nif obj in some_queryset:\n print("Entry contained in queryset")\n像 exists() 一样，如果 some_queryset 还没有被执行，但你知道它将在某个时候被执行，那么使用 some_queryset.contains(obj) 将进行额外的数据库查询，通常会导致整体性能变慢。
update()Link to this heading#异步版本: aupdate()
对指定的字段执行 SQL 更新查询，并返回匹配的行数（如果有些行已经有了新的值，则可能不等于更新的行数）。
\n例如，要关闭所有在 2010 年发布的博客条目的评论，你可以这样做：
\n>>> Entry.objects.filter(pub_date__year=2010).update(comments_on=False)\n（假定你的 Entry 模型有 pub_date 和 comments_on。）
你可以更新多个字段，没有限制。例如，这里我们更新了 comments_on 和 headline 字段：
>>> Entry.objects.filter(pub_date__year=2010).update(\n... comments_on=False, headline="This is old"\n... )\nupdate() 方法会立即应用，并且被更新的 QuerySet 的唯一限制是它只能更新模型主表中的列，不能更新相关模型上的列。例如，你不能这样做：
>>> Entry.objects.update(blog__name="foo") # Won't work!\n基于相关字段的过滤仍然是可能的：
\n>>> Entry.objects.filter(blog__id=1).update(comments_on=True)\n你不能在一个 QuerySet 上调用 update()，因为它已经被取走了一个片断或者不能再被过滤。
update() 方法返回受影响的行数：
>>> Entry.objects.filter(id=64).update(comments_on=True)\n1\n\n>>> Entry.objects.filter(slug="nonexistent-slug").update(comments_on=True)\n0\n\n>>> Entry.objects.filter(pub_date__year=2010).update(comments_on=False)\n132\n如果你只是更新一条记录，不需要对模型对象做任何事情，最有效的方法是调用 update()，而不是将模型对象加载到内存中。例如，不要这样做：
e = Entry.objects.get(id=10)\ne.comments_on = False\ne.save()\n...要这样做：
\nEntry.objects.filter(id=10).update(comments_on=False)\n使用 update() 还可以防止在加载对象和调用 save() 之间的短暂时间内数据库中的某些东西可能发生变化的竞争条件。
Finally, realize that update() does an update at the SQL level and, thus,\nmethod does not call any\nsave() methods on your models, nor does it emit the\npre_save or\npost_save signals (which are a consequence of\ncalling Model.save()). If you want to\nupdate a bunch of records for a model that has a custom\nsave() method, loop over them and call\nsave(), like this:
for e in Entry.objects.filter(pub_date__year=2010):\n e.comments_on = False\n e.save()\n将 order_by() 与 update() 串联起来，只在 MariaDB 和 MySQL 上支持，对于不同的数据库会被忽略。这对于按照指定的顺序更新一个唯一的字段是很有用的，没有冲突。例如：
Entry.objects.order_by("-number").update(number=F("number") + 1)\ndelete()Link to this heading#异步版本: adelete()
Performs an SQL delete query on all rows in the QuerySet and\nreturns the number of objects deleted and a dictionary with the number of\ndeletions per object type. The return value will count instances from related\nmodels if Django is emulating cascade behavior via Python\non_delete variants. Otherwise, for\ndatabase variants such as DB_CASCADE, the return\nvalue will report only instances of the QuerySet's model.
delete() 是即时应用的。你不能对已经被取走一个片断或不能再被过滤的 QuerySet 调用 delete()。
例如，要删除特定博客中的所有条目：
\n>>> b = Blog.objects.get(pk=1)\n\n# Delete all the entries belonging to this Blog.\n>>> Entry.objects.filter(blog=b).delete()\n(4, {'blog.Entry': 2, 'blog.Entry_authors': 2})\n默认情况下，Django 的 ForeignKey 模拟了 SQL 约束 ON DELETE CASCADE — 也就是说，任何具有外键指向将要被删除的对象的对象将会随之一起被删除。例如：
>>> blogs = Blog.objects.all()\n\n# This will delete all Blogs and all of their Entry objects.\n>>> blogs.delete()\n(5, {'blog.Blog': 1, 'blog.Entry': 2, 'blog.Entry_authors': 2})\n这种级联行为通过 ForeignKey 的 on_delete 参数定义。
The delete() method does a bulk delete and does not call any delete() methods on your\nmodels. It does, however, emit the pre_delete\nand post_delete signals for all deleted\nobjects (including cascaded deletions). Signals won't be sent when\nDB_CASCADE is used. Also, delete() doesn't return information about\nobjects deleted from database variants (DB_*) of the\non_delete argument, e.g. DB_CASCADE.
Django won’t need to fetch objects into memory when deleting them in the\nfollowing cases:
\nIf related fields use DB_* options.
If there are no cascades and no delete signal receivers.
In these cases, Django may take a fast path and delete objects without fetching\nthem, which can result in significantly reduced memory usage and fewer executed\nqueries.
\n设置为 on_delete DO_NOTHING 的外键不会阻止在删除时采取快速路径。
需要注意的是，对象删除中产生的查询是一个实现细节，可能会发生变化。
\n\nas_manager()Link to this heading#类方法，该方法返回一个 Manager 的实例，其中包含 QuerySet 的方法的副本。详见 创建带有 QuerySet 方法的管理器 。
请注意，与本节中的其他条目不同，这个条目没有异步变体，因为它不执行查询。
\nexplain()Link to this heading#异步版本: aexplain()
返回一个 QuerySet 的执行计划的字符串，它详细说明了数据库将如何执行查询，包括将使用的任何索引或联接。了解这些细节可以帮助你提高慢速查询的性能。
例如，在使用 PostgreSQL 时：
\n>>> print(Blog.objects.filter(title="My Blog").explain())\nSeq Scan on blog (cost=0.00..35.50 rows=10 width=12)\n Filter: (title = 'My Blog'::bpchar)\n不同数据库之间的输出有很大的不同。
\nexplain() 得到了所有内置数据库后端的支持，但 Oracle 除外，因为在那里的实现并不直接。
The format parameter changes the output format from the database's\ndefault, which is usually text-based. PostgreSQL supports 'TEXT',\n'JSON', 'YAML', and 'XML' formats. MariaDB and MySQL support\n'TEXT' (also called 'TRADITIONAL') and 'JSON' formats. MySQL\n8.0.16+ also supports an improved 'TREE' format, which is similar to\nPostgreSQL's 'TEXT' output and is used by default, if supported.
一些数据库接受可以返回有关查询的更多信息的标志。将这些标志作为关键字参数传递。例如，在使用 PostgreSQL 时：
\n>>> print(Blog.objects.filter(title="My Blog").explain(verbose=True, analyze=True))\nSeq Scan on public.blog (cost=0.00..35.50 rows=10 width=12) (actual time=0.004..0.004 rows=10 loops=1)\n Output: id, title\n Filter: (blog.title = 'My Blog'::bpchar)\nPlanning time: 0.064 ms\nExecution time: 0.058 ms\nOn some databases, flags may cause the query to be executed which could have\nadverse effects on your database. For example, the ANALYZE flag supported\nby MariaDB, MySQL, and PostgreSQL could result in changes to data if there are\ntriggers or if a function is called, even for a SELECT query.
Field 查找Link to this heading#Field lookups are how you specify the meat of an SQL WHERE clause. They're\nspecified as keyword arguments to the QuerySet methods filter(),\nexclude() and get().
介绍见 模型和数据库查询文档。
\nDjango 的内置查找功能如下。也可以为模型字段写 自定义查找。
\n为方便起见，当没有提供查找类型时（如 Entry.objects.get(id=14)），查找类型被假定为 exact。
exactLink to this heading#Exact match. If the value provided for comparison is None, it will be\ninterpreted as an SQL NULL (see isnull for more details).\nKey and index lookups are exceptions: they\ninterpret None as JSON null instead.
举例：
\nEntry.objects.get(id__exact=14)\nEntry.objects.get(id__exact=None)\nSQL 等价于：
\nSELECT ... WHERE id = 14;\nSELECT ... WHERE id IS NULL;\niexactLink to this heading#不区分大小写的完全匹配。如果提供的比较值是 None，它将被解释为 SQL NULL （详见 isnull）。
举例：
\nBlog.objects.get(name__iexact="beatles blog")\nBlog.objects.get(name__iexact=None)\nSQL 等价于：
\nSELECT ... WHERE name ILIKE 'beatles blog';\nSELECT ... WHERE name IS NULL;\n注意第一个查询会匹配 'Beatles Blog'、'beatles blog'、'BeAtLes BLoG' 等。
containsLink to this heading#区分大小写的包含测试。
\n举例：
\nEntry.objects.get(headline__contains="Lennon")\nSQL 等价于：
\nSELECT ... WHERE headline LIKE '%Lennon%';\n（确切的 SQL 语法因每个数据库引擎而异）。
\n请注意，这将与标题 'Lennon honored today' 相匹配，而不是 'lennon honored today'。
icontainsLink to this heading#不区分大小写的包含测试。
\n举例：
\nEntry.objects.get(headline__icontains="Lennon")\nSQL 等价于：
\nSELECT ... WHERE headline ILIKE '%Lennon%';\n（确切的 SQL 语法因每个数据库引擎而异）。
\n\ninLink to this heading#在一个给定的可迭代对象中；通常是一个列表、元组或查询集。这不是一个常见的用例，但字符串（可迭代）是可以接受的。
\n举例：
\nEntry.objects.filter(id__in=[1, 3, 4])\nEntry.objects.filter(headline__in="abc")\nSQL 等价于：
\nSELECT ... WHERE id IN (1, 3, 4);\nSELECT ... WHERE headline IN ('a', 'b', 'c');\n你也可以使用一个查询集来动态计算值列表，而不是提供一个字面值列表：
\ninner_qs = Blog.objects.filter(name__contains="Cheddar")\nentries = Entry.objects.filter(blog__in=inner_qs)\n该查询集将作为子选择语句执行：
\nSELECT ... WHERE blog.id IN (SELECT id FROM ... WHERE NAME LIKE '%Cheddar%')\n如果你把一个由 values() 或 values_list() 产生的 QuerySet 作为值传递给 __in 查找，你需要确保你只提取结果中的一个字段。例如，这样做就可以了（过滤博客名）：
inner_qs = Blog.objects.filter(name__contains="Ch").values("name")\nentries = Entry.objects.filter(blog__name__in=inner_qs)\n这个例子会引发一个异常，因为内部查询正试图提取两个字段值，而预期只有一个：
\n# Bad code! Will raise a TypeError.\ninner_qs = Blog.objects.filter(name__contains="Ch").values("name", "id")\nentries = Entry.objects.filter(blog__name__in=inner_qs)\ngtLink to this heading#大于。
\n举例：
\nEntry.objects.filter(id__gt=4)\nSQL 等价于：
\nSELECT ... WHERE id > 4;\ngteLink to this heading#大于等于。
\nltLink to this heading#小于。
\nlteLink to this heading#小于等于
\nstartswithLink to this heading#区分大小写的开头为。
\n举例：
\nEntry.objects.filter(headline__startswith="Lennon")\nSQL 等价于：
\nSELECT ... WHERE headline LIKE 'Lennon%';\n（确切的 SQL 语法因每个数据库引擎而异）。
\nSQLite 不支持区分大小写的 LIKE 语句；startswith 的作用就像 SQLite 的 istartswith。
istartswithLink to this heading#不区分大小写的开头为。
\n举例：
\nEntry.objects.filter(headline__istartswith="Lennon")\nSQL 等价于：
\nSELECT ... WHERE headline ILIKE 'Lennon%';\n（确切的 SQL 语法因每个数据库引擎而异）。
\n\nendswithLink to this heading#区分大小写的结尾为。
\n举例：
\nEntry.objects.filter(headline__endswith="Lennon")\nSQL 等价于：
\nSELECT ... WHERE headline LIKE '%Lennon';\n（确切的 SQL 语法因每个数据库引擎而异）。
\n\niendswithLink to this heading#不区分大小写的结尾为。
\n举例：
\nEntry.objects.filter(headline__iendswith="Lennon")\nSQL 等价于：
\nSELECT ... WHERE headline ILIKE '%Lennon';\n（确切的 SQL 语法因每个数据库引擎而异）。
\n\nrangeLink to this heading#范围测试（含）。
\n举例：
\nimport datetime\n\nstart_date = datetime.date(2005, 1, 1)\nend_date = datetime.date(2005, 3, 31)\nEntry.objects.filter(pub_date__range=(start_date, end_date))\nSQL 等价于：
\nSELECT ... WHERE pub_date BETWEEN '2005-01-01' and '2005-03-31';\n在 SQL 中，你可以在任何你可以使用 BETWEEN 的地方使用 range——用于日期、数字甚至字符。
dateLink to this heading#对于日期时间字段，将值投射为日期。允许链接其他字段的查找。取一个日期值。
\n举例：
\nEntry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))\nEntry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))\n（由于不同的数据库引擎对相关查询的实现各不相同，因此本次查询不包含等效的 SQL 代码片段）。
\n\nyearLink to this heading#对于日期和日期时间字段，精确匹配年份。允许链接其他字段的查询。取整数年。
\n举例：
\nEntry.objects.filter(pub_date__year=2005)\nEntry.objects.filter(pub_date__year__gte=2005)\nSQL 等价于：
\nSELECT ... WHERE pub_date BETWEEN '2005-01-01' AND '2005-12-31';\nSELECT ... WHERE pub_date >= '2005-01-01';\n（确切的 SQL 语法因每个数据库引擎而异）。
\n\niso_yearLink to this heading#对于日期和日期时间字段，精确的 ISO 8601 周号年份匹配。允许链接其他字段的查询。取整数年。
\n举例：
\nEntry.objects.filter(pub_date__iso_year=2005)\nEntry.objects.filter(pub_date__iso_year__gte=2005)\n（确切的 SQL 语法因每个数据库引擎而异）。
\n\nmonthLink to this heading#对于日期和日期时间字段，精确的月份匹配。允许链接其他字段的查询。取整数 1（1 月）到 12（12 月）。
\n举例：
\nEntry.objects.filter(pub_date__month=12)\nEntry.objects.filter(pub_date__month__gte=6)\nSQL 等价于：
\nSELECT ... WHERE EXTRACT('month' FROM pub_date) = '12';\nSELECT ... WHERE EXTRACT('month' FROM pub_date) >= '6';\n（确切的 SQL 语法因每个数据库引擎而异）。
\n\ndayLink to this heading#对于日期和日期时间字段，精确匹配日期。允许链接其他字段的查询。取整数日。
\n举例：
\nEntry.objects.filter(pub_date__day=3)\nEntry.objects.filter(pub_date__day__gte=3)\nSQL 等价于：
\nSELECT ... WHERE EXTRACT('day' FROM pub_date) = '3';\nSELECT ... WHERE EXTRACT('day' FROM pub_date) >= '3';\n（确切的 SQL 语法因每个数据库引擎而异）。
\n请注意，这将匹配任何带有 pub_date 的月份第三天的记录，如 1 月 3 日，7 月 3 日等。
\n\nweekLink to this heading#对于日期和日期时间字段，根据 ISO-8601 ，返回星期号（1-52 或 53），即星期从星期一开始，第一周包含一年的第一个星期四。
\n举例：
\nEntry.objects.filter(pub_date__week=52)\nEntry.objects.filter(pub_date__week__gte=32, pub_date__week__lte=38)\n（由于不同的数据库引擎对相关查询的实现各不相同，因此本次查询不包含等效的 SQL 代码片段）。
\n\nweek_dayLink to this heading#对于日期和日期时间字段，“星期几”匹配。允许链接其他字段的查询。
\n从 1（星期日）到 7（星期六）取一个整数值，代表一周的一天。
\n举例：
\nEntry.objects.filter(pub_date__week_day=2)\nEntry.objects.filter(pub_date__week_day__gte=2)\n（由于不同的数据库引擎对相关查询的实现各不相同，因此本次查询不包含等效的 SQL 代码片段）。
\n请注意，这将匹配任何带有 pub_date 的记录，这些记录都是在星期一（一周的第 2 天）发生的，不管它发生在哪一年哪一月。周日的索引，第 1 天是周日，第 7 天是周六。
iso_week_dayLink to this heading#对于日期和日期时间字段，精确匹配 ISO 8601 星期几。允许链接其他字段的查询。
\n取一个整数值，代表一周的 1（星期一）到 7（星期日）。
\n举例：
\nEntry.objects.filter(pub_date__iso_week_day=1)\nEntry.objects.filter(pub_date__iso_week_day__gte=1)\n（由于不同的数据库引擎对相关查询的实现各不相同，因此本次查询不包含等效的 SQL 代码片段）。
\n请注意，这将匹配任何带有 pub_date 的记录，这些记录都是在星期一（一周的第 1 天）发生的，不管它发生在哪个月或哪个年。周日的索引是第 1 天是星期一，第 7 天是星期天。
quarterLink to this heading#对于日期和日期时间字段，“一年的四分之一”匹配。允许链接额外的字段查找。取 1 到 4 之间的整数值，代表一年中的季度。
\n检索第二季度（4 月 1 日至 6 月 30 日）的条目示例：
\nEntry.objects.filter(pub_date__quarter=2)\n（由于不同的数据库引擎对相关查询的实现各不相同，因此本次查询不包含等效的 SQL 代码片段）。
\n\ntimeLink to this heading#对于日期时间字段，将其值强制转换为时间。允许链式附加字段查找。取一个 datetime.time 的值。
举例：
\nEntry.objects.filter(pub_date__time=datetime.time(14, 30))\nEntry.objects.filter(pub_date__time__range=(datetime.time(8), datetime.time(17)))\n（由于不同的数据库引擎对相关查询的实现各不相同，因此本次查询不包含等效的 SQL 代码片段）。
\n\nhourLink to this heading#对于日期时间和时间字段，精确的小时匹配。允许链式查找其他字段。取 0 到 23 之间的整数。
\n举例：
\nEvent.objects.filter(timestamp__hour=23)\nEvent.objects.filter(time__hour=5)\nEvent.objects.filter(timestamp__hour__gte=12)\nSQL 等价于：
\nSELECT ... WHERE EXTRACT('hour' FROM timestamp) = '23';\nSELECT ... WHERE EXTRACT('hour' FROM time) = '5';\nSELECT ... WHERE EXTRACT('hour' FROM timestamp) >= '12';\n（确切的 SQL 语法因每个数据库引擎而异）。
\n\nminuteLink to this heading#对于日期时间和时间字段，精确的分钟匹配。允许链式查找其他字段。取 0 到 59 之间的整数。
\n举例：
\nEvent.objects.filter(timestamp__minute=29)\nEvent.objects.filter(time__minute=46)\nEvent.objects.filter(timestamp__minute__gte=29)\nSQL 等价于：
\nSELECT ... WHERE EXTRACT('minute' FROM timestamp) = '29';\nSELECT ... WHERE EXTRACT('minute' FROM time) = '46';\nSELECT ... WHERE EXTRACT('minute' FROM timestamp) >= '29';\n（确切的 SQL 语法因每个数据库引擎而异）。
\n\nsecondLink to this heading#对于日期时间和时间字段，完全秒配。允许链式查找其他字段。取 0 到 59 之间的整数。
\n举例：
\nEvent.objects.filter(timestamp__second=31)\nEvent.objects.filter(time__second=2)\nEvent.objects.filter(timestamp__second__gte=31)\nSQL 等价于：
\nSELECT ... WHERE EXTRACT('second' FROM timestamp) = '31';\nSELECT ... WHERE EXTRACT('second' FROM time) = '2';\nSELECT ... WHERE EXTRACT('second' FROM timestamp) >= '31';\n（确切的 SQL 语法因每个数据库引擎而异）。
\n\nisnullLink to this heading#取 True 或 False，分别对应 IS NULL 和 IS NOT NULL 的 SQL 查询。
举例：
\nEntry.objects.filter(pub_date__isnull=True)\nSQL 等价于：
\nSELECT ... WHERE pub_date IS NULL;\nregexLink to this heading#区分大小写的正则表达式匹配。
\n正则表达式语法是使用中的数据库后端的语法。对于没有内置正则表达式支持的 SQLite 来说，这个功能是由（Python）用户定义的 REGEXP 函数提供的，因此正则表达式语法是 Python 的 re 模块的语法。
举例：
\nEntry.objects.get(title__regex=r"^(An?|The) +")\nSQL 等价于：
\nSELECT ... WHERE title REGEXP BINARY '^(An?|The) +'; -- MySQL\n\nSELECT ... WHERE REGEXP_LIKE(title, '^(An?|The) +', 'c'); -- Oracle\n\nSELECT ... WHERE title ~ '^(An?|The) +'; -- PostgreSQL\n\nSELECT ... WHERE title REGEXP '^(An?|The) +'; -- SQLite\n建议使用原始字符串（例如，用 r'foo' 代替 'foo'）来传递正则表达式语法。
iregexLink to this heading#不区分大小写的正则表达式匹配。
\n举例：
\nEntry.objects.get(title__iregex=r"^(an?|the) +")\nSQL 等价于：
\nSELECT ... WHERE title REGEXP '^(an?|the) +'; -- MySQL\n\nSELECT ... WHERE REGEXP_LIKE(title, '^(an?|the) +', 'i'); -- Oracle\n\nSELECT ... WHERE title ~* '^(an?|the) +'; -- PostgreSQL\n\nSELECT ... WHERE title REGEXP '(?i)^(an?|the) +'; -- SQLite\nDjango 在 django.db.models 模块中提供了以下聚合函数。关于如何使用这些聚合函数的细节，请参见 关于聚合的主题指南。参见 Aggregate 文档，了解如何创建你的聚合函数。
所有聚合体都有以下共同的参数：
\nexpressionsLink to this heading#引用模型上的字段的字符串，字段的转换，或 查询表达式。
\noutput_fieldLink to this heading#一个可选的参数，表示返回值的 模型字段
\n\nfilterLink to this heading#An optional Q object that's used to filter the rows that\nare aggregated.
\n\ndefaultLink to this heading#一个可选的参数，允许指定一个值作为默认值，当查询集（或分组）不包含条目时使用。
\n**extraLink to this heading#关键字参数，可以为聚合生成的 SQL 提供额外的上下文。
\nAnyValueLink to this heading#Returns an arbitrary value from the non-null input values.
\nDefault alias: <field>__anyvalue
返回类型：与输入字段相同，或者如果提供了 output_field，则返回它。如果查询集或分组为空，将返回 default。
用法示例：
\n>>> # Get average rating for each year along with a sample headline\n>>> # from that year.\n>>> from django.db.models import AnyValue, Avg, F, Q\n>>> sample_headline = AnyValue("headline")\n>>> Entry.objects.values(\n... pub_year=F("pub_date__year"),\n... ).annotate(\n... avg_rating=Avg("rating"),\n... sample_headline=sample_headline,\n... )\n\n>>> # Get a sample headline from each year with rating greater than 4.5.\n>>> sample_headline = AnyValue(\n... "headline",\n... filter=Q(rating__gt=4.5),\n... )\n>>> Entry.objects.values(\n... pub_year=F("pub_date__year"),\n... ).annotate(\n... avg_rating=Avg("rating"),\n... sample_headline=sample_headline,\n... )\nSupported on SQLite, MySQL, Oracle, and PostgreSQL 16+.
\n\nAvgLink to this heading#返回给定表达式的平均值，除非指定不同的 output_field，否则必须是数值。
默认别名：<field>__avg
返回类型：如果输入是 int，则返回 float，否则返回与输入字段相同的类型，或者如果提供了 output_field，则返回它。如果查询集或分组为空，将返回 default。
可选。如果 distinct=True，则 Avg 返回唯一值的平均值。这相当于 SQL 中的 AVG(DISTINCT <field>)。默认值是 False。
BitAndLink to this heading#返回所有非空输入值的位式 AND 的 int，如果所有值为空，则返回 default。
The default parameter is not supported on MariaDB, MySQL, and Oracle.
BitOrLink to this heading#返回所有非空输入值的位式 OR 的 int，如果所有值为空，则返回 default。
The default parameter is not supported on MariaDB, MySQL, and Oracle.
BitXorLink to this heading#Returns an int of the bitwise XOR of all non-null input values, or\ndefault if all values are null.
The default parameter is not supported on MariaDB, MySQL, and Oracle.
CountLink to this heading#返回通过提供的表达式相关联的对象数量。 Count('*') 等同于 SQL 的 COUNT(*) 表达式。
默认别名：<field>__count
返回类型：int
可选。如果 distinct=True，计数将仅包括唯一的实例。这相当于 SQL 中的 COUNT(DISTINCT <field>)。默认值是 False。
MaxLink to this heading#返回给定表达式的最大值。
\n默认别名：<field>__max
返回类型：与输入字段相同，或者如果提供了 output_field，则返回它。如果查询集或分组为空，将返回 default。
MinLink to this heading#返回给定表达式的最小值。
\n默认别名：<field>__min
返回类型：与输入字段相同，或者如果提供了 output_field，则返回它。如果查询集或分组为空，将返回 default。
StdDevLink to this heading#返回给定表达式中数据的标准差。
\n默认别名：<field>__stddev
返回类型：如果输入是 int，则返回 float，否则返回与输入字段相同的类型，或者如果提供了 output_field，则返回它。如果查询集或分组为空，将返回 default。
可选。默认情况下，StdDev 返回总体标准差。然而，如果 sample=True，返回值将是样本标准差。
SumLink to this heading#计算给定表达式的所有值的总和。
\n默认别名：<field>__sum
返回类型：与输入字段相同，或者如果提供了 output_field，则返回它。如果查询集或分组为空，将返回 default。
可选。如果 distinct=True，Sum 返回唯一值的总和。这相当于 SQL 中的 SUM(DISTINCT <field>)。默认值是 False。
VarianceLink to this heading#返回给定表达式中数据的方差。
\n默认别名：<field>__variance
返回类型：如果输入是 int，则返回 float，否则返回与输入字段相同的类型，或者如果提供了 output_field，则返回它。如果查询集或分组为空，将返回 default。
可选。默认情况下，Variance 返回总体方差。然而，如果 sample=True，返回值将是样本方差。
StringAggLink to this heading#返回输入值串联成的字符串，用 delimiter 字符串分隔，如果没有值，则返回 default。
Default alias: <field>__stringagg
Return type: string or output_field if supplied. If the\nqueryset or grouping is empty, default is returned.
A Value or expression representing the string that should separate\neach of the values. For example, Value(","). (On SQLite, the\nliteral delimiter Value(",") is the only delimiter compatible with\ndistinct=True.)