Django 中的 OneToOneField() 与foreignkey()

Question

Django OneToOneField 和 ForeignKey 之间有什么区别？

Answer 1

OneToOneField(SomeModel) 和 ForeignKey(SomeModel, unique=True) 之间的差异，如 Django 权威指南：

OneToOneField

一对一的关系。从概念上讲，这类似于具有 unique=True 的 ForeignKey，但关系的“反向”端将直接返回单个对象。

与 OneToOneField“反向”关系相反，ForeignKey“反向”关系返回一个 QuerySet。

示例

例如，如果我们有以下两个模型（完整模型代码如下）：

1. Car 模型使用 OneToOneField(Engine)
2. Car2 模型使用 < code>ForeignKey(Engine2, unique=True)

从 python manage.py shell 执行以下命令：

OneToOneField 示例

>>> from testapp.models import Car, Engine
>>> c = Car.objects.get(name='Audi')
>>> e = Engine.objects.get(name='Diesel')
>>> e.car
<Car: Audi>

ForeignKey 为unique=True 示例

>>> from testapp.models import Car2, Engine2
>>> c2 = Car2.objects.get(name='Mazda')
>>> e2 = Engine2.objects.get(name='Wankel')
>>> e2.car2_set.all()
[<Car2: Mazda>]

模型代码

from django.db import models

class Engine(models.Model):
    name = models.CharField(max_length=25)

    def __unicode__(self):
        return self.name

class Car(models.Model):
    name = models.CharField(max_length=25)
    engine = models.OneToOneField(Engine)

    def __unicode__(self):
        return self.name

class Engine2(models.Model):
    name = models.CharField(max_length=25)

    def __unicode__(self):
        return self.name

class Car2(models.Model):
    name = models.CharField(max_length=25)
    engine = models.ForeignKey(Engine2, unique=True, on_delete=models.CASCADE)

    def __unicode__(self):
        return self.name

Answer 2

ForeignKey 是多对一关系。因此，Car 对象可能有许多 Wheel 实例。因此，每个 Wheel 都会有一个指向其所属 Car 的 ForeignKey。 OneToOneField 就像 Engine 的一个实例，其中 Car 对象有至多一个且仅有一个。

Answer 3

学习新事物最好、最有效的方法是查看和研究现实世界的实际例子。假设您想在 django 中构建一个博客，记者可以在其中撰写和发布新闻文章。在线报纸的老板希望允许每个记者发表尽可能多的文章，但不希望不同的记者撰写同一篇文章。这意味着当读者阅读一篇文章时，他们只会看到文章中的一位作者。

例如：约翰的文章、哈利的文章、里克的文章。您不能拥有 Harry & 的文章。里克，因为老板不希望两个或更多作者写同一篇文章。

我们如何在 django 的帮助下解决这个“问题”？解决这个问题的关键是django ForeignKey。

下面是完整的代码，可以用来实现我们老板的想法。

from django.db import models

# Create your models here.

class Reporter(models.Model):
    first_name = models.CharField(max_length=30)

    def __unicode__(self):
        return self.first_name


class Article(models.Model):
    title = models.CharField(max_length=100)
    reporter = models.ForeignKey(Reporter)

    def __unicode__(self):
        return self.title

运行 python manage.pysyncdb 来执行 sql 代码并在数据库中为您的应用构建表。然后使用 python manage.py shell 打开 python shell。

创建报告者对象 R1。

In [49]: from thepub.models import Reporter, Article

In [50]: R1 = Reporter(first_name='Rick')

In [51]: R1.save()

创建文章对象 A1。

In [5]: A1 = Article.objects.create(title='TDD In Django', reporter=R1)

In [6]: A1.save()

然后使用下面的代码来获取记者的姓名。

In [8]: A1.reporter.first_name
Out[8]: 'Rick'

现在通过运行以下 python 代码创建 Reporter 对象 R2。

In [9]: R2 = Reporter.objects.create(first_name='Harry')

In [10]: R2.save()

现在尝试将 R2 添加到 Article 对象 A1。

In [13]: A1.reporter.add(R2)

它不起作用，您将收到一个 AttributeError 消息，指出“Reporter”对象没有属性“add”。

正如您所看到的，一篇 Article 对象不能与多个 Reporter 对象相关。

R1呢？我们可以附加多个 Article 对象吗？

In [14]: A2 = Article.objects.create(title='Python News', reporter=R1)

In [15]: R1.article_set.all()
Out[15]: [<Article: Python News>, <Article: TDD In Django>]

这个实际例子向我们展示了 django ForeignKey 用于定义多对一关系。

OneToOneField 用于创建一对一关系。

我们可以在上面的 models.py 文件中使用reporter = models.OneToOneField(Reporter)，但它在我们的示例中没有用，因为作者无法发布多于一篇文章。

每次您想要发布新文章时，您都必须创建一个新的 Reporter 对象。这很耗时，不是吗？

我强烈建议尝试使用 OneToOneField 的示例并意识到其中的差异。我非常确定，在这个示例之后，您将完全了解 django OneToOneField 和 django ForeignKey 之间的区别。

Answer 4

OneToOneField（一对一）在面向对象中实现了组合的概念，而ForeignKey（一对多）则与聚合相关。

Answer 5

此外，OneToOneField 可用作主键以避免键重复。可能没有隐式/显式自动字段

models.AutoField(primary_key=True)

，而是使用 OneToOneField 作为主键（例如，想象一下 UserProfile 模型）：

user = models.OneToOneField(
    User, null=False, primary_key=True, verbose_name='Member profile')

Answer 6

我也对这两个字段的用法感到困惑。
让我举一个例子来理解它们的用法，因为我最近遇到了这个问题并意识到这两个字段的用法。

我有一个模型，像这样 -

from django.contrib.auth.models import User
from django.db import models


class Attendance(models.Model):
     user = models.OneToOneField(User, on_delete=models.CASCADE, default="", null=True)
     date = models.CharField(max_length=11)

     def __int__(self):
         return self.id

现在的问题是我无法使用同一用户创建多个对象，
即同一用户将出席多天。因此，多个对象具有同一用户。

但 OneToOne 字段不允许我这样做。
参考图片

因此，我将模型更改为 -

from django.contrib.auth.models import User
from django.db import models


class Attendance(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE, default="", null=True)
    date = models.CharField(max_length=11)

    def __int__(self):
        return self.id

现在它工作正常，我可以标记出勤率多天的用户。

这就是区别所在，OneToOne 字段不允许您使用同一用户创建多个对象（作为示例），但使用foreignkey 则可以。

Answer 7

当您访问 OneToOneField 时，您将获得查询的字段的值。在此示例中，书籍模型的“标题”字段是 OneToOneField：

>>> from mysite.books.models import Book
>>> b = Book.objects.get(id=50)
>>> b.title
u'The Django Book'

当您访问外键时，您将获得相关的模型对象，然后您可以对其执行进一步的查询。在此示例中，同一本书模型的“publisher”字段是一个ForeignKey（与Publisher类模型定义相关）：

>>> b = Book.objects.get(id=50)
>>> b.publisher
<Publisher: Apress Publishing>
>>> b.publisher.website
u'http://www.apress.com/'

使用ForeignKey字段查询也可以以另一种方式工作，但由于关系的非对称性质，它们略有不同。

>>> p = Publisher.objects.get(name='Apress Publishing')
>>> p.book_set.all()
[<Book: The Django Book>, <Book: Dive Into Python>, ...]

在幕后，book_set 只是一个 QuerySet，可以像任何其他 QuerySet 一样进行过滤和切片。属性名称 book_set 是通过将小写模型名称附加到 _set 生成的。

Answer 8

OneToOneField：如果第二个表与表2相关

table2_col1 = models.OneToOneField(table1,on_delete=models.CASCADE, related_name='table1_id')

，则将仅包含与表1的pk值相对应的一条记录，即table2_col1将具有等于表的pk的唯一值，

table2_col1 == models.ForeignKey(table1, on_delete=models.CASCADE, related_name='table1_id')

表2可能包含与表1的pk值相对应的多个记录。

Answer 9

绘制项目之间关系的最简单方法是用简单的语言理解它们。示例

一个用户可以拥有多辆汽车，但一辆车只能有一个车主。建立此后，外键应用于具有多个关系的项目。在这种情况下，汽车。这意味着您将在汽车中包含用户作为外键

，并且一对一的关系非常简单。说一个人，一个心。一个人只有一颗心，一颗心只能属于一个人

Answer 10

OneToOneField（示例：一辆车有一个车主）
foreignKey(OneToMany)（例如：一家餐厅有很多商品）

Answer 11

foreignKey 允许您接收子类（它是另一个类的定义），但 OneToOneFields 不能执行此操作，并且它不能附加到多个变量

Answer 12

OneToOneField() 无法使用 _set 而 ForeignKey() 和ManyToManyField() 可以。 *您可以看到 我的问题和关于它的答案。

例如，您有 Person 模型和带有 OneToOneField() 的 PersonDetail 模型，如下所示：

class Person(models.Model):
    name = models.CharField(max_length=20)

class PersonDetail(models.Model):
    person = models.OneToOneField(Person, on_delete=models.CASCADE)
    age = models.IntegerField()
    gender = models.CharField(max_length=20)

然后，您无法访问子模型 PersonDetail 与 Person 对象的 persondetail_set 如下所示，因为存在错误。 *在 OneToOneField() 的情况下，使用 persondetail 而不是 persondetail_set 来访问子模型 PersonDetail：

obj = Person.objects.get(id=1)
print(obj.persondetail_set.get(id=1)) # Error
        # ↑ ↑ ↑ Here ↑ ↑ ↑

现在，您使用 ForeignKey() 和 ManyToManyField() 如下所示：

class PersonDetail(models.Model):
    person = models.ForeignKey(Person, on_delete=models.CASCADE)
    # ...

class PersonDetail(models.Model):
    person = models.ManyToManyField(Person)
    # ...

然后，您可以使用 persondetail_set 访问子模型 PersonDetail Person 对象的 code> 如下所示：

obj = Person.objects.get(id=1)
print(obj.persondetail_set.get(id=1)) # PersonDetail object (1)
        # ↑ ↑ ↑ Here ↑ ↑ ↑