模型实例引用¶

自定义模型加载¶

classmethod Model.from_db(db, field_names, values)[源代码]¶

from_db() 方法可用于在从数据库加载时自定义模型实例创建。

db 参数包含用于加载模型的数据库的数据库别名，field_names 包含所有加载字段的名称，values 包含 field_names 中每个字段的加载值。 field_names 与 values 的顺序相同。如果所有模型的字段都存在，那么 values 保证为 __init__() 期望它们的顺序。也就是说，实例可以由 cls(*values) 创建。如果任何字段被延迟，它们不会出现在 field_names 中。在这种情况下，请为每个缺少的字段分配一个 django.db.models.DEFERRED 值。

除了创建新模型，from_db() 方法必须在新实例的 _state 属性中设置 adding 和 db 标志。

下面是一个示例，显示如何记录从数据库加载的字段的初始值:

from django.db.models import DEFERRED

@classmethod
def from_db(cls, db, field_names, values):
    # Default implementation of from_db() (subject to change and could
    # be replaced with super()).
    if len(values) != len(cls._meta.concrete_fields):
        values = list(values)
        values.reverse()
        values = [
            values.pop() if f.attname in field_names else DEFERRED
            for f in cls._meta.concrete_fields
        ]
    new = cls(*values)
    instance._state.adding = False
    instance._state.db = db
    # customization to store the original field values on the instance
    instance._loaded_values = dict(zip(field_names, values))
    return instance

def save(self, *args, **kwargs):
    # Check how the current values differ from ._loaded_values. For example,
    # prevent changing the creator_id of the model. (This example doesn't
    # support cases where 'creator_id' is deferred).
    if not self._state.adding and (
            self.creator_id != self._loaded_values['creator_id']):
        raise ValueError("Updating the value of creator isn't allowed")
    super(...).save(*args, **kwargs)

上面的例子显示了一个完整的 from_db() 实现，以澄清如何做。在这种情况下，当然可以在 from_db() 方法中使用 super() 调用。

自动递增主键¶

如果一个模型有一个 AutoField - 一个自动递增的主键，那么该自动递增的值将被计算并保存为您的对象的属性，第一次调用 save():

>>> b2 = Blog(name='Cheddar Talk', tagline='Thoughts on cheese.')
>>> b2.id     # Returns None, because b doesn't have an ID yet.
>>> b2.save()
>>> b2.id     # Returns the ID of your new object.

在调用 save() 之前，无法确定ID的值，因为该值由数据库计算，而不是由Django计算。

为了方便起见，每个模型都默认有一个名为 id 的 AutoField，除非您在模型中的字段上明确指定了 primary_key=True。有关更多详细信息，请参阅 AutoField 的文档。

>>> b3 = Blog(id=3, name='Cheddar Talk', tagline='Thoughts on cheese.')
>>> b3.id     # Returns 3.
>>> b3.save()
>>> b3.id     # Returns 3.

b4 = Blog(id=3, name='Not Cheddar', tagline='Anything but cheese.')
b4.save()  # Overrides the previous blog with ID=3!

保存时会发生什么？¶

当您保存对象时，Django会执行以下步骤：

1. 发出预保存信号。 发送 pre_save 信号，允许监听该信号的任何功能做某事。

2. 预处理数据。 调用每个字段的 pre_save() 方法来执行所需的任何自动数据修改。例如，日期/时间字段覆盖 pre_save() 以实现 auto_now_add 和 auto_now。

3. 准备数据库的数据。 要求每个字段的 get_db_prep_save() 方法在可以写入数据库的数据类型中提供其当前值。

   大多数字段不需要数据准备。简单的数据类型，如整数和字符串，是“准备写”作为一个Python对象。然而，更复杂的数据类型通常需要一些修改。

   例如，DateField 字段使用Python datetime 对象来存储数据。数据库不存储 datetime 对象，因此字段值必须转换为符合ISO的日期字符串以插入到数据库中。

4. 将数据插入数据库。 预处理的，准备好的数据被组成一个SQL语句以插入到数据库中。

5. 发出后保存信号。 发送 post_save 信号，允许监听该信号的任何功能做某事。

如何Django知道UPDATE与INSERT¶

您可能已经注意到，Django数据库对象使用相同的 save() 方法来创建和更改对象。 Django摘要需要使用 INSERT 或 UPDATE SQL语句。具体来说，当你调用 save() 时，Django遵循这个算法：

• 如果对象的主键属性设置为评估为 True 的值（即，非 None 或空字符串的值），Django将执行 UPDATE。

• 如果对象的主键属性是 not 集或如果 UPDATE 没有更新任何东西，Django执行 INSERT。

在这里得到的是，你应该注意不要在保存新对象时明确指定主键值，如果您不能保证主键值未被使用。有关这种细微差别的更多信息，请参阅上面的 Explicitly specifying auto-primary-key values 和下面的 Forcing an INSERT or UPDATE。

在Django 1.5和更早版本中，Django在设置主键属性时执行了 SELECT。如果 SELECT 找到一行，那么Django做了一个 UPDATE，否则它做了一个 INSERT。旧的算法导致在 UPDATE 情况下多一个查询。在一些罕见的情况下，数据库不报告行已更新，即使数据库包含对象主键值的行。一个例子是返回 NULL 的PostgreSQL ON UPDATE 触发器。在这种情况下，可以通过将 select_on_save 选项设置为 True 来还原为旧算法。

基于现有字段更新属性¶

有时，您需要在字段上执行简单的算术任务，例如递增或递减当前值。实现这一点的明显方法是做类似的事情:

>>> product = Product.objects.get(name='Venezuelan Beaver Cheese')
>>> product.number_sold += 1
>>> product.save()

如果从数据库检索的旧 number_sold 值为10，则值11将写回数据库。

通过表达相对于原始字段值的更新，而不是作为新值的显式赋值，可以使该过程变得鲁棒，避免竞争条件，以及略快。 Django提供 F expressions 来执行这种相对更新。使用 F expressions，前面的例子表示为:

>>> from django.db.models import F
>>> product = Product.objects.get(name='Venezuelan Beaver Cheese')
>>> product.number_sold = F('number_sold') + 1
>>> product.save()

有关更多详细信息，请参阅有关 F expressions 及其 在更新查询中使用 的文档。

指定要保存的字段¶

如果 save() 传递了关键字参数 update_fields 中的字段名称列表，则只会更新该列表中命名的字段。如果你想更新一个对象上的一个或几个字段，这可能是可取的。防止在数据库中更新所有模型字段将有轻微的性能优势。例如:

product.name = 'Name changed again'
product.save(update_fields=['name'])

update_fields 参数可以是任何包含字符串的iterable。空的 update_fields iterable将跳过保存。值为None将对所有字段执行更新。

指定 update_fields 将强制更新。

当保存通过延迟模型加载（only() 或 defer()）获取的模型时，只有从数据库加载的字段才会更新。实际上，在这种情况下存在自动 update_fields。如果分配或更改任何延迟字段值，该字段将添加到更新的字段。

__str__()¶

Model.__str__()[源代码]¶

每当您在对象上调用 str() 时，将调用 __str__() 方法。 Django在许多地方使用 str(obj)。最值得注意的是，在Django管理站点中显示对象，以及在显示对象时作为插入到模板中的值。因此，你应该总是从 __str__() 方法返回一个漂亮，人类可读的模型表示。

例如:

from django.db import models
from django.utils.encoding import python_2_unicode_compatible

@python_2_unicode_compatible  # only if you need to support Python 2
class Person(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)

    def __str__(self):
        return '%s %s' % (self.first_name, self.last_name)

如果你想与Python 2兼容，你可以使用 python_2_unicode_compatible() 来装饰模型类，如上所示。

__eq__()¶

Model.__eq__()[源代码]¶

相等方法被定义为使得具有相同主键值和相同具体类的实例被认为相等，除了具有主键值 None 的实例不等于除了它们本身之外的任何实例。对于代理模型，具体类被定义为模型的第一个非代理父类；对于所有其他模型，它只是模型的类。

例如:

from django.db import models

class MyModel(models.Model):
    id = models.AutoField(primary_key=True)

class MyProxyModel(MyModel):
    class Meta:
        proxy = True

class MultitableInherited(MyModel):
    pass

# Primary keys compared
MyModel(id=1) == MyModel(id=1)
MyModel(id=1) != MyModel(id=2)
# Primay keys are None
MyModel(id=None) != MyModel(id=None)
# Same instance
instance = MyModel(id=None)
instance == instance
# Proxy model
MyModel(id=1) == MyProxyModel(id=1)
# Multi-table inheritance
MyModel(id=1) != MultitableInherited(id=1)

__hash__()¶

Model.__hash__()[源代码]¶

__hash__() 方法基于实例的主键值。它是有效的 hash(obj.pk)。如果实例没有主键值，那么将引发 TypeError （否则 __hash__() 方法将在保存实例之前和之后返回不同的值，但在Python中禁止更改实例的 __hash__() 值。

get_absolute_url()¶

Model.get_absolute_url()¶

定义一个 get_absolute_url() 方法来告诉Django如何计算对象的规范URL。对于调用者，这个方法应该返回一个字符串，可以用来通过HTTP引用对象。

例如:

def get_absolute_url(self):
    return "/people/%i/" % self.id

虽然这段代码是正确和简单的，它可能不是最便携的方式来编写这种方法。 reverse() 函数通常是最好的方法。

例如:

def get_absolute_url(self):
    from django.urls import reverse
    return reverse('people.views.details', args=[str(self.id)])

Django使用 get_absolute_url() 的一个地方在管理应用程序中。如果一个对象定义了这个方法，对象编辑页面将有一个“View on site”链接，它将直接跳转到对象的公共视图，如 get_absolute_url() 所示。

类似地，Django的一些其他位，例如 联合馈送框架，在定义时使用 get_absolute_url()。如果模型的实例每个都有唯一的URL是有意义的，您应该定义 get_absolute_url()。

def get_absolute_url(self):
    return '/%s/' % self.name

最好在模板中使用 get_absolute_url()，而不是对对象的URL进行硬编码。例如，此模板代码是错误的：

<!-- BAD template code. Avoid! -->
<a href="/people/{{ object.id }}/">{{ object.name }}</a>

这个模板代码好多了：

<a href="{{ object.get_absolute_url }}">{{ object.name }}</a>

这里的逻辑是，如果您更改对象的URL结构，即使是一些简单的，如更正拼写错误，您不想跟踪每个可能创建的URL的地方。在 get_absolute_url() 中指定一次，并让所有其他代码调用一个地方。

DoesNotExist¶

exception Model.DoesNotExist¶

ORM在几个地方引发此异常，例如，当找不到给定查询参数的对象时，由 QuerySet.get() 引发。

Django提供了一个 DoesNotExist 异常作为每个模型类的属性来标识无法找到的对象类，并允许您使用 try/except 捕获特定的模型类。异常是 django.core.exceptions.ObjectDoesNotExist 的子类。