Getting Help

el
en
es
fr
id
it
ko
pl
pt-br
zh-hans
Language: ja

1.10
1.11
2.0
2.1
2.2
3.0
3.1
3.2
4.0
4.1
5.0
5.1
dev
Documentation version: 4.2

モデルインスタンスリファレンス¶

このドキュメントでは、Model API の詳細を説明しています。モデルとデータベースクエリガイドにある説明を前提としていますので、このドキュメントを読む前にこの 2 つを読んでおいた方がよいでしょう。

このリファレンスでは、データベースクエリガイドで提供された Blogモデルの例を使用します。

オブジェクトを作成する¶

To create a new instance of a model, instantiate it like any other Python class:

class Model(**kwargs)¶

The keyword arguments are the names of the fields you've defined on your model. Note that instantiating a model in no way touches your database; for that, you need to save().

注釈

You may be tempted to customize the model by overriding the __init__ method. If you do so, however, take care not to change the calling signature as any change may prevent the model instance from being saved. Additionally, referring to model fields within __init__ may potentially result in infinite recursion errors in some circumstances. Rather than overriding __init__, try using one of these approaches:

モデルクラスにクラスメソッドを追加する:

from django.db import models


class Book(models.Model):
    title = models.CharField(max_length=100)

    @classmethod
    def create(cls, title):
        book = cls(title=title)
        # do something with the book
        return book


book = Book.create("Pride and Prejudice")

独自のマネジャーにメソッドを追加する (通常推奨される方法です):

class BookManager(models.Manager):
    def create_book(self, title):
        book = self.create(title=title)
        # do something with the book
        return book


class Book(models.Model):
    title = models.CharField(max_length=100)

    objects = BookManager()


book = Book.objects.create_book("Pride and Prejudice")

モデルの読み込みをカスタマイズする¶

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 の値が設定されています。

In addition to creating the new model, the from_db() method must set the adding and db flags in the new instance's _state attribute.

以下はデータベースから読みだされたフィールドの初期値をどのように保存しているのかについてを示した例です:

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
        ]
    instance = 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, (value for value in values if value is not DEFERRED))
    )
    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)

The example above shows a full from_db() implementation to clarify how that is done. In this case it would be possible to use a super() call in the from_db() method.

データベースからオブジェクトを再読み込みする¶

If you delete a field from a model instance, accessing it again reloads the value from the database:

>>> obj = MyModel.objects.first()
>>> del obj.field
>>> obj.field  # Loads the field from the database

Model.refresh_from_db(using=None, fields=None)¶

Model.arefresh_from_db(using=None, fields=None)¶

Asynchronous version: arefresh_from_db()

データベースからモデルの値を再読み込みする必要が有る場合は、 refresh_from_db() メソッドを利用できます。引数なしでこのメソッドを呼び出した場合は以下の処理が行われます:

モデル上の遅延評価されない全てのフィールドはその時点でデータベース上に存在する値に更新されます。
Any cached relations are cleared from the reloaded instance.

データベースからはフィールドのみが再読み込みされます。それ以外のアノテーションのようなデータベース依存の値は更新されません。いずれの @cached_property 属性等も同様にクリアされる事はありません。

再読み込みはインスタンスを読み込むデータベースから、もしくはインスタンスがデータベースから読み込まれない場合はデフォルトのデータベースから行われます。 using 引数は再読み込みを行うデータベースを強制的に設定する際に用いることができます。

読み込むフィールドのセットを強制的に設定するには fields 引数を用いる事ができます。

例えば、update() の呼び出しによって期待する更新が行われたかをテストするため、以下のようなテストを書くことができます:

def test_update_result(self):
    obj = MyModel.objects.create(val=1)
    MyModel.objects.filter(pk=obj.pk).update(val=F("val") + 1)
    # At this point obj.val is still 1, but the value in the database
    # was updated to 2. The object's updated value needs to be reloaded
    # from the database.
    obj.refresh_from_db()
    self.assertEqual(obj.val, 2)

遅延評価されているフィールドにアクセスした場合、その遅延評価されるフィールドの読み込みはこのメソッドを経由する事に注意してください。そのため遅延評価の読み込みがどのように行われるかを独自に設定する事が可能です。以下の例は遅延評価するフィールドが再読み込みされた時どのようにしてインスタンス上のフィールド全てを再読み込みできるかを示しています:

class ExampleModel(models.Model):
    def refresh_from_db(self, using=None, fields=None, **kwargs):
        # fields contains the name of the deferred field to be
        # loaded.
        if fields is not None:
            fields = set(fields)
            deferred_fields = self.get_deferred_fields()
            # If any deferred field is going to be loaded
            if fields.intersection(deferred_fields):
                # then load all of them
                fields = fields.union(deferred_fields)
        super().refresh_from_db(using, fields, **kwargs)

Model.get_deferred_fields()¶

対象となるモデルにおいて現在評価を遅延している全てのフィールドの属性名を持った集合を返すヘルパーメソッドです。

Changed in Django 4.2:

arefresh_from_db() method was added.

オブジェクトを検証 (バリデーション) する¶

There are four steps involved in validating a model:

モデルフィールドを検証する - Model.clean_fields()
モデル全体を検証する - Model.clean()
フィールドの一意性を検証する - Model.validate_unique()
Validate the constraints - Model.validate_constraints()

All four steps are performed when you call a model's full_clean() method.

ModelForm を使っているとき、is_valid() の呼び出しは、フォーム上に含まれる全てのフィールドに対して、これらの検証ステップを実行します。詳しくは ModelForm ドキュメントを参照してください。検証エラーを自分でコントロールしたい場合、もしくは ModelForm から検証を必要とするフィールドを除外した場合は、モデルの full_clean() メソッドだけを呼び出す必要があります。

警告

Constraints containing JSONField may not raise validation errors as key, index, and path transforms have many database-specific caveats. This may be fully supported later.

You should always check that there are no log messages, in the django.db.models logger, like "Got a database error calling check() on …" to confirm it's validated properly.

Changed in Django 4.1:

In older versions, constraints were not checked during the model validation.

Model.full_clean(exclude=None, validate_unique=True, validate_constraints=True)¶

This method calls Model.clean_fields(), Model.clean(), Model.validate_unique() (if validate_unique is True), and Model.validate_constraints() (if validate_constraints is True) in that order and raises a ValidationError that has a message_dict attribute containing errors from all four stages.

The optional exclude argument can be used to provide a set of field names that can be excluded from validation and cleaning. ModelForm uses this argument to exclude fields that aren't present on your form from being validated since any errors raised could not be corrected by the user.

モデルの save() メソッドを呼んだときでも full_clean() は自動的に 呼ばれない ことに注意してください。手動で作ったモデルに対して 1 ステップでモデル検証をしたいときには、手動で呼び出す必要があります。例えば:

from django.core.exceptions import ValidationError

try:
    article.full_clean()
except ValidationError as e:
    # Do something based on the errors contained in e.message_dict.
    # Display them to a user, or handle them programmatically.
    pass

full_clean() が行う最初のステップは、個々のフィールドをそれぞれクリーニングすることです。

Changed in Django 4.1:

The validate_constraints argument was added.

Changed in Django 4.1:

An exclude value is now converted to a set rather than a list.

Model.clean_fields(exclude=None)¶

This method will validate all fields on your model. The optional exclude argument lets you provide a set of field names to exclude from validation. It will raise a ValidationError if any fields fail validation.

full_clean() の第二段階では Model.clean() を呼び出します。このメソッドはモデル独自のバリデーションにオーバーライドされます。

Model.clean()¶

このメソッドは、独自のモデルバリデーションを提供するために使い、必要な場合はモデルの属性を修正できます。例えば、フィールドに対して自動的に値を提供したり、複数のフィールドにアクセスする必要のガルバリデーションを実施できます:

import datetime
from django.core.exceptions import ValidationError
from django.db import models
from django.utils.translation import gettext_lazy as _


class Article(models.Model):
    ...

    def clean(self):
        # Don't allow draft entries to have a pub_date.
        if self.status == "draft" and self.pub_date is not None:
            raise ValidationError(_("Draft entries may not have a publication date."))
        # Set the pub_date for published items if it hasn't been set already.
        if self.status == "published" and self.pub_date is None:
            self.pub_date = datetime.date.today()

ただし、Model.full_clean() と同様に、モデルの clean() メソッドは、save() メソッドが呼ばれたときには実行されないことに注意してください。

上の例では、Model.clean() により発生した ValidationError 例外は文字列によりインスタンス化されていたので、特別なエラーディクショナリのキー NON_FIELD_ERRORS に保存されます。このキーは、特定のフィールドではなくモデル全体に関連付けられたエラーに使用します:

from django.core.exceptions import NON_FIELD_ERRORS, ValidationError

try:
    article.full_clean()
except ValidationError as e:
    non_field_errors = e.message_dict[NON_FIELD_ERRORS]

例外を特定のフィールドにアサインするには、ディクショナリで ValidationError をインスタンス化し、キーにフィールド名を指定してください。上記の例を変更して、pub_date フィールドにエラーをアサインします:

class Article(models.Model):
    ...

    def clean(self):
        # Don't allow draft entries to have a pub_date.
        if self.status == "draft" and self.pub_date is not None:
            raise ValidationError(
                {"pub_date": _("Draft entries may not have a publication date.")}
            )
        ...

Model.clean() 実施中に複数フィールドでエラーを発見した場合、ディクショナリを渡してエラーにフィールド名をマップすることもできます:

raise ValidationError(
    {
        "title": ValidationError(_("Missing title."), code="required"),
        "pub_date": ValidationError(_("Invalid date."), code="invalid"),
    }
)

Then, full_clean() will check unique constraints on your model.

ModelForm 内に表示されないフィールドに対してフィールド特有のバリデーションエラーを発生させる方法

(Meta.fields や Meta.exclude で制限されて) モデルフォームに表示されないフィールドに対して Model.clean() 内でバリデーションエラーを発生させることはできません。やろうとしても、ValueError が発生します。これは、バリデーションエラーが除外されたフィールドと関連付けることができないからです。

このジレンマに対応するには、Model.clean_fields() をオーバーライドすることです。これはバリデーションから除外されたフィールドのリストを受け取ります。例えば:

class Article(models.Model):
    ...

    def clean_fields(self, exclude=None):
        super().clean_fields(exclude=exclude)
        if self.status == "draft" and self.pub_date is not None:
            if exclude and "status" in exclude:
                raise ValidationError(
                    _("Draft entries may not have a publication date.")
                )
            else:
                raise ValidationError(
                    {
                        "status": _(
                            "Set status to draft if there is not a " "publication date."
                        ),
                    }
                )

Model.validate_unique(exclude=None)¶

This method is similar to clean_fields(), but validates uniqueness constraints defined via Field.unique, Field.unique_for_date, Field.unique_for_month, Field.unique_for_year, or Meta.unique_together on your model instead of individual field values. The optional exclude argument allows you to provide a set of field names to exclude from validation. It will raise a ValidationError if any fields fail validation.

UniqueConstraints defined in the Meta.constraints are validated by Model.validate_constraints().

validate_unique() で exclude 引数を指定した場合、そのうちの 1 つでも含む unique_together 制限はチェックされません。

Finally, full_clean() will check any other constraints on your model.

Changed in Django 4.1:

In older versions, UniqueConstraints were validated by validate_unique().

Model.validate_constraints(exclude=None)¶

New in Django 4.1.

This method validates all constraints defined in Meta.constraints. The optional exclude argument allows you to provide a set of field names to exclude from validation. It will raise a ValidationError if any constraints fail validation.

オブジェクトを保存する¶

データベースにオブジェクトを保存し直すには、save() を呼び出します:

Model.save(force_insert=False, force_update=False, using=DEFAULT_DB_ALIAS, update_fields=None)¶

Model.asave(force_insert=False, force_update=False, using=DEFAULT_DB_ALIAS, update_fields=None)¶

Asynchronous version: asave()

For details on using the force_insert and force_update arguments, see INSERT や UPDATE を強制する. Details about the update_fields argument can be found in the どのフィールドを保存するか指定する section.

保存の動作をカスタマイズしたい場合は、save() メソッドをオーバーライドできます。詳しくは定義済みのモデルメソッドをオーバーライドするを参照してください。

モデル保存のプロセスには、いくつかの細かな注意点もあります; 以下の各セクションを参照してください。

Changed in Django 4.2:

asave() method was added.

自動インクリメントのプライマリキー¶

If a model has an AutoField — an auto-incrementing primary key — then that auto-incremented value will be calculated and saved as an attribute on your object the first time you call save():

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

There's no way to tell what the value of an ID will be before you call save(), because that value is calculated by your database, not by Django.

For convenience, each model has an AutoField named id by default unless you explicitly specify primary_key=True on a field in your model. See the documentation for AutoField for more details.

`pk` プロパティ¶

Model.pk¶

Regardless of whether you define a primary key field yourself, or let Django supply one for you, each model will have a property called pk. It behaves like a normal attribute on the model, but is actually an alias for whichever attribute is the primary key field for the model. You can read and set this value, just as you would for any other attribute, and it will update the correct field in the model.

Explicitly specifying auto-primary-key values¶

If a model has an AutoField but you want to define a new object's ID explicitly when saving, define it explicitly before saving, rather than relying on the auto-assignment of the ID:

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

If you assign auto-primary-key values manually, make sure not to use an already-existing primary-key value! If you create a new object with an explicit primary-key value that already exists in the database, Django will assume you're changing the existing record rather than creating a new one.

Given the above 'Cheddar Talk' blog example, this example would override the previous record in the database:

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

See How Django knows to UPDATE vs. INSERT, below, for the reason this happens.

Explicitly specifying auto-primary-key values is mostly useful for bulk-saving objects, when you're confident you won't have primary-key collision.

If you're using PostgreSQL, the sequence associated with the primary key might need to be updated; see Manually-specifying values of auto-incrementing primary keys.

What happens when you save?¶

When you save an object, Django performs the following steps:

Emit a pre-save signal. The pre_save signal is sent, allowing any functions listening for that signal to do something.
Preprocess the data. Each field's pre_save() method is called to perform any automated data modification that's needed. For example, the date/time fields override pre_save() to implement auto_now_add and auto_now.
Prepare the data for the database. Each field's get_db_prep_save() method is asked to provide its current value in a data type that can be written to the database.

Most fields don't require data preparation. Simple data types, such as integers and strings, are 'ready to write' as a Python object. However, more complex data types often require some modification.

For example, DateField fields use a Python datetime object to store data. Databases don't store datetime objects, so the field value must be converted into an ISO-compliant date string for insertion into the database.
Insert the data into the database. The preprocessed, prepared data is composed into an SQL statement for insertion into the database.
Emit a post-save signal. The post_save signal is sent, allowing any functions listening for that signal to do something.

Django が UPDATE と INSERT を見分ける方法¶

You may have noticed Django database objects use the same save() method for creating and changing objects. Django abstracts the need to use INSERT or UPDATE SQL statements. Specifically, when you call save() and the object's primary key attribute does not define a default, Django follows this algorithm:

オブジェクトのプライマリキー属性が True と評価される値にセットされている場合 (例えば None や空の文字列以外の場合)。Django は UPDATE を実行します。
If the object's primary key attribute is not set or if the UPDATE didn't update anything (e.g. if primary key is set to a value that doesn't exist in the database), Django executes an INSERT.

If the object's primary key attribute defines a default then Django executes an UPDATE if it is an existing model instance and primary key is set to a value that exists in the database. Otherwise, Django executes an INSERT.

ここで重要なのは、そのプライマリキーが使われていないことが保証できない場合、新しいオブジェクトを保存するときに明示的にプライマリキーの値を指定しないように気をつけることです。このニュアンスについては、上述の自動プライマリキーの値を明示的に指定すると下記の INSERT や UPDATE を強制するを参照してください。

In Django 1.5 and earlier, Django did a SELECT when the primary key attribute was set. If the SELECT found a row, then Django did an UPDATE, otherwise it did an INSERT. The old algorithm results in one more query in the UPDATE case. There are some rare cases where the database doesn't report that a row was updated even if the database contains a row for the object's primary key value. An example is the PostgreSQL ON UPDATE trigger which returns NULL. In such cases it is possible to revert to the old algorithm by setting the select_on_save option to True.

INSERT や UPDATE を強制する¶

In some rare circumstances, it's necessary to be able to force the save() method to perform an SQL INSERT and not fall back to doing an UPDATE. Or vice-versa: update, if possible, but not insert a new row. In these cases you can pass the force_insert=True or force_update=True parameters to the save() method. Passing both parameters is an error: you cannot both insert and update at the same time!

これらのパラメータを必要とするのは、まれであるべきです。Django は、ほとんどの場合で正しく処理を行い、オーバーライドしようとすると追跡が難しいエラーの原因となります。この機能は応用的な場合のみに使用してください。

update_fields を使うと force_update と同じように更新を強制します。

既存のフィールドに基づいて属性を更新する¶

Sometimes you'll need to perform a simple arithmetic task on a field, such as incrementing or decrementing the current value. One way of achieving this is doing the arithmetic in Python like:

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

データベースから取得した古い number_sold の値は 10 でした。そして、11 という値がデータベースに書き直されます。

The process can be made robust, avoiding a race condition, as well as slightly faster by expressing the update relative to the original field value, rather than as an explicit assignment of a new value. Django provides F expressions for performing this kind of relative update. Using F expressions, the previous example is expressed as:

>>> 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 内でフィールドリストの名前が渡された場合、このリスト内で指定されたフィールドだけが更新されます。これは、オブジェクトの 1 つないし少数のフィールドだけを更新したい場合に望ましいでしょう。データベースで全てのモデルフィールドを更新しないようにすると、実行速度が少し向上します。例えば:

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

The update_fields argument can be any iterable containing strings. An empty update_fields iterable will skip the save. A value of None will perform an update on all fields.

update_fields を指定すると更新を強制します。

遅延モデルローディング (only() や defer()) を通してフェッチされたモデルを保存するとき、DB からロードされたフィールドだけが更新されます。実際には、このケースでは自動的な update_fields が存在します。遅延フィールドの値を追加もしくは変更した場合、フィールドは更新されたフィールドに追加されます。

Field.pre_save() and update_fields

If update_fields is passed in, only the pre_save() methods of the update_fields are called. For example, this means that date/time fields with auto_now=True will not be updated unless they are included in the update_fields.

オブジェクトを削除する¶

Model.delete(using=DEFAULT_DB_ALIAS, keep_parents=False)¶

Model.adelete(using=DEFAULT_DB_ALIAS, keep_parents=False)¶

Asynchronous version: adelete()

Issues an SQL DELETE for the object. This only deletes the object in the database; the Python instance will still exist and will still have data in its fields, except for the primary key set to None. This method returns the number of objects deleted and a dictionary with the number of deletions per object type.

より詳しく (まとめてオブジェクトを削除する方法を含む) については、オブジェクトを削除するを参照してください。

独自の削除動作がほしいときは、delete() メソッドをオーバーライドすることができます。詳しくは定義済みのモデルメソッドをオーバーライドするを参照してください。

Sometimes with multi-table inheritance you may want to delete only a child model's data. Specifying keep_parents=True will keep the parent model's data.

Changed in Django 4.2:

adelete() method was added.

Pickling objects¶

When you pickle a model, its current state is pickled. When you unpickle it, it'll contain the model instance at the moment it was pickled, rather than the data that's currently in the database.

バージョン間でpickle化されたデータを共有することはできません

Pickles of models are only valid for the version of Django that was used to generate them. If you generate a pickle using Django version N, there is no guarantee that pickle will be readable with Django version N+1. Pickles should not be used as part of a long-term archival strategy.

pickle の互換性エラーは、静的に衝突したオブジェクトのように判定が難しいことがあるので、モデルをpickle化したデータを別のバージョンで復元しようとすると RuntimeWarning が送出されます。

Other model instance methods¶

A few object methods have special purposes.

`str()`¶

Model.__str__()¶

The __str__() method is called whenever you call str() on an object. Django uses str(obj) in a number of places. Most notably, to display an object in the Django admin site and as the value inserted into a template when it displays an object. Thus, you should always return a nice, human-readable representation of the model from the __str__() method.

例:

from django.db import models


class Person(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)

    def __str__(self):
        return f"{self.first_name} {self.last_name}"

`eq()`¶

Model.__eq__()¶

The equality method is defined such that instances with the same primary key value and the same concrete class are considered equal, except that instances with a primary key value of None aren't equal to anything except themselves. For proxy models, concrete class is defined as the model's first non-proxy parent; for all other models it's simply the model's class.

例:

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)
# Primary 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__()¶

The __hash__() method is based on the instance's primary key value. It is effectively hash(obj.pk). If the instance doesn't have a primary key value then a TypeError will be raised (otherwise the __hash__() method would return different values before and after the instance is saved, but changing the __hash__() value of an instance is forbidden in Python.

`get_absolute_url()`¶

Model.get_absolute_url()¶

オブジェクトに対する正式な URL を計算する方法は、get_absolute_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-detail", kwargs={"pk": self.pk})

Django が get_absolute_url() を使う場所の一つが、admin アプリです。オブジェクトにこのメソッドが定義されている場合、オブジェクト編集のページは "View on site" リンクを持つようになり、get_absolute_url() で定義された通りオブジェクトの公開用ビューに直接飛べるようになります。

同様に、Django の他にもいくつか、get_absolute_url() が定義されている場合に使用するものがあります (syndication feed framework など)。各モデルインスタンスがユニークな URL を持つことが適切な場合、get_absolute_url() を定義すべきです。

警告

リダイレクトポイズニングの可能性を減らすため、検証されていないユーザーの入力を利用した URL の生成は避けてください。

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

self.name が '/example.com' の場合、上記は '//example.com/' を返します。これは有効な schema relative URL ですが、期待されていた '/%2Fexample.com/' ではありません。

テンプレート内で、ハードコーディングしたオブジェクトの URL ではなく get_absolute_url() を使うのは良い実装方法です。以下のテンプレートコードは悪い例です:

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

以下のテンプレートコードは改善例です:

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

The logic here is that if you change the URL structure of your objects, even for something small like correcting a spelling error, you don't want to have to track down every place that the URL might be created. Specify it once, in get_absolute_url() and have all your other code call that one place.

注釈

The string you return from get_absolute_url() must contain only ASCII characters (required by the URI specification, RFC 3986#section-2) and be URL-encoded, if necessary.

Code and templates calling get_absolute_url() should be able to use the result directly without any further processing. You may wish to use the django.utils.encoding.iri_to_uri() function to help with this if you are using strings containing characters outside the ASCII range.

Extra instance methods¶

In addition to save(), delete(), a model object might have some of the following methods:

Model.get_FOO_display()¶

For every field that has choices set, the object will have a get_FOO_display() method, where FOO is the name of the field. This method returns the "human-readable" value of the field.

例:

from django.db import models


class Person(models.Model):
    SHIRT_SIZES = [
        ("S", "Small"),
        ("M", "Medium"),
        ("L", "Large"),
    ]
    name = models.CharField(max_length=60)
    shirt_size = models.CharField(max_length=2, choices=SHIRT_SIZES)

>>> p = Person(name="Fred Flintstone", shirt_size="L")
>>> p.save()
>>> p.shirt_size
'L'
>>> p.get_shirt_size_display()
'Large'

Model.get_next_by_FOO(**kwargs)¶

Model.get_previous_by_FOO(**kwargs)¶

For every DateField and DateTimeField that does not have null=True, the object will have get_next_by_FOO() and get_previous_by_FOO() methods, where FOO is the name of the field. This returns the next and previous object with respect to the date field, raising a DoesNotExist exception when appropriate.

Both of these methods will perform their queries using the default manager for the model. If you need to emulate filtering used by a custom manager, or want to perform one-off custom filtering, both methods also accept optional keyword arguments, which should be in the format described in Field lookups.

Note that in the case of identical date values, these methods will use the primary key as a tie-breaker. This guarantees that no records are skipped or duplicated. That also means you cannot use those methods on unsaved objects.

Overriding extra instance methods

In most cases overriding or inheriting get_FOO_display(), get_next_by_FOO(), and get_previous_by_FOO() should work as expected. Since they are added by the metaclass however, it is not practical to account for all possible inheritance structures. In more complex cases you should override Field.contribute_to_class() to set the methods you need.

Other attributes¶

`_state`¶

Model._state¶

The _state attribute refers to a ModelState object that tracks the lifecycle of the model instance.

The ModelState object has two attributes: adding, a flag which is True if the model has not been saved to the database yet, and db, a string referring to the database alias the instance was loaded from or saved to.

Newly instantiated instances have adding=True and db=None, since they are yet to be saved. Instances fetched from a QuerySet will have adding=False and db set to the alias of the associated database.

Model Meta options

QuerySet API リファレンス

ドキュメント

モデルインスタンスリファレンス¶

オブジェクトを作成する¶

モデルの読み込みをカスタマイズする¶

データベースからオブジェクトを再読み込みする¶

オブジェクトを検証 (バリデーション) する¶

オブジェクトを保存する¶

自動インクリメントのプライマリキー¶

`pk` プロパティ¶

Explicitly specifying auto-primary-key values¶

What happens when you save?¶

Django が UPDATE と INSERT を見分ける方法¶

INSERT や UPDATE を強制する¶

既存のフィールドに基づいて属性を更新する¶

どのフィールドを保存するか指定する¶

オブジェクトを削除する¶

Pickling objects¶

Other model instance methods¶

`str()`¶

`eq()`¶

`hash()`¶

`get_absolute_url()`¶

Extra instance methods¶

Other attributes¶

`_state`¶

Additional Information

Support Django!

Contents

Browse

You are here:

Getting help

Download:

Django Links

Learn More

Get Involved

Get Help

Follow Us

Support Us

ドキュメント

モデルインスタンスリファレンス¶

オブジェクトを作成する¶

モデルの読み込みをカスタマイズする¶

データベースからオブジェクトを再読み込みする¶

オブジェクトを検証 (バリデーション) する¶

オブジェクトを保存する¶

自動インクリメントのプライマリキー¶

pk プロパティ¶

Explicitly specifying auto-primary-key values¶

What happens when you save?¶

Django が UPDATE と INSERT を見分ける方法¶

INSERT や UPDATE を強制する¶

既存のフィールドに基づいて属性を更新する¶

どのフィールドを保存するか指定する¶

オブジェクトを削除する¶

Pickling objects¶

Other model instance methods¶

__str__()¶

__eq__()¶

__hash__()¶

get_absolute_url()¶

Extra instance methods¶

Other attributes¶

_state¶

Additional Information

Support Django!

Contents

Browse

You are here:

Getting help

Download:

`pk` プロパティ¶

`str()`¶

`eq()`¶

`hash()`¶

`get_absolute_url()`¶

`_state`¶