关于Django外键赋值问题详解_Python

关于Django外键赋值问题详解

2020-12-01 00:48Youmai Python

这段时间用django 做程序用到了一对多的关系的操作，下面分享一些心得体会，这篇文章主要给大家介绍了关于Django外键赋值问题的相关资料，需要的朋友可以参考借鉴，下面来一起看看吧。

本文主要给大家介绍关于Django 外键赋值的相关内容，分享出来供大家参考学习，在开始之前，我们先来看一段代码：

									class Article(models.Model):

									 title = models.CharField(max_length=1024, default='')

									 ...

									 def __str__(self):

									  return 'Article pk:%d %s' % (self.pk, self.title[:30])

									class ArticleContent(models.Model):

									 article = cached_fields.OneToOneField(Article)

									 ...

写代码的的时候，发现了一个很奇怪的现象，当我给一个instance的外键（以_id结尾）赋值（数字）的时候，这个外键对应的instance的值并不会改变。

									In [44]: ac = ArticleContent.objects.get(article_id=14269)

									In [45]: ac.article_id

									Out[45]: 14269

									In [46]: ac.article_id = 14266

									In [47]: ac.save()

									In [48]: ac.article

									Out[48]: <Article: Article pk:14266 EC: Russia, Ukraine to Meet in>

									In [49]: ac.article.pk

									Out[49]: 14266

如上面的代码所示，为了找到答案，我翻了一下Django的源码：

									django/db/models/fields/related_descriptors.py 

									  def __get__(self, instance, cls=None):

									   """

									   Get the related instance through the forward relation.

									   With the example above, when getting ``child.parent``:

									   - ``self`` is the descriptor managing the ``parent`` attribute

									   - ``instance`` is the ``child`` instance

									   - ``cls`` is the ``Child`` class (we don't need it)

									   """

									   if instance is None:

									    return self

									   # The related instance is loaded from the database and then cached in

									   # the attribute defined in self.cache_name. It can also be pre-cached

									   # by the reverse accessor (ReverseOneToOneDescriptor).

									   try:

									    rel_obj = getattr(instance, self.cache_name)

									   except AttributeError:

									    val = self.field.get_local_related_value(instance)

									    if None in val:

									     rel_obj = None

									    else:

									     qs = self.get_queryset(instance=instance)

									     qs = qs.filter(self.field.get_reverse_related_filter(instance))

									     # Assuming the database enforces foreign keys, this won't fail.

									     rel_obj = qs.get()

									     # If this is a one-to-one relation, set the reverse accessor

									     # cache on the related object to the current instance to avoid

									     # an extra SQL query if it's accessed later on.

									     if not self.field.remote_field.multiple:

									      setattr(rel_obj, self.field.remote_field.get_cache_name(), instance)

									    setattr(instance, self.cache_name, rel_obj)

									   if rel_obj is None and not self.field.null:

									    raise self.RelatedObjectDoesNotExist(

									     "%s has no %s." % (self.field.model.__name__, self.field.name)

									    )

									   else:

									    return rel_obj