保存 ForeignKey 和 ManyToManyField 字段¶

更新 ForeignKey 字段的方式与保存普通字段完全相同——将正确类型的对象分配给相关字段。此示例更新 Entry 实例 entry 的 blog 属性，假设 Entry 和 Blog 的适当实例已保存到数据库中（以便我们可以在下面检索它们）

>>> from blog.models import Blog, Entry
>>> entry = Entry.objects.get(pk=1)
>>> cheese_blog = Blog.objects.get(name="Cheddar Talk")
>>> entry.blog = cheese_blog
>>> entry.save()

更新 ManyToManyField 的方式略有不同——使用该字段上的 add() 方法向关系中添加记录。此示例将 Author 实例 joe 添加到 entry 对象

>>> from blog.models import Author
>>> joe = Author.objects.create(name="Joe")
>>> entry.authors.add(joe)

要一次将多个记录添加到 ManyToManyField，请在对 add() 的调用中包含多个参数，如下所示

>>> john = Author.objects.create(name="John")
>>> paul = Author.objects.create(name="Paul")
>>> george = Author.objects.create(name="George")
>>> ringo = Author.objects.create(name="Ringo")
>>> entry.authors.add(john, paul, george, ringo)

如果你尝试分配或添加错误类型的对象，Django 会报错。

检索所有对象¶

从表中检索对象的最简单方法是获取所有对象。为此，请在 Manager 上使用 all() 方法

>>> all_entries = Entry.objects.all()

all() 方法返回数据库中所有对象的 QuerySet。

使用过滤器检索特定对象¶

QuerySet 由 all() 返回，它描述数据库表中的所有对象。但是，通常你需要仅选择完整对象集的子集。

要创建这样的子集，你需要细化初始 QuerySet，添加过滤器条件。细化 QuerySet 的两种最常见方法是

filter(**kwargs)

返回一个新的 QuerySet，其中包含与给定查找参数匹配的对象。

exclude(**kwargs)

返回一个新的包含**不**匹配给定查找参数的对象的QuerySet。

查找参数（上述函数定义中的**kwargs）应采用以下字段查找中描述的格式。

例如，要获取2006年的博客文章的QuerySet，请像这样使用filter()

Entry.objects.filter(pub_date__year=2006)

使用默认管理器类时，它与以下相同：

Entry.objects.all().filter(pub_date__year=2006)

>>> Entry.objects.filter(headline__startswith="What").exclude(
...     pub_date__gte=datetime.date.today()
... ).filter(pub_date__gte=datetime.date(2005, 1, 30))

>>> q1 = Entry.objects.filter(headline__startswith="What")
>>> q2 = q1.exclude(pub_date__gte=datetime.date.today())
>>> q3 = q1.filter(pub_date__gte=datetime.date.today())

>>> q = Entry.objects.filter(headline__startswith="What")
>>> q = q.filter(pub_date__lte=datetime.date.today())
>>> q = q.exclude(body_text__icontains="food")
>>> print(q)

使用get()检索单个对象¶

filter()始终会为您提供一个QuerySet，即使只有一个对象匹配查询——在这种情况下，它将是一个包含单个元素的QuerySet。

如果您知道只有一个对象匹配您的查询，则可以在Manager上使用get()方法，该方法直接返回对象

>>> one_entry = Entry.objects.get(pk=1)

您可以将任何查询表达式与get()一起使用，就像使用filter()一样——同样，请参阅以下字段查找。

请注意，使用get()与使用filter()以及[0]切片之间存在差异。如果没有结果匹配查询，则get()将引发DoesNotExist异常。此异常是正在对其执行查询的模型类的属性——因此在上面的代码中，如果没有主键为1的Entry对象，Django将引发Entry.DoesNotExist。

类似地，如果多个项目匹配get()查询，Django将报错。在这种情况下，它将引发MultipleObjectsReturned，它同样也是模型类本身的属性。

其他QuerySet方法¶

大多数时候，当您需要从数据库中查找对象时，您将使用all()、get()、filter()和exclude()。但是，这远非全部；请参阅QuerySet API 参考，以获取所有各种QuerySet方法的完整列表。

限制QuerySet¶

使用 Python 的数组切片语法的子集来将您的QuerySet限制到一定数量的结果。这相当于 SQL 的LIMIT和OFFSET子句。

例如，这将返回前 5 个对象（LIMIT 5）

>>> Entry.objects.all()[:5]

这将返回第 6 到第 10 个对象（OFFSET 5 LIMIT 5）

>>> Entry.objects.all()[5:10]

不支持负索引（即Entry.objects.all()[-1]）。

通常，对QuerySet进行切片会返回一个新的QuerySet——它不会评估查询。一个例外是如果您使用 Python 切片语法中的“步长”参数。例如，这实际上会执行查询以返回前 10 个对象的每个第二个对象列表

>>> Entry.objects.all()[:10:2]

由于这种做法可能存在歧义，因此禁止对已切片的 QuerySet 进行进一步的过滤或排序。

要检索单个对象而不是列表（例如 SELECT foo FROM bar LIMIT 1），请使用索引而不是切片。例如，这将返回数据库中的第一个 Entry，在按标题按字母顺序排序后

>>> Entry.objects.order_by("headline")[0]

这大致相当于

>>> Entry.objects.order_by("headline")[0:1].get()

但是请注意，如果没有任何对象匹配给定条件，则第一个将引发 IndexError，而第二个将引发 DoesNotExist。有关更多详细信息，请参阅 get()。

字段查找¶

字段查找是您指定 SQL WHERE 子句主体的方式。它们被指定为 QuerySet 方法 filter()、exclude() 和 get() 的关键字参数。

基本查找关键字参数采用 field__lookuptype=value 的形式。（那是双下划线）。例如

>>> Entry.objects.filter(pub_date__lte="2006-01-01")

大致转换为以下 SQL

SELECT * FROM blog_entry WHERE pub_date <= '2006-01-01';

查找中指定的字段必须是模型字段的名称。不过，在 ForeignKey 的情况下有一个例外，您可以指定以 _id 结尾的字段名称。在这种情况下，预期 value 参数包含外键模型主键的原始值。例如

>>> Entry.objects.filter(blog_id=4)

如果传递无效的关键字参数，则查找函数将引发 TypeError。

数据库 API 支持大约二十多种查找类型；可以在 字段查找参考 中找到完整参考。为了让您了解可用的内容，以下是一些您可能会使用的一些更常见的查找

exact

“精确”匹配。例如

>>> Entry.objects.get(headline__exact="Cat bites dog")

将生成如下 SQL

SELECT ... WHERE headline = 'Cat bites dog';

如果未提供查找类型 - 即，如果您的关键字参数不包含双下划线 - 则假定查找类型为 exact。

例如，以下两个语句是等效的

>>> Blog.objects.get(id__exact=14)  # Explicit form
>>> Blog.objects.get(id=14)  # __exact is implied

这是为了方便起见，因为 exact 查找是最常见的情况。

iexact

不区分大小写的匹配。因此，查询

>>> Blog.objects.get(name__iexact="beatles blog")

将匹配标题为 "Beatles Blog"、"beatles blog" 甚至 "BeAtlES blOG" 的 Blog。

contains

区分大小写的包含测试。例如

Entry.objects.get(headline__contains="Lennon")

大致转换为以下 SQL

SELECT ... WHERE headline LIKE '%Lennon%';

请注意，这将匹配标题 'Today Lennon honored' 但不匹配 'today lennon honored'。

还有一个不区分大小写的版本，icontains。

startswith、endswith

分别表示以开头和以结尾的搜索。还有称为 istartswith 和 iendswith 的不区分大小写版本。

同样，这只是触及了表面。可以在 字段查找参考 中找到完整参考。

跨越关系的查找¶

Django 提供了一种强大且直观的方式来在查找中“跟随”关系，在幕后自动处理 SQL JOIN。要跨越关系，请使用跨模型的相关字段的字段名称，用双下划线分隔，直到到达所需的字段。

此示例检索所有 Blog 的 name 为 'Beatles Blog' 的 Entry 对象

>>> Entry.objects.filter(blog__name="Beatles Blog")

这种跨越可以像您想要的那样深入。

它也可以反向工作。虽然它 可以 被 定制，但默认情况下，您使用模型的小写名称在查找中引用“反向”关系。

此示例检索所有至少有一个 Entry 的 headline 包含 'Lennon' 的 Blog 对象

>>> Blog.objects.filter(entry__headline__contains="Lennon")

如果您正在跨多个关系进行过滤，并且其中一个中间模型没有满足过滤条件的值，则 Django 将将其视为存在一个空（所有值均为 NULL）但有效的对象。所有这些意味着不会引发错误。例如，在此过滤器中

Blog.objects.filter(entry__authors__name="Lennon")

（如果存在相关的 Author 模型），如果没有任何与条目关联的 author，则将其视为也没有附加的 name，而不是由于缺少 author 而引发错误。通常，这正是您希望发生的事情。唯一可能令人困惑的情况是，如果您正在使用 isnull。因此

Blog.objects.filter(entry__authors__name__isnull=True)

将返回在 author 上具有空 name 的 Blog 对象，以及在 entry 上具有空 author 的对象。如果您不想要后者对象，则可以编写

Blog.objects.filter(entry__authors__isnull=False, entry__authors__name__isnull=True)

Blog.objects.filter(entry__headline__contains="Lennon", entry__pub_date__year=2008)

Blog.objects.filter(entry__headline__contains="Lennon").filter(
    entry__pub_date__year=2008
)

>>> from datetime import date
>>> beatles = Blog.objects.create(name="Beatles Blog")
>>> pop = Blog.objects.create(name="Pop Music Blog")
>>> Entry.objects.create(
...     blog=beatles,
...     headline="New Lennon Biography",
...     pub_date=date(2008, 6, 1),
... )
<Entry: New Lennon Biography>
>>> Entry.objects.create(
...     blog=beatles,
...     headline="New Lennon Biography in Paperback",
...     pub_date=date(2009, 6, 1),
... )
<Entry: New Lennon Biography in Paperback>
>>> Entry.objects.create(
...     blog=pop,
...     headline="Best Albums of 2008",
...     pub_date=date(2008, 12, 15),
... )
<Entry: Best Albums of 2008>
>>> Entry.objects.create(
...     blog=pop,
...     headline="Lennon Would Have Loved Hip Hop",
...     pub_date=date(2020, 4, 1),
... )
<Entry: Lennon Would Have Loved Hip Hop>
>>> Blog.objects.filter(
...     entry__headline__contains="Lennon",
...     entry__pub_date__year=2008,
... )
<QuerySet [<Blog: Beatles Blog>]>
>>> Blog.objects.filter(
...     entry__headline__contains="Lennon",
... ).filter(
...     entry__pub_date__year=2008,
... )
<QuerySet [<Blog: Beatles Blog>, <Blog: Beatles Blog>, <Blog: Pop Music Blog]>

Blog.objects.exclude(
    entry__headline__contains="Lennon",
    entry__pub_date__year=2008,
)

Blog.objects.exclude(
    entry__in=Entry.objects.filter(
        headline__contains="Lennon",
        pub_date__year=2008,
    ),
)

过滤器可以引用模型上的字段¶

在到目前为止给出的示例中，我们构建了将模型字段的值与常量进行比较的过滤器。但是，如果您想将模型字段的值与同一模型上的另一个字段进行比较，该怎么办？

Django 提供了F 表达式 以允许此类比较。F() 的实例充当查询中模型字段的引用。然后，这些引用可以在查询过滤器中用于比较同一模型实例上两个不同字段的值。

例如，要查找评论数超过pingback数的所有博客条目的列表，我们构建一个F()对象来引用pingback计数，并在查询中使用该F()对象。

>>> from django.db.models import F
>>> Entry.objects.filter(number_of_comments__gt=F("number_of_pingbacks"))

例如，要查找评论数超过pingback数两倍的所有博客条目，我们修改查询如下。

>>> Entry.objects.filter(number_of_comments__gt=F("number_of_pingbacks") * 2)

要查找条目评分小于pingback计数和评论计数之和的所有条目，我们将发出以下查询：

>>> Entry.objects.filter(rating__lt=F("number_of_comments") + F("number_of_pingbacks"))

您还可以使用双下划线表示法在F()对象中跨越关系。F()对象带双下划线将引入访问相关对象所需的任何连接。例如，要检索作者姓名与博客名称相同的全部条目，我们可以发出以下查询：

>>> Entry.objects.filter(authors__name=F("blog__name"))

对于日期和日期/时间字段，您可以添加或减去一个timedelta对象。以下将返回在发布后3天以上修改的所有条目：

>>> from datetime import timedelta
>>> Entry.objects.filter(mod_date__gt=F("pub_date") + timedelta(days=3))

F()对象通过.bitand()、.bitor()、.bitxor()、.bitrightshift()和.bitleftshift()支持按位运算。例如：

>>> F("somefield").bitand(16)

表达式可以引用转换¶

Django支持在表达式中使用转换。

例如，要查找在与上次修改相同年份发布的所有Entry对象：

>>> from django.db.models import F
>>> Entry.objects.filter(pub_date__year=F("mod_date__year"))

要查找条目最早的发布年份，我们可以发出以下查询：

>>> from django.db.models import Min
>>> Entry.objects.aggregate(first_published_year=Min("pub_date__year"))

此示例查找每年的最高评分条目的值以及所有条目的总评论数。

>>> from django.db.models import OuterRef, Subquery, Sum
>>> Entry.objects.values("pub_date__year").annotate(
...     top_rating=Subquery(
...         Entry.objects.filter(
...             pub_date__year=OuterRef("pub_date__year"),
...         )
...         .order_by("-rating")
...         .values("rating")[:1]
...     ),
...     total_comments=Sum("number_of_comments"),
... )

pk查找快捷方式¶

为了方便起见，Django 提供了一个pk查找快捷方式，它代表“主键”。

在示例Blog模型中，主键是id字段，因此以下三个语句是等效的：

>>> Blog.objects.get(id__exact=14)  # Explicit form
>>> Blog.objects.get(id=14)  # __exact is implied
>>> Blog.objects.get(pk=14)  # pk implies id__exact

pk的使用不限于__exact查询——任何查询项都可以与pk组合以对模型的主键执行查询。

# Get blogs entries with id 1, 4 and 7
>>> Blog.objects.filter(pk__in=[1, 4, 7])

# Get all blog entries with id > 14
>>> Blog.objects.filter(pk__gt=14)

pk查找也适用于跨连接。例如，以下三个语句是等效的：

>>> Entry.objects.filter(blog__id__exact=3)  # Explicit form
>>> Entry.objects.filter(blog__id=3)  # __exact is implied
>>> Entry.objects.filter(blog__pk=3)  # __pk implies __id__exact

在LIKE语句中转义百分号和下划线¶

等效于LIKE SQL 语句的字段查找（iexact、contains、icontains、startswith、istartswith、endswith和iendswith）将自动转义LIKE语句中使用的两个特殊字符——百分号和下划线。（在LIKE语句中，百分号表示多字符通配符，下划线表示单字符通配符。）

这意味着事情应该直观地工作，所以抽象不会泄露。例如，要检索所有包含百分号的条目，请将百分号用作任何其他字符。

>>> Entry.objects.filter(headline__contains="%")

Django 会为您处理引用；生成的 SQL 将如下所示：

SELECT ... WHERE headline LIKE '%\%%';

下划线也是如此。百分号和下划线都会为您透明地处理。

缓存和QuerySet¶

每个QuerySet包含一个缓存以最大程度地减少数据库访问。了解其工作原理将使您能够编写最有效的代码。

在新创建的QuerySet中，缓存为空。第一次评估QuerySet时（因此，数据库查询发生时），Django 会将查询结果保存在QuerySet的缓存中并返回已明确请求的结果（例如，如果正在迭代QuerySet，则返回下一个元素）。QuerySet的后续评估将重用缓存的结果。

请记住此缓存行为，因为如果您没有正确使用QuerySet，它可能会给您带来麻烦。例如，以下操作将创建两个QuerySet，评估它们并丢弃它们。

>>> print([e.headline for e in Entry.objects.all()])
>>> print([e.pub_date for e in Entry.objects.all()])

这意味着相同的数据库查询将被执行两次，实际上使您的数据库负载加倍。此外，这两个列表可能不包含相同的数据库记录，因为在两次请求之间极短的时间内可能添加或删除了Entry。

为了避免此问题，请保存QuerySet并重复使用它。

>>> queryset = Entry.objects.all()
>>> print([p.headline for p in queryset])  # Evaluate the query set.
>>> print([p.pub_date for p in queryset])  # Reuse the cache from the evaluation.

>>> queryset = Entry.objects.all()
>>> print(queryset[5])  # Queries the database
>>> print(queryset[5])  # Queries the database again

>>> queryset = Entry.objects.all()
>>> [entry for entry in queryset]  # Queries the database
>>> print(queryset[5])  # Uses cache
>>> print(queryset[5])  # Uses cache

>>> [entry for entry in queryset]
>>> bool(queryset)
>>> entry in queryset
>>> list(queryset)

查询迭代¶

使用for 迭代查询的默认方式将在后台导致阻塞数据库查询，因为 Django 在迭代时加载结果。要解决此问题，您可以切换到async for。

async for entry in Authors.objects.filter(name__startswith="A"):
    ...

请注意，您也不能执行可能迭代 Queryset 的其他操作，例如在其周围包装list() 以强制其评估（如果需要，您可以在推导式中使用async for）。

因为QuerySet 方法（如filter() 和exclude()）实际上不会运行查询——它们设置了在迭代时运行的 Queryset——您可以在异步代码中自由使用它们。有关哪些方法可以像这样继续使用以及哪些方法具有异步版本，请阅读下一节。

QuerySet 和管理器方法¶

管理器和 Queryset 上的一些方法（如get() 和first()）会强制执行 Queryset 并进行阻塞。有些方法（如filter() 和exclude()）不会强制执行，因此可以在异步代码中安全地运行。但是您如何区分它们呢？

虽然您可以四处查看是否存在该方法的以a 为前缀的版本（例如，我们有aget() 但没有afilter()），但有一种更合乎逻辑的方法——在QuerySet 参考中查找它是什么类型的方法。

在那里，您会发现 Queryset 上的方法分为两个部分。

• 返回新 Queryset 的方法：这些是非阻塞方法，并且没有异步版本。您可以在任何情况下自由使用这些方法，但在使用之前请阅读有关defer() 和only() 的说明。

• 不返回 Queryset 的方法：这些是阻塞方法，并且具有异步版本——每个异步名称在其文档中都有说明，尽管我们的标准模式是在前面添加a 前缀。

使用这种区别，您可以确定何时需要使用异步版本，以及何时不需要。例如，这是一个有效的异步查询。

user = await User.objects.filter(username=my_input).afirst()

filter() 返回一个 Queryset，因此在异步环境中继续对其进行链式操作是可以的，而first() 评估并返回一个模型实例——因此，我们更改为afirst()，并在整个表达式的前面使用await 以便以异步友好的方式调用它。

事务¶

事务目前不支持异步查询和更新。您会发现尝试使用事务会引发SynchronousOnlyOperation。

如果您希望使用事务，我们建议您将 ORM 代码写入一个单独的同步函数中，然后使用sync_to_async 调用该函数——有关更多信息，请参阅异步支持。

存储和查询None¶

与其他字段一样，将None 作为字段的值存储会将其存储为 SQLNULL。虽然不推荐，但可以通过使用Value(None, JSONField()) 来存储 JSON 标量null 而不是 SQLNULL。

无论存储哪个值，当从数据库中检索时，JSON 标量null 的 Python 表示形式与 SQLNULL 相同，即None。因此，很难区分它们。

这仅适用于字段的顶级值为None。如果None 在list 或dict 内部，它将始终被解释为 JSONnull。

在查询时，None 值将始终被解释为 JSONnull。要查询 SQLNULL，请使用isnull。

>>> Dog.objects.create(name="Max", data=None)  # SQL NULL.
<Dog: Max>
>>> Dog.objects.create(name="Archie", data=Value(None, JSONField()))  # JSON null.
<Dog: Archie>
>>> Dog.objects.filter(data=None)
<QuerySet [<Dog: Archie>]>
>>> Dog.objects.filter(data=Value(None, JSONField()))
<QuerySet [<Dog: Archie>]>
>>> Dog.objects.filter(data__isnull=True)
<QuerySet [<Dog: Max>]>
>>> Dog.objects.filter(data__isnull=False)
<QuerySet [<Dog: Archie>]>

除非您确定要使用 SQLNULL 值，否则请考虑设置null=False 并为空值提供合适的默认值，例如default=dict。

键、索引和路径转换¶

要根据给定的字典键进行查询，请使用该键作为查找名称。

>>> Dog.objects.create(
...     name="Rufus",
...     data={
...         "breed": "labrador",
...         "owner": {
...             "name": "Bob",
...             "other_pets": [
...                 {
...                     "name": "Fishy",
...                 }
...             ],
...         },
...     },
... )
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": None})
<Dog: Meg>
>>> Dog.objects.filter(data__breed="collie")
<QuerySet [<Dog: Meg>]>

可以将多个键链接在一起以形成路径查找。

>>> Dog.objects.filter(data__owner__name="Bob")
<QuerySet [<Dog: Rufus>]>

如果键是整数，它将被解释为数组中的索引转换。

>>> Dog.objects.filter(data__owner__other_pets__0__name="Fishy")
<QuerySet [<Dog: Rufus>]>

如果要查询的键与另一个查找的名称冲突，请改用contains 查找。

要查询缺少的键，请使用isnull 查找。

>>> Dog.objects.create(name="Shep", data={"breed": "collie"})
<Dog: Shep>
>>> Dog.objects.filter(data__owner__isnull=True)
<QuerySet [<Dog: Shep>]>

包含和键查找¶

>>> Dog.objects.create(name="Rufus", data={"breed": "labrador", "owner": "Bob"})
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})
<Dog: Meg>
>>> Dog.objects.create(name="Fred", data={})
<Dog: Fred>
>>> Dog.objects.filter(data__contains={"owner": "Bob"})
<QuerySet [<Dog: Rufus>, <Dog: Meg>]>
>>> Dog.objects.filter(data__contains={"breed": "collie"})
<QuerySet [<Dog: Meg>]>

>>> Dog.objects.create(name="Rufus", data={"breed": "labrador", "owner": "Bob"})
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})
<Dog: Meg>
>>> Dog.objects.create(name="Fred", data={})
<Dog: Fred>
>>> Dog.objects.filter(data__contained_by={"breed": "collie", "owner": "Bob"})
<QuerySet [<Dog: Meg>, <Dog: Fred>]>
>>> Dog.objects.filter(data__contained_by={"breed": "collie"})
<QuerySet [<Dog: Fred>]>

>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})
<Dog: Meg>
>>> Dog.objects.filter(data__has_key="owner")
<QuerySet [<Dog: Meg>]>

>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})
<Dog: Meg>
>>> Dog.objects.filter(data__has_keys=["breed", "owner"])
<QuerySet [<Dog: Meg>]>

>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})
<Dog: Rufus>
>>> Dog.objects.create(name="Meg", data={"owner": "Bob"})
<Dog: Meg>
>>> Dog.objects.filter(data__has_any_keys=["owner", "breed"])
<QuerySet [<Dog: Rufus>, <Dog: Meg>]>

一对多关系¶

>>> e = Entry.objects.get(id=2)
>>> e.blog  # Returns the related Blog object.

>>> e = Entry.objects.get(id=2)
>>> e.blog = some_blog
>>> e.save()

>>> e = Entry.objects.get(id=2)
>>> e.blog = None
>>> e.save()  # "UPDATE blog_entry SET blog_id = NULL ...;"

>>> e = Entry.objects.get(id=2)
>>> print(e.blog)  # Hits the database to retrieve the associated Blog.
>>> print(e.blog)  # Doesn't hit the database; uses cached version.

>>> e = Entry.objects.select_related().get(id=2)
>>> print(e.blog)  # Doesn't hit the database; uses cached version.
>>> print(e.blog)  # Doesn't hit the database; uses cached version.

>>> b = Blog.objects.get(id=1)
>>> b.entry_set.all()  # Returns all Entry objects related to Blog.

# b.entry_set is a Manager that returns QuerySets.
>>> b.entry_set.filter(headline__contains="Lennon")
>>> b.entry_set.count()

>>> b = Blog.objects.get(id=1)
>>> b.entries.all()  # Returns all Entry objects related to Blog.

# b.entries is a Manager that returns QuerySets.
>>> b.entries.filter(headline__contains="Lennon")
>>> b.entries.count()

from django.db import models


class Entry(models.Model):
    # ...
    objects = models.Manager()  # Default Manager
    entries = EntryManager()  # Custom Manager


b = Blog.objects.get(id=1)
b.entry_set(manager="entries").all()

b.entry_set(manager="entries").is_published()

from django.db.models import Prefetch

prefetch_manager = Prefetch("entry_set", queryset=Entry.entries.all())
Blog.objects.prefetch_related(prefetch_manager)

b = Blog.objects.get(id=1)
b.entry_set.set([e1, e2])

多对多关系¶

多对多关系的两端都可以自动访问另一端。API 的工作方式类似于上面描述的“反向”一对多关系。

一个区别在于属性命名：定义 ManyToManyField 的模型使用该字段本身的属性名称，而“反向”模型则使用原始模型的小写模型名称，加上 '_set'（就像反向一对多关系一样）。

一个例子可以使这更容易理解。

e = Entry.objects.get(id=3)
e.authors.all()  # Returns all Author objects for this Entry.
e.authors.count()
e.authors.filter(name__contains="John")

a = Author.objects.get(id=5)
a.entry_set.all()  # Returns all Entry objects for this Author.

像 ForeignKey 一样，ManyToManyField 可以指定 related_name。在上面的示例中，如果 Entry 中的 ManyToManyField 指定了 related_name='entries'，那么每个 Author 实例将具有一个 entries 属性而不是 entry_set。

与一对多关系的另一个区别在于，除了模型实例之外，多对多关系上的 add()、set() 和 remove() 方法也接受主键值。例如，如果 e1 和 e2 是 Entry 实例，那么这些 set() 调用将以相同的方式工作。

a = Author.objects.get(id=5)
a.entry_set.set([e1, e2])
a.entry_set.set([e1.pk, e2.pk])

一对一关系¶

一对一关系与多对一关系非常相似。如果在模型上定义了 OneToOneField，则该模型的实例可以通过模型的属性访问相关对象。

例如

class EntryDetail(models.Model):
    entry = models.OneToOneField(Entry, on_delete=models.CASCADE)
    details = models.TextField()


ed = EntryDetail.objects.get(id=2)
ed.entry  # Returns the related Entry object.

区别在于“反向”查询。一对一关系中的相关模型也能够访问 Manager 对象，但该 Manager 代表单个对象，而不是对象集合。

e = Entry.objects.get(id=2)
e.entrydetail  # returns the related EntryDetail object

如果没有对象分配给此关系，Django 将引发 DoesNotExist 异常。

可以像分配正向关系一样分配反向关系的实例。

e.entrydetail = ed

反向关系是如何实现的？¶

其他对象关系映射器要求你在两端都定义关系。Django 开发人员认为这违反了 DRY（不要重复自己）原则，因此 Django 只要求你在一端定义关系。

但是，鉴于模型类在其他模型类加载之前不知道哪些其他模型类与其相关，这是如何实现的呢？

答案在于 app registry。当 Django 启动时，它会导入 INSTALLED_APPS 中列出的每个应用程序，然后导入每个应用程序中的 models 模块。每当创建新的模型类时，Django 都会向任何相关模型添加反向关系。如果相关模型尚未导入，Django 会跟踪这些关系，并在最终导入相关模型时添加它们。

因此，尤其重要的是，您正在使用的所有模型都应定义在 INSTALLED_APPS 中列出的应用程序中。否则，反向关系可能无法正常工作。

相关对象的查询¶

涉及相关对象的查询遵循与涉及普通值字段的查询相同的规则。在指定查询匹配的值时，您可以使用对象实例本身或对象的primaryKey值。

例如，如果您有一个 id=5 的 Blog 对象 b，则以下三个查询将是相同的。

Entry.objects.filter(blog=b)  # Query using object instance
Entry.objects.filter(blog=b.id)  # Query using id from instance
Entry.objects.filter(blog=5)  # Query using id directly