python - Django 中的 OneToOne、ManyToMany 和 ForeignKey 字段有什么区别？

Question

我在处理 Django 模型中的关系时遇到了一些困难。

有人可以解释 OneToOne、ManyToMany 和 ForeignKey 之间的区别吗？

Answer 1

嗯，这里基本上有两个问题:

一对一、多对多、外键关系(一般)有什么区别

它们与 Django 有什么区别。

通过简单的谷歌搜索可以很容易地回答这两个问题，但是由于我在 SO 上找不到这个问题的确切重复，我会继续回答。

请注意，在 Django 中，关系应该只在关系的一侧定义。

外键

外键关系通常称为多对一关系。请注意，这种关系的反向是一对多(Django 提供了访问工具)。顾名思义，许多对象可能与一个有关。

Person >--| Birthplace
   ^           ^
   |           |
  Many        One 

在这个例子中，一个人可能只有一个出生地，但一个出生地可能与很多人有关。让我们看看 Django 中的这个例子。说这些是我们的模型:

class Birthplace(models.Model):
    city = models.CharField(max_length=75)
    state = models.CharField(max_length=25)

    def __unicode__(self):
        return "".join(self.city, ", ", self.state)

class Person(models.Model):
    name = models.CharField(max_length=50)
    birthplace = models.ForeignKey(Birthplace)

    def __unicode__(self):
        return self.name

您可以看到 Birthplace 中没有定义任何关系。模型和 ForeignKey关系在 Person 中定义模型。假设我们创建了模型的以下实例(显然不是 Python 语法):

出生地:德克萨斯州达拉斯

出生地:纽约市，纽约

人:约翰史密斯，出生地:(德克萨斯州达拉斯)

人:Maria Lee，出生地:(德克萨斯州达拉斯)

人:Daniel Lee，出生地:(纽约市，纽约)

现在我们可以看到 Django 如何让我们使用这些关系(注意 ./manage.py shell 是你的 friend !):

>> from somewhere.models import Birthplace, Person
>> Person.objects.all()
[<Person: John Smith>, <Person: Maria Lee>, <Person: Daniel Lee>]
>> Birthplace.objects.all()
[<Birthplace: Dallas, Texas>, <Birthplace: New York City, New York>]

您可以看到我们创建的模型实例。现在让我们检查某人的出生地:

>> person = Person.object.get(name="John Smith")
>> person.birthplace
<Birthplace: Dallas, Texas>
>> person.birthplace.city
Dallas

假设您想查看所有出生地的人。正如我之前所说，Django 允许您访问反向关系。默认情况下，Django 在您的模型上创建一个管理器( RelatedManager )来处理这个问题，名为 <model>_set ，其中 <model>是小写的型号名称。

>> place = Birthplace.objects.get(city="Dallas")
>> place.person_set.all()
[<Person: John Smith>, <Person: Maria Lee>]

请注意，我们可以通过设置 related_name 来更改此经理的名称。我们模型关系中的关键字参数。因此，我们将更改 birthplace Person 中的字段模型为:

birthplace = models.ForeignKey(Birthplace, related_name="people")

现在，我们可以用一个漂亮的名字来访问反向关系:

>> place.people.all()
[<Person: John Smith>, <Person: Maria Lee>]

一对一

一对一关系与多对一关系非常相似，不同之处在于它将两个对象限制为具有唯一关系。一个例子是用户和配置文件(存储有关用户的信息)。没有两个用户共享相同的配置文件。

User |--| Profile
  ^          ^
  |          |
 One        One

让我们在 Django 中看看这个。我不会费心定义用户模型，因为 Django 为我们定义了它。但是请注意，Django 建议使用 django.contrib.auth.get_user_model()导入用户，这就是我们要做的。配置文件模型可以定义如下:

class Profile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL) # Note that Django suggests getting the User from the settings for relationship definitions
    fruit = models.CharField(max_length=50, help_text="Favorite Fruit")
    facebook = models.CharField(max_length=100, help_text="Facebook Username")

    def __unicode__(self):
        return "".join(self.fruit, " ", self.facebook)

我们所需要的只是一个具有配置文件的用户，可以在 shell 中对此进行测试:

用户:johndt6

个人资料:用户:johndt6、“Kiwi”、“blah_blah”

现在您可以轻松地从 User 模型访问用户的个人资料:

>> user = User.objects.all()[0]
>> user.username
johndt6
>> user.profile
<Profile: Kiwi blah_blah>
>> user.profile.fruit
Kiwi
>> profile = Profile.objects.get(user=user)
>> profile.user
<User: johndt6>

当然，您可以使用 related_name 自定义反向关系的名称。论据如上。

多对多

多对多关系可能有点棘手。首先让我说多对多字段是困惑的，应该尽可能避免。鉴于此，在很多情况下多对多关系是有意义的。

两个模型之间的多对多关系定义了第一模型的零个、一个或多个对象可能与第二模型的零个、一个或多个对象相关。例如，让我们设想一家通过项目定义其工作流程的公司。一个项目可能与没有订单、只有一个订单或多个订单相关。订单可能与无项目、一个项目或多个项目相关。

Order >--< Project
  ^           ^
  |           |
 Many        Many

让我们这样定义我们的模型:

class Order(models.Model):
    product = models.CharField(max_length=150)  # Note that in reality, this would probably be better served by a Product model
    customer = models.CharField(max_length=150)  # The same may be said for customers

    def __unicode__(self):
        return "".join(self.product, " for ", self.customer)

class Project(models.Model):
    orders = models.ManyToManyField(Order)

    def __unicode__(self):
        return "".join("Project ", str(self.id))

请注意，Django 会创建一个 RelatedManager为 orders字段来访问多对多关系。

让我们为我们的模型创建以下实例(在我不一致的语法中!):

订单:“宇宙飞船”、“美国宇航局”

订单:“潜艇”、“美国海军”

订购:“赛车”、“NASCAR”

项目:订单:[]

项目:订单:[(订单:“宇宙飞船”，“NASA”)]

项目:orders: [(Order: "Spaceship", "NASA"), (Or​​der: "Race car", "NASCAR")]

我们可以按如下方式访问这些关系:

>> Project.objects.all()
[<Project: Project 0>, <Project: Project 1>, <Project: Project 2>]
>> for proj in Project.objects.all():
..     print(proj)
..     proj.orders.all()  # Note that we must access the `orders`
..                        # field through its manager
..     print("")
Project 0
[]

Project 1
[<Order: Spaceship for NASA>]

Project 2
[<Order: Spaceship for NASA>, <Order: Race car for NASCAR>]

请注意，NASA 订单与 2 个项目相关，而美国海军订单与一个项目无关。另请注意，一个项目没有订单，一个项目有多个订单。

我们也可以以与之前相同的方式反向访问关系:

>> order = Order.objects.filter(customer="NASA")[0]
>> order.project_set.all()
[<Project: Project 0>, <Project: Project 2>]

ASCII 基数指南

在我的 ASCII 图表可能有点困惑的情况下，以下解释可能会有所帮助:

>或 <意思是“对很多”

|表示“对一”

所以... A --| B意味着 A 的一个实例只能与 B 的一个实例相关。

和 A --< B意味着 A 的实例可以与 B 的许多实例相关。
A >--< B相当于……

A --< B
A >-- B

因此，关系的每个“侧面”或方向都可以单独阅读。把它们挤在一起很方便。

扩展这些关系之一可能更有意义:

               +---- John Smith
               |
 Dallas|-------+---- Jane Doe
               |
               +---- Joe Smoe

资源

Good explanation of db relationships由@MarcB 提供

Wikipedia page on Cardinality

Django 文档:

models.ForeignKey

models.OneToOneField

models.ManyToManyField

One-to-one Relationships

Many-to-many Relationships