Django 中的 OneToOne、ManyToMany 和 ForeignKey 字段有啥区别?
Posted
技术标签:
【中文标题】Django 中的 OneToOne、ManyToMany 和 ForeignKey 字段有啥区别?【英文标题】:Whats the difference between a OneToOne, ManyToMany, and a ForeignKey Field in Django?Django 中的 OneToOne、ManyToMany 和 ForeignKey 字段有什么区别? 【发布时间】:2014-10-12 17:06:55 【问题描述】:我很难理解 Django 模型中的关系。
有人能解释一下 OneToOne、ManyToMany 和 ForeignKey 之间的区别吗?
【问题讨论】:
这是一个 DB 概念,并非特定于 Django:databaseprimer.com/pages/table-relationships 外键是这些关系的指定方式。 【参考方案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 语法):
现在我们可以看到 Django 如何让我们使用这些关系(注意 ./manage.py shell
是你的朋友!):
>> 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
关键字参数来更改此经理的名称。因此,我们将 Person
模型中的 birthplace
字段更改为:
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 将为orders
字段创建一个RelatedManager
以访问多对多关系。
让我们创建模型的以下实例(我的语法不一致!):
订单:“宇宙飞船”、“NASA” 订单:“潜艇”、“美国海军” 订单:“赛车”、“NASCAR” 项目:订单:[] 项目:订单:[(订单:“宇宙飞船”,“NASA”)] 项目:订单:[(订单:“Spaceship”、“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 个项目相关,而美国海军订单与任何项目无关。另请注意,一个项目没有订单,一个项目有多个。
我们也可以像以前一样反向访问关系:
>> 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
【讨论】:
我要补充一点,使用ManyToManyField
在数据库中创建一个额外的表,其中包含 3 个字段:pk 和 2 个对连接表的引用(table1_id、table2_id)。 ManyToManyField
是标签的绝佳选择(例如,如果您想用标签标记特定的项目/产品/位置)。
这里是 ManyToManyField 中间表上的文档 - docs.djangoproject.com/en/3.1/ref/models/fields/#id1。【参考方案2】:
在我看来,一对一和一对多的黑白差异是 一对一:这意味着一个人只能包含一本护照 一对多:这意味着一个人可以包含多个地址,例如(永久地址,办公室地址,次要地址) 如果你调用父模型它会自动调用许多子类
【讨论】:
以上是关于Django 中的 OneToOne、ManyToMany 和 ForeignKey 字段有啥区别?的主要内容,如果未能解决你的问题,请参考以下文章
Django 1.11 admin:创建 OneToOne 关系,它是 admin 中的对象
Django Admin:如何在 oneToOne 关系中的两个模型中显示带有 list_display 的字段值?