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

时间:2014-08-19 14:32:30

标签: python django many-to-many foreign-key-relationship one-to-one

我很难在Django模型中找到关系。

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

1 个答案:

答案 0 :(得分:88)

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

  1. 一对一,多对多和外键关系之间的区别(一般情况)
  2. 他们与Django有什么不同。
  3. 通过简单的Google搜索很容易回答这两个问题,但由于我无法在SO上找到这个问题的确切欺骗,我会继续回答。

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


    ForeignKey的

    外键关系通常称为多对一关系。请注意,这种关系的反向是一对多(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是你的朋友!):

    >> 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,&#34; Kiwi&#34;,&#34; blah_blah&#34;

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

    >> 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以访问多对多关系。

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

    • 订购:&#34;宇宙飞船&#34;,&#34; NASA&#34;
    • 订单:&#34;潜艇&#34;,&#34;美国海军&#34;
    • 订购:&#34;赛车&#34;,&#34; NASCAR&#34;
    • 项目:订单:[]
    • 项目:订单:[(订单:&#34;太空船&#34;,&#34; NASA&#34;)]
    • 项目:订单:[(订单:&#34; Spaceship&#34;,&#34; NASA&#34;),(订单:&#34;赛车&#34;,&#34; NASCAR&#34; )]

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

    >> 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图有点令人困惑的情况下,以下解释可能会有所帮助:

    • ><对许多人来说意味着&#34;
    • |表示&#34;到一个&#34;

    所以... A --| B表示A的实例只能与B的一个实例相关。

    A --< B表示A的实例可以与B的多个实例相关。

    A >--< B相当于....

    A --< B
    A >-- B
    

    因此,每个&#34; side&#34;或者关系的方向可以单独阅读。把它们挤在一起很方便。

    扩展其中一种关系可能更有意义:

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

    资源

    @MarcB提供的

    Good explanation of db relationships

    Wikipedia page on Cardinality

    Django Docs:

    models.ForeignKey

    models.OneToOneField

    models.ManyToManyField

    One-to-one Relationships

    Many-to-many Relationships