python-Django中的OneToOne,ManyToMany和ForeignKey字段之间有什么区别?

我很难理解Django模型中的关系。

有人可以解释一下OneToOne,ManyToMany和ForeignKey之间的区别吗?

1个解决方案
110 votes

好吧,这里基本上有两个问题:

  1. 一对一,多对多和外键关系之间的区别(通常)是什么
  2. 它们对Django有什么区别。

通过简单的Google搜索,可以很容易地回答这两个问题,但是由于我在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

您可以看到在|模型中未定义任何关系,并且在Person模型中未定义<关系。 假设我们创建了以下模型实例(显然不是使用Python语法):

  • 出生地:德克萨斯州达拉斯
  • 出生地:纽约,纽约
  • 人:约翰·史密斯(John Smith),出生地:(德克萨斯州达拉斯)
  • 人:玛丽亚·李,出生地:(德克萨斯州达拉斯)
  • 人:丹尼尔·李,出生地:(纽约,纽约)

现在我们可以看到Django如何让我们使用这些关系(请注意|是您的朋友!):

>> 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在模型上创建一个经理(|)来处理此问题,名为|,其中<是小写的模型名称。

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

请注意,我们可以通过在模型关系中设置|关键字参数来更改此管理器的名称。 因此,我们将Person模型中的<字段更改为:

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

现在,我们可以使用漂亮的名称访问该反向关系:

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

一对一

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

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

让我们在Django中看一下。 我不会费心定义用户模型,因为Django为我们定义了它。 请注意,但是Django建议使用|导入用户,因此我们将这样做。 简档模型可以定义如下:

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.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>

当然,您可以使用上述|参数来自定义反向关系的名称。


多对多

多对多关系可能有些棘手。 首先,我要说多对多字段是混乱的,应尽可能避免使用。 鉴于此,在许多情况下,多对多关系才有意义。

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

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将为<字段创建|,以访问多对多关系。

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

  • 订购:“太空飞船”,“ NASA”
  • 订单:“潜艇”,“美国海军”
  • 订购:“赛车”,“ NASCAR”
  • 项目:订单:[]
  • 项目:订单:[(订单:“太空飞船”,“ NASA”)]
  • 项目:订单:[(订单:“太空飞船”,“ NASA”),(订单:“赛车”,“ 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个项目有关,而美国海军订单与2个项目都不相关。 另请注意,一个项目没有订单,而一个则有多个。

我们还可以通过与以前相同的方式来反向访问该关系:

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

ASCII基数指南

在我的ASCII图可能有点混乱的情况下,以下说明可能会有所帮助:

  • |<的意思是“很多”
  • |的意思是“一对一”

因此... models.ManyToManyField表示A的一个实例只能与B的一个实例相关。

models.ManyToManyField表示A的实例可以与B的很多实例相关。

models.ManyToManyField等效于...

A --< B
A >-- B

因此,关系的每个“侧面”或方向都可以分别读取。 将它们挤压在一起很方便。

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

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

资源资源

@MarcB提供的数据库关系的良好解释

关于基数的维基百科页面

Django文件:

models.ManyToManyField

models.ManyToManyField

models.ManyToManyField

一对一关系

多对多关系

Johndt6 answered 2020-08-05T03:23:19Z
translate from https://stackoverflow.com:/questions/25386119/whats-the-difference-between-a-onetoone-manytomany-and-a-foreignkey-field-in-d