除了我们前面说过的普通类型字段，Django还定义了一组关系类型字段，用来表示模型与模型之间的关系。

一、多对一（ForeignKey）

多对一的关系，通常被称为外键。外键字段类的定义如下：

  1. class ForeignKey(to, on_delete, **options)[source]

外键需要两个位置参数，一个是关联的模型，另一个是on_delete选项。实际上，在目前版本中，on_delete选项也可以不设置，但Django极力反对如此，因此在Django2.0版本后，该选项会设置为必填。

外键要定义在‘多’的一方！

  1. from django.db import models
  3. class Car(models.Model):
  4.     manufacturer = models.ForeignKey(
  5.         'Manufacturer',
  6.         on_delete=models.CASCADE,
  7.     )
  8.     # ...
  10. class Manufacturer(models.Model):
  11.     # ...
  12.     pass

上面的例子中，每辆车都会有一个生产工厂，一个工厂可以生产N辆车，于是用一个外键字段manufacturer表示，并放在Car模型中。注意，此manufacturer非彼Manufacturer模型类，它是一个字段的名称。在Django的模型定义中，经常出现类似的英文单词大小写不同，一定要注意区分！

如果要关联的对象在另外一个app中，可以显式的指出。下例假设Manufacturer模型存在于production这个app中，则Car模型的定义如下：

  1. class Car(models.Model):
  2.     manufacturer = models.ForeignKey(
  3.         'production.Manufacturer',      # 关键在这里！！
  4.         on_delete=models.CASCADE,
  5.     )

如果要创建一个递归的外键，也就是自己关联自己的的外键，使用下面的方法：

  1. models.ForeignKey('self', on_delete=models.CASCADE)

核心在于‘self’这个引用。什么时候需要自己引用自己的外键呢？典型的例子就是评论系统！一条评论可以被很多人继续评论，如下所示：

  1. class Comment(models.Model):
  2.     title = models.CharField(max_length=128)
  3.     text = models.TextField()
  4.     parent_comment = models.ForeignKey('self', on_delete=models.CASCADE)
  5.     # .....

注意上面的外键字段定义的是父评论，而不是子评论。为什么呢？因为外键要放在‘多’的一方！

在实际的数据库后台，Django会为每一个外键添加_id后缀，并以此创建数据表里的一列。在上面的工厂与车的例子中，Car模型对应的数据表中，会有一列叫做manufacturer_id。但实际上，在Django代码中你不需要使用这个列名，除非你书写原生的SQL语句，一般我们都直接使用字段名manufacturer。

关系字段的定义还有个小坑。在后面我们会讲到的verbose_name参数用于设置字段的别名。很多情况下，为了方便，我们都会设置这么个值，并且作为字段的第一位置参数。但是对于关系字段，其第一位置参数永远是关系对象，不能是verbose_name，一定要注意！

参数说明：

外键还有一些重要的参数，说明如下：

on_delete

注意：这个参数在Django2.0之后，不可以省略了，需要显式的指定！这也是除了路由编写方式外，Django2和Django1.x最大的不同点之一！

当一个被外键关联的对象被删除时，Django将模仿on_delete参数定义的SQL约束执行相应操作。比如，你有一个可为空的外键，并且你想让它在关联的对象被删除时，自动设为null，可以如下定义：

  1. user = models.ForeignKey(
  2.     User,
  3.     models.SET_NULL,
  4.     blank=True,
  5.     null=True,
  6. )

该参数可选的值都内置在django.db.models中，包括：

  • CASCADE：模拟SQL语言中的ON DELETE CASCADE约束，将定义有外键的模型对象同时删除！（该操作为当前Django版本的默认操作！）
  • PROTECT:阻止上面的删除操作，但是弹出ProtectedError异常
  • SET_NULL：将外键字段设为null，只有当字段设置了null=True时，方可使用该值。
  • SET_DEFAULT:将外键字段设为默认值。只有当字段设置了default参数时，方可使用。
  • DO_NOTHING：什么也不做。
  • SET()：设置为一个传递给SET()的值或者一个回调函数的返回值。注意大小写。
  1. from django.conf import settings
  2. from django.contrib.auth import get_user_model
  3. from django.db import models
  5. def get_sentinel_user():
  6.     return get_user_model().objects.get_or_create(username='deleted')[0]
  8. class MyModel(models.Model):
  9.     user = models.ForeignKey(
  10.         settings.AUTH_USER_MODEL,
  11.         on_delete=models.SET(get_sentinel_user),
  12.     )

limit_choices_to

该参数用于限制外键所能关联的对象，只能用于Django的ModelForm（Django的表单模块）和admin后台，对其它场合无限制功能。其值可以是一个字典、Q对象或者一个返回字典或Q对象的函数调用，如下例所示：

  1. staff_member = models.ForeignKey(
  2.     User,
  3.     on_delete=models.CASCADE,
  4.     limit_choices_to={'is_staff': True},
  5. )

这样定义，则ModelForm的staff_member字段列表中，只会出现那些is_staff=True的Users对象，这一功能对于admin后台非常有用。

可以参考下面的方式，使用函数调用：

  1. def limit_pub_date_choices():
  2.     return {'pub_date__lte': datetime.date.utcnow()}
  4. # ...
  5. limit_choices_to = limit_pub_date_choices
  6. # ...

related_name

用于关联对象反向引用模型的名称。以前面车和工厂的例子解释，就是从工厂反向关联到车的关系名称。

通常情况下，这个参数我们可以不设置，Django会默认以模型的小写加上_set作为反向关联名，比如对于工厂就是car_set，如果你觉得car_set还不够直观，可以如下定义：

  1. class Car(models.Model):
  2.     manufacturer = models.ForeignKey(
  3.         'production.Manufacturer',      
  4.         on_delete=models.CASCADE,
  5.         related_name='car_producted_by_this_manufacturer',  # 看这里！！
  6.     )

也许我定义了一个蹩脚的词，但表达的意思很清楚。以后从工厂对象反向关联到它所生产的汽车，就可以使用maufacturer.car_producted_by_this_manufacturer了。

如果你不想为外键设置一个反向关联名称，可以将这个参数设置为“+”或者以“+”结尾，如下所示：

  1. user = models.ForeignKey(
  2.     User,
  3.     on_delete=models.CASCADE,
  4.     related_name='+',
  5. )

related_query_name

反向关联查询名。用于从目标模型反向过滤模型对象的名称。（过滤和查询在后续章节会介绍）

  1. class Tag(models.Model):
  2.     article = models.ForeignKey(
  3.         Article,
  4.         on_delete=models.CASCADE,
  5.         related_name="tags",
  6.         related_query_name="tag",       # 注意这一行
  7.     )
  8.     name = models.CharField(max_length=255)
  10. # 现在可以使用‘tag’作为查询名了
  11. Article.objects.filter(tag__name="important")

to_field

默认情况下，外键都是关联到被关联对象的主键上（一般为id）。如果指定这个参数，可以关联到指定的字段上，但是该字段必须具有unique=True属性，也就是具有唯一属性。

db_constraint

默认情况下，这个参数被设为True，表示遵循数据库约束，这也是大多数情况下你的选择。如果设为False，那么将无法保证数据的完整性和合法性。在下面的场景中，你可能需要将它设置为False：

  • 有历史遗留的不合法数据，没办法的选择
  • 你正在分割数据表

当它为False，并且你试图访问一个不存在的关系对象时，会抛出DoesNotExist 异常。

swappable

控制迁移框架的动作，如果当前外键指向一个可交换的模型。使用场景非常稀少，通常请将该参数保持默认的True。

二、多对多（ManyToManyField）

多对多关系在数据库中也是非常常见的关系类型。比如一本书可以有好几个作者，一个作者也可以写好几本书。多对多的字段可以定义在任何的一方，请尽量定义在符合人们思维习惯的一方，但不要同时都定义。

  1. class ManyToManyField(to, **options)[source]

多对多关系需要一个位置参数：关联的对象模型。它的用法和外键多对一基本类似。

在数据库后台，Django实际上会额外创建一张用于体现多对多关系的中间表。默认情况下，该表的名称是“多对多字段名+关联对象模型名+一个独一无二的哈希码”，例如‘author_books_9cdf4’，当然你也可以通过db_table选项，自定义表名。

参数说明：

related_name

参考外键的相同参数。

related_query_name

参考外键的相同参数。

limit_choices_to

参考外键的相同参数。但是对于使用through参数自定义中间表的多对多字段无效。

symmetrical

默认情况下，Django中的多对多关系是对称的。看下面的例子：

  1. from django.db import models
  3. class Person(models.Model):
  4.     friends = models.ManyToManyField("self")

Django认为，如果我是你的朋友，那么你也是我的朋友，这是一种对称关系，Django不会为Person模型添加person_set属性用于反向关联。如果你不想使用这种对称关系，可以将symmetrical设置为False，这将强制Django为反向关联添加描述符。

through

（定义中间表）

如果你想自定义多对多关系的那张额外的关联表，可以使用这个参数！参数的值为一个中间模型。

最常见的使用场景是你需要为多对多关系添加额外的数据，比如两个人建立QQ好友的时间。

通常情况下，这张表在数据库内的结构是这个样子的：

  1. 中间表的id列....模型对象的id列.....被关联对象的id列
  2. # 各行数据

如果自定义中间表并添加时间字段，则在数据库内的表结构如下：

  1. 中间表的id列....模型对象的id列.....被关联对象的id列.....时间对象列
  2. # 各行数据

看下面的例子：

  1. from django.db import models
  3. class Person(models.Model):
  4.     name = models.CharField(max_length=50)
  6. class Group(models.Model):
  7.     name = models.CharField(max_length=128)
  8.     members = models.ManyToManyField(
  9.         Person,
  10.         through='Membership',       ## 自定义中间表
  11.         through_fields=('group', 'person'),
  12.     )
  14. class Membership(models.Model):  # 这就是具体的中间表模型
  15.     group = models.ForeignKey(Group, on_delete=models.CASCADE)
  16.     person = models.ForeignKey(Person, on_delete=models.CASCADE)
  17.     inviter = models.ForeignKey(
  18.         Person,
  19.         on_delete=models.CASCADE,
  20.         related_name="membership_invites",
  21.     )
  22.     invite_reason = models.CharField(max_length=64)

上面的代码中，通过class Membership(models.Model)定义了一个新的模型，用来保存Person和Group模型的多对多关系，并且同时增加了‘邀请人’和‘邀请原因’的字段。

through参数在某些使用场景中是必须的，至关重要，请务必掌握！

through_fields

接着上面的例子。Membership模型中包含两个关联Person的外键，Django无法确定到底使用哪个作为和Group关联的对象。所以，在这个例子中，必须显式的指定through_fields参数，用于定义关系。

through_fields参数接收一个二元元组(‘field1’, ‘field2’)，field1是指向定义有多对多关系的模型的外键字段的名称，这里是Membership中的‘group’字段（注意大小写），另外一个则是指向目标模型的外键字段的名称，这里是Membership中的‘person’，而不是‘inviter’。

再通俗的说，就是through_fields参数指定从中间表模型Membership中选择哪两个字段，作为关系连接字段。

db_table

设置中间表的名称。不指定的话，则使用默认值。

db_constraint

参考外键的相同参数。

swappable

参考外键的相同参数。

ManyToManyField多对多字段不支持Django内置的validators验证功能。

null参数对ManyToManyField多对多字段无效！设置null=True毫无意义

三、一对一（OneToOneField）

一对一关系类型的定义如下：

  1. class OneToOneField(to, on_delete, parent_link=False, **options)[source]

从概念上讲，一对一关系非常类似具有unique=True属性的外键关系，但是反向关联对象只有一个。这种关系类型多数用于当一个模型需要从别的模型扩展而来的情况。比如，Django自带auth模块的User用户表，如果你想在自己的项目里创建用户模型，又想方便的使用Django的认证功能，那么一个比较好的方案就是在你的用户模型里，使用一对一关系，添加一个与auth模块User模型的关联字段。

该关系的第一位置参数为关联的模型，其用法和前面的多对一外键一样。

如果你没有给一对一关系设置related_name参数，Django将使用当前模型的小写名作为默认值。

看下面的例子：

  1. from django.conf import settings
  2. from django.db import models
  4. # 两个字段都使用一对一关联到了Django内置的auth模块中的User模型
  5. class MySpecialUser(models.Model):
  6.     user = models.OneToOneField(
  7.         settings.AUTH_USER_MODEL,
  8.         on_delete=models.CASCADE,
  9.     )
  10.     supervisor = models.OneToOneField(
  11.         settings.AUTH_USER_MODEL,
  12.         on_delete=models.CASCADE,
  13.         related_name='supervisor_of',
  14.     )

这样下来，你的User模型将拥有下面的属性：

  1. >>> user = User.objects.get(pk=1)
  2. >>> hasattr(user, 'myspecialuser')
  3. True
  4. >>> hasattr(user, 'supervisor_of')
  5. True

OneToOneField一对一关系拥有和多对一外键关系一样的额外可选参数，只是多了一个parent_link参数。

跨模块的模型：

有时候，我们关联的模型并不在当前模型的文件内，没关系，就像我们导入第三方库一样的从别的模块内导入进来就好，如下例所示：

  1. from django.db import models
  2. from geography.models import ZipCode
  4. class Restaurant(models.Model):
  5.     # ...
  6.     zip_code = models.ForeignKey(
  7.         ZipCode,
  8.         on_delete=models.SET_NULL,
  9.         blank=True,
  10.         null=True,
  11.     )

四、多对多中间表详解

我们都知道对于ManyToMany字段，Django采用的是第三张中间表的方式。通过这第三张表，来关联ManyToMany的双方。下面我们根据一个具体的例子，详细解说中间表的使用。

1、默认中间表

首先，模型是这样的：

  1. class Person(models.Model):
  2.     name = models.CharField(max_length=128)
  4.     def __str__(self):
  5.         return self.name
  8. class Group(models.Model):
  9.     name = models.CharField(max_length=128)
  10.     members = models.ManyToManyField(Person)
  12.     def __str__(self):
  13.         return self.name

在Group模型中，通过members字段，以ManyToMany方式与Person模型建立了关系。

让我们到数据库内看一下实际的内容，Django为我们创建了三张数据表，其中的app1是应用名。

关系类型字段 - 图1

然后我在数据库中添加了下面的Person对象：

关系类型字段 - 图2

再添加下面的Group对象：

关系类型字段 - 图3

让我们来看看，中间表是个什么样子的：

关系类型字段 - 图4

首先有一列id，这是Django默认添加的，没什么好说的。然后是Group和Person的id列，这是默认情况下，Django关联两张表的方式。如果你要设置关联的列，可以使用to_field参数。

可见在中间表中，并不是将两张表的数据都保存在一起，而是通过id的关联进行映射。

2、自定义中间表

一般情况，普通的多对多已经够用，无需自己创建第三张关系表。但是某些情况可能更复杂一点，比如如果你想保存某个人加入某个分组的时间呢？想保存进组的原因呢？

Django提供了一个through参数，用于指定中间模型，你可以将类似进组时间，邀请原因等其他字段放在这个中间模型内。例子如下：

  1. from django.db import models
  3. class Person(models.Model):
  4.     name = models.CharField(max_length=128)
  5.     def __str__(self): 
  6.         return self.name
  8. class Group(models.Model):
  9.     name = models.CharField(max_length=128)
  10.     members = models.ManyToManyField(Person, through='Membership')
  11.     def __str__(self): 
  12.         return self.name
  14. class Membership(models.Model):
  15.     person = models.ForeignKey(Person, on_delete=models.CASCADE)
  16.     group = models.ForeignKey(Group, on_delete=models.CASCADE)
  17.     date_joined = models.DateField()        # 进组时间
  18.     invite_reason = models.CharField(max_length=64)  # 邀请原因

在中间表中，我们至少要编写两个外键字段，分别指向关联的两个模型。在本例中就是‘Person’和‘group’。 这里，我们额外增加了‘date_joined’字段，用于保存人员进组的时间，‘invite_reason’字段用于保存邀请进组的原因。

下面我们依然在数据库中实际查看一下（应用名为app2）：

关系类型字段 - 图5

注意中间表的名字已经变成“app2_membership”了。

关系类型字段 - 图6

关系类型字段 - 图7

Person和Group没有变化。

关系类型字段 - 图8

但是中间表就截然不同了！它完美的保存了我们需要的内容。

3、使用中间表

针对上面的中间表，下面是一些使用例子（以欧洲著名的甲壳虫乐队成员为例）：

  1. >>> ringo = Person.objects.create(name="Ringo Starr")
  2. >>> paul = Person.objects.create(name="Paul McCartney")
  3. >>> beatles = Group.objects.create(name="The Beatles")
  4. >>> m1 = Membership(person=ringo, group=beatles,
  5. ... date_joined=date(1962, 8, 16),
  6. ... invite_reason="Needed a new drummer.")
  7. >>> m1.save()
  8. >>> beatles.members.all()
  9. <QuerySet [<Person: Ringo Starr>]>
  10. >>> ringo.group_set.all()
  11. <QuerySet [<Group: The Beatles>]>
  12. >>> m2 = Membership.objects.create(person=paul, group=beatles,
  13. ... date_joined=date(1960, 8, 1),
  14. ... invite_reason="Wanted to form a band.")
  15. >>> beatles.members.all()
  16. <QuerySet [<Person: Ringo Starr>, <Person: Paul McCartney>]>

与普通的多对多不一样，使用自定义中间表的多对多不能使用add(), create(),remove(),和set()方法来创建、删除关系，看下面：

  1. >>> # 无效
  2. >>> beatles.members.add(john)
  3. >>> # 无效
  4. >>> beatles.members.create(name="George Harrison")
  5. >>> # 无效
  6. >>> beatles.members.set([john, paul, ringo, george])

为什么？因为上面的方法无法提供加入时间、邀请原因等中间模型需要的字段内容。唯一的办法只能是通过创建中间模型的实例来创建这种类型的多对多关联。但是，clear()方法是有效的，它能清空所有的多对多关系。

  1. >>> # 甲壳虫乐队解散了
  2. >>> beatles.members.clear()
  3. >>> # 删除了中间模型的对象
  4. >>> Membership.objects.all()
  5. <QuerySet []>

一旦你通过创建中间模型实例的方法建立了多对多的关联，你立刻就可以像普通的多对多那样进行查询操作：

  1. # 查找组内有Paul这个人的所有的组（以Paul开头的名字）
  2. >>> Group.objects.filter(members__name__startswith='Paul')
  3. <QuerySet [<Group: The Beatles>]>

可以使用中间模型的属性进行查询：

  1. # 查找甲壳虫乐队中加入日期在1961年1月1日之后的成员
  2. >>> Person.objects.filter(
  3. ... group__name='The Beatles',
  4. ... membership__date_joined__gt=date(1961,1,1))
  5. <QuerySet [<Person: Ringo Starr]>

可以像普通模型一样使用中间模型：

  1. >>> ringos_membership = Membership.objects.get(group=beatles, person=ringo)
  2. >>> ringos_membership.date_joined
  3. datetime.date(1962, 8, 16)
  4. >>> ringos_membership.invite_reason
  5. 'Needed a new drummer.'
  6. >>> ringos_membership = ringo.membership_set.get(group=beatles)
  7. >>> ringos_membership.date_joined
  8. datetime.date(1962, 8, 16)
  9. >>> ringos_membership.invite_reason
  10. 'Needed a new drummer.'

这一部分内容，需要结合后面的模型query，如果暂时看不懂，没有关系。

对于中间表，有一点要注意（在前面章节已经介绍过，再次重申一下），默认情况下，中间模型只能包含一个指向源模型的外键关系，上面例子中，也就是在Membership中只能有Person和Group外键关系各一个，不能多。否则，你必须显式的通过ManyToManyField.through_fields参数指定关联的对象。参考下面的例子：

  1. from django.db import models
  3. class Person(models.Model):
  4.     name = models.CharField(max_length=50)
  6. class Group(models.Model):
  7.     name = models.CharField(max_length=128)
  8.     members = models.ManyToManyField(
  9.     Person,
  10.     through='Membership',
  11.     through_fields=('group', 'person'),
  12.     )
  14. class Membership(models.Model):
  15.     group = models.ForeignKey(Group, on_delete=models.CASCADE)
  16.     person = models.ForeignKey(Person, on_delete=models.CASCADE)
  17.     inviter = models.ForeignKey(
  18.     Person,
  19.     on_delete=models.CASCADE,
  20.     related_name="membership_invites",
  21.     )
  22.     invite_reason = models.CharField(max_length=64)