モデルは、データに関する単一の決定的な情報源です。これはあなたが保持するデータが必要とするフィールドと振る舞いについての情報を持ちます。一般的に、各モデルは単一のデータベースのテーブルに対応付けられます。
\n基本:
\nモデルは各々 Python のクラスであり django.db.models.Model のサブクラスです。
モデルの属性はそれぞれがデータベースのフィールドを表します。
これら全てを用いて、Django はデータベースにアクセスする自動生成された API を提供します。 Making queries を参照ください。
この例では first_name と last_name を持つ Person というモデルを定義しています:
from django.db import models\n\nclass Person(models.Model):\n first_name = models.CharField(max_length=30)\n last_name = models.CharField(max_length=30)\nfirst_name および last_name はこのモデルの フィールド です。各フィールドはクラスの属性として定義され、各属性はデータベースのカラムに関連付けられます。
上記の Person モデルは以下のようなデータベースのテーブルを作成します:
CREATE TABLE myapp_person (\n "id" serial NOT NULL PRIMARY KEY,\n "first_name" varchar(30) NOT NULL,\n "last_name" varchar(30) NOT NULL\n);\n技術的な注意点:
\nmyapp_person というテーブル名は、いくつかのモデルのメタデータから自動的に生成されますがそれを無効化する事ができます。詳細は Table names を参照ください。
id フィールドは自動的に追加されますが、この処理を無効化する事ができます。Automatic primary key fields を参照ください。
この例における CREATE TABLE の SQL は PostgreSQL の文法に準拠していますが、Django は 設定ファイル 内に定義されたデータベースバックエンドに応じた SQL を利用することに注意した方がよろしいでしょう。
一度モデルを定義した後は、Django にこれらのモデルを 利用する 事を知らせる必要が有ります。それは設定ファイルを編集して設定値 INSTALLED_APPS に、定義した models.py を含むモジュール名を追加する事で行えます。
例として、アプリケーションのモデルが myapp.models モジュール内に存在すれば(このパッケージ構造は manage.py startapp スクリプトによってアプリケーション内に構築される物です)、INSTALLED_APPS は一部を抜粋し、以下のように定義されている必要が有ります:
INSTALLED_APPS = [\n #...\n 'myapp',\n #...\n]\nINSTALLED_APPS 内に新たなアプリケーションを追加した場合、manage.py migrate を、初回は必要に応じて manage.py makemigrations を忘れずに実行してください。
モデルにおいて最も重要な箇所であり -- モデルにおいて唯一必須となっている箇所 -- それはそのモデルが定義するデータベースのフィールドの一覧になります。フィールドはクラスの属性として定義されます。フィールド名として clean、save あるいは delete のような models API で利用されている文字列を選び衝突しないように注意してください。
実装例:
\nfrom django.db import models\n\nclass Musician(models.Model):\n first_name = models.CharField(max_length=50)\n last_name = models.CharField(max_length=50)\n instrument = models.CharField(max_length=100)\n\nclass Album(models.Model):\n artist = models.ForeignKey(Musician, on_delete=models.CASCADE)\n name = models.CharField(max_length=100)\n release_date = models.DateField()\n num_stars = models.IntegerField()\nモデル内の各フィールドは適切に Field クラスのインスタンスとなっている必要が有ります。Django は利用しているフィールドクラスの型に応じて以下のような挙動を決定します:
カラムの型、データベースに保持するデータがどのような種別の物であるかを表します(例えば INTEGER、 VARCHAR、 TEXT 等です)。
フォーム領域をレンダリングする際に利用するデフォルトの HTML ウィジェット (例えば <input type="text">、 <select>)。
最低限必要とされる入力値確認、Django の管理機能と自動生成されるフォームにおいて利用されます。
Django は多くのフィールド型を内蔵しています; それらの完全な一覧は フィールドの型 で確認できます。もし Django に内蔵されたフィールドの型では実現できない機能を実装したい場合は独自のフィールドを簡単に記述できます; Writing custom model fields を参照してください。
\nフィールドはそれぞれあらかじめ定められたフィールド特有の引数 ( モデルのフィールド型一覧 にまとめられています) を受け取ります。例えば、CharField (およびそのサブクラス) はそのデータを保持するためにデータベース上に定義される VARCHAR 領域の長さを定義する引数 max_length を必要とします。
これらに加えてまた全てのフィールドの型で利用できる共通の引数が存在します。これらは全て入力が任意の物です。これらの引数についてはこちらの リファレンス 内で全て説明されていますが、ここにはそれらの内特に頻繁に用いられるものに関する概説を記述します:
\nnullTrue``の場合、Django はデータベース内に ``NULL として空の値を保持します。デフォルトは False です。
blankTrue の場合、フィールドはブランクになることが許容されます。デフォルトは False です。
null とは挙動が異なる事に注意してください。 blank がバリデーション由来である一方、 null は完全にデータベース由来です。あるフィールドが blank=True であれば、フォームのバリデーションは空の値の入力を許容します。あるフィールドが blank=False の場合は、そのフィールドへの入力は必須となります。
choicesフィールドの選択肢として用いられる 2 値のタプルのイテラブルなオブジェクト (例えばリストやタプル) です。このオプションが渡された場合、デフォルトのフォームウィジェットが標準のテキストフィールドからセレクトボックスに変わり与えられた選択肢のみに選択を制限します。
\n選択肢のリストは以下のようになります:
\nYEAR_IN_SCHOOL_CHOICES = (\n ('FR', 'Freshman'),\n ('SO', 'Sophomore'),\n ('JR', 'Junior'),\n ('SR', 'Senior'),\n ('GR', 'Graduate'),\n)\n各タプルの最初の要素はデータベースに保存される値となります。二番目の要素はデフォルトのフォームウィジェットあるいは ModelChoiceField 内で表示されます。モデルのインスタンスが存在する時、選択肢の値は get_FOO_display() のようなメソッドを使うことで参照できます。以下はその利用例です:
from django.db import models\n\nclass Person(models.Model):\n SHIRT_SIZES = (\n ('S', 'Small'),\n ('M', 'Medium'),\n ('L', 'Large'),\n )\n name = models.CharField(max_length=60)\n shirt_size = models.CharField(max_length=1, choices=SHIRT_SIZES)\n>>> p = Person(name="Fred Flintstone", shirt_size="L")\n>>> p.save()\n>>> p.shirt_size\n'L'\n>>> p.get_shirt_size_display()\n'Large'\ndefaultそのフィールドのデフォルト値です。このオプションには特定の値もしくは呼び出し可能オブジェクトを渡すことができます。もし渡した値が呼び出し可能であれば新しくオブジェクトが生成される度に呼び出されます。
\nhelp_textフォームウィジェットと共に表示される "補助" テキストになります。この値はフィールドがフォームとして利用されない場合でもドキュメント化する際に有用です。
\nprimary_keyTrue の場合、設定したフィールドはそのモデルの主キーとなります。
定義したモデル内でどのフィールドに対しても primary_key=True が設定されなかった場合、Django は自動的に主キーを保存するために IntegerField を追加します、つまりその主キーに対するデフォルトの動作を変更する必要がない場合はどのフィールドに対しても primary_key=True を設定する必要が有りません。
主キーとなったフィールドは読み込み専用となります。もし既存のオブジェクトの主キーの値を変更して保存する操作を行うと、既存のオブジェクトに加えて新たなオブジェクトが生成されます。以下に例を示します:
\nfrom django.db import models\n\nclass Fruit(models.Model):\n name = models.CharField(max_length=100, primary_key=True)\n>>> fruit = Fruit.objects.create(name='Apple')\n>>> fruit.name = 'Pear'\n>>> fruit.save()\n>>> Fruit.objects.values_list('name', flat=True)\n['Apple', 'Pear']\nuniqueTrue の場合、そのフィールドはテーブル上で一意となる制約を受けます。
繰り返しになりますが、これらは特によく利用されるフィールドのオプションの概説です。完全な説明は 共通のフィールドオプションの説明 で参照できます。
\nBy default, Django gives each model the following field:
\nid = models.AutoField(primary_key=True)\nThis is an auto-incrementing primary key.
\nIf you'd like to specify a custom primary key, just specify\nprimary_key=True on one of your fields. If Django\nsees you've explicitly set Field.primary_key, it won't add the automatic\nid column.
Each model requires exactly one field to have primary_key=True (either explicitly declared or automatically added).
Each field type, except for ForeignKey,\nManyToManyField and\nOneToOneField, takes an optional first positional\nargument -- a verbose name. If the verbose name isn't given, Django will\nautomatically create it using the field's attribute name, converting underscores\nto spaces.
In this example, the verbose name is "person's first name":
first_name = models.CharField("person's first name", max_length=30)\nIn this example, the verbose name is "first name":
first_name = models.CharField(max_length=30)\nForeignKey,\nManyToManyField and\nOneToOneField require the first argument to be a\nmodel class, so use the verbose_name keyword argument:
poll = models.ForeignKey(\n Poll,\n on_delete=models.CASCADE,\n verbose_name="the related poll",\n)\nsites = models.ManyToManyField(Site, verbose_name="list of sites")\nplace = models.OneToOneField(\n Place,\n on_delete=models.CASCADE,\n verbose_name="related place",\n)\nThe convention is not to capitalize the first letter of the\nverbose_name. Django will automatically capitalize the first\nletter where it needs to.
Clearly, the power of relational databases lies in relating tables to each\nother. Django offers ways to define the three most common types of database\nrelationships: many-to-one, many-to-many and one-to-one.
\nTo define a many-to-one relationship, use django.db.models.ForeignKey.\nYou use it just like any other Field type: by\nincluding it as a class attribute of your model.
ForeignKey requires a positional argument: the class\nto which the model is related.
For example, if a Car model has a Manufacturer -- that is, a\nManufacturer makes multiple cars but each Car only has one\nManufacturer -- use the following definitions:
from django.db import models\n\nclass Manufacturer(models.Model):\n # ...\n pass\n\nclass Car(models.Model):\n manufacturer = models.ForeignKey(Manufacturer, on_delete=models.CASCADE)\n # ...\nYou can also create recursive relationships (an\nobject with a many-to-one relationship to itself) and relationships to\nmodels not yet defined; see the model field\nreference for details.
\nIt's suggested, but not required, that the name of a\nForeignKey field (manufacturer in the example\nabove) be the name of the model, lowercase. You can, of course, call the field\nwhatever you want. For example:
class Car(models.Model):\n company_that_makes_it = models.ForeignKey(\n Manufacturer,\n on_delete=models.CASCADE,\n )\n # ...\nTo define a many-to-many relationship, use\nManyToManyField. You use it just like any other\nField type: by including it as a class attribute of\nyour model.
ManyToManyField requires a positional argument: the\nclass to which the model is related.
For example, if a Pizza has multiple Topping objects -- that is, a\nTopping can be on multiple pizzas and each Pizza has multiple toppings\n-- here's how you'd represent that:
from django.db import models\n\nclass Topping(models.Model):\n # ...\n pass\n\nclass Pizza(models.Model):\n # ...\n toppings = models.ManyToManyField(Topping)\nAs with ForeignKey, you can also create\nrecursive relationships (an object with a\nmany-to-many relationship to itself) and relationships to models not yet\ndefined.
It's suggested, but not required, that the name of a\nManyToManyField (toppings in the example above)\nbe a plural describing the set of related model objects.
It doesn't matter which model has the\nManyToManyField, but you should only put it in one\nof the models -- not both.
Generally, ManyToManyField instances should go in\nthe object that's going to be edited on a form. In the above example,\ntoppings is in Pizza (rather than Topping having a pizzas\nManyToManyField ) because it's more natural to think\nabout a pizza having toppings than a topping being on multiple pizzas. The way\nit's set up above, the Pizza form would let users select the toppings.
ManyToManyField fields also accept a number of\nextra arguments which are explained in the model field reference. These options help define how the relationship\nshould work; all are optional.
When you're only dealing with simple many-to-many relationships such as\nmixing and matching pizzas and toppings, a standard\nManyToManyField is all you need. However, sometimes\nyou may need to associate data with the relationship between two models.
For example, consider the case of an application tracking the musical groups\nwhich musicians belong to. There is a many-to-many relationship between a person\nand the groups of which they are a member, so you could use a\nManyToManyField to represent this relationship.\nHowever, there is a lot of detail about the membership that you might want to\ncollect, such as the date at which the person joined the group.
For these situations, Django allows you to specify the model that will be used\nto govern the many-to-many relationship. You can then put extra fields on the\nintermediate model. The intermediate model is associated with the\nManyToManyField using the\nthrough argument to point to the model\nthat will act as an intermediary. For our musician example, the code would look\nsomething like this:
from django.db import models\n\nclass Person(models.Model):\n name = models.CharField(max_length=128)\n\n def __str__(self): # __unicode__ on Python 2\n return self.name\n\nclass Group(models.Model):\n name = models.CharField(max_length=128)\n members = models.ManyToManyField(Person, through='Membership')\n\n def __str__(self): # __unicode__ on Python 2\n return self.name\n\nclass Membership(models.Model):\n person = models.ForeignKey(Person, on_delete=models.CASCADE)\n group = models.ForeignKey(Group, on_delete=models.CASCADE)\n date_joined = models.DateField()\n invite_reason = models.CharField(max_length=64)\nWhen you set up the intermediary model, you explicitly specify foreign\nkeys to the models that are involved in the many-to-many relationship. This\nexplicit declaration defines how the two models are related.
\nThere are a few restrictions on the intermediate model:
\nYour intermediate model must contain one - and only one - foreign key\nto the source model (this would be Group in our example), or you must\nexplicitly specify the foreign keys Django should use for the relationship\nusing ManyToManyField.through_fields.\nIf you have more than one foreign key and through_fields is not\nspecified, a validation error will be raised. A similar restriction applies\nto the foreign key to the target model (this would be Person in our\nexample).
For a model which has a many-to-many relationship to itself through an\nintermediary model, two foreign keys to the same model are permitted, but\nthey will be treated as the two (different) sides of the many-to-many\nrelationship. If there are more than two foreign keys though, you\nmust also specify through_fields as above, or a validation error\nwill be raised.
When defining a many-to-many relationship from a model to\nitself, using an intermediary model, you must use\nsymmetrical=False (see\nthe model field reference).
Now that you have set up your ManyToManyField to use\nyour intermediary model (Membership, in this case), you're ready to start\ncreating some many-to-many relationships. You do this by creating instances of\nthe intermediate model:
>>> ringo = Person.objects.create(name="Ringo Starr")\n>>> paul = Person.objects.create(name="Paul McCartney")\n>>> beatles = Group.objects.create(name="The Beatles")\n>>> m1 = Membership(person=ringo, group=beatles,\n... date_joined=date(1962, 8, 16),\n... invite_reason="Needed a new drummer.")\n>>> m1.save()\n>>> beatles.members.all()\n<QuerySet [<Person: Ringo Starr>]>\n>>> ringo.group_set.all()\n<QuerySet [<Group: The Beatles>]>\n>>> m2 = Membership.objects.create(person=paul, group=beatles,\n... date_joined=date(1960, 8, 1),\n... invite_reason="Wanted to form a band.")\n>>> beatles.members.all()\n<QuerySet [<Person: Ringo Starr>, <Person: Paul McCartney>]>\nUnlike normal many-to-many fields, you can't use add(), create(),\nor set() to create relationships:
>>> # The following statements will not work\n>>> beatles.members.add(john)\n>>> beatles.members.create(name="George Harrison")\n>>> beatles.members.set([john, paul, ringo, george])\nWhy? You can't just create a relationship between a Person and a Group\n- you need to specify all the detail for the relationship required by the\nMembership model. The simple add, create and assignment calls\ndon't provide a way to specify this extra detail. As a result, they are\ndisabled for many-to-many relationships that use an intermediate model.\nThe only way to create this type of relationship is to create instances of the\nintermediate model.
The remove() method is\ndisabled for similar reasons. For example, if the custom through table defined\nby the intermediate model does not enforce uniqueness on the\n(model1, model2) pair, a remove() call would not provide enough\ninformation as to which intermediate model instance should be deleted:
>>> Membership.objects.create(person=ringo, group=beatles,\n... date_joined=date(1968, 9, 4),\n... invite_reason="You've been gone for a month and we miss you.")\n>>> beatles.members.all()\n<QuerySet [<Person: Ringo Starr>, <Person: Paul McCartney>, <Person: Ringo Starr>]>\n>>> # This will not work because it cannot tell which membership to remove\n>>> beatles.members.remove(ringo)\nHowever, the clear()\nmethod can be used to remove all many-to-many relationships for an instance:
>>> # Beatles have broken up\n>>> beatles.members.clear()\n>>> # Note that this deletes the intermediate model instances\n>>> Membership.objects.all()\n<QuerySet []>\nOnce you have established the many-to-many relationships by creating instances\nof your intermediate model, you can issue queries. Just as with normal\nmany-to-many relationships, you can query using the attributes of the\nmany-to-many-related model:
\n# Find all the groups with a member whose name starts with 'Paul'\n>>> Group.objects.filter(members__name__startswith='Paul')\n<QuerySet [<Group: The Beatles>]>\nAs you are using an intermediate model, you can also query on its attributes:
\n# Find all the members of the Beatles that joined after 1 Jan 1961\n>>> Person.objects.filter(\n... group__name='The Beatles',\n... membership__date_joined__gt=date(1961,1,1))\n<QuerySet [<Person: Ringo Starr]>\nIf you need to access a membership's information you may do so by directly\nquerying the Membership model:
>>> ringos_membership = Membership.objects.get(group=beatles, person=ringo)\n>>> ringos_membership.date_joined\ndatetime.date(1962, 8, 16)\n>>> ringos_membership.invite_reason\n'Needed a new drummer.'\nAnother way to access the same information is by querying the\nmany-to-many reverse relationship from a\nPerson object:
>>> ringos_membership = ringo.membership_set.get(group=beatles)\n>>> ringos_membership.date_joined\ndatetime.date(1962, 8, 16)\n>>> ringos_membership.invite_reason\n'Needed a new drummer.'\nTo define a one-to-one relationship, use\nOneToOneField. You use it just like any other\nField type: by including it as a class attribute of your model.
This is most useful on the primary key of an object when that object "extends"\nanother object in some way.
\nOneToOneField requires a positional argument: the\nclass to which the model is related.
For example, if you were building a database of "places", you would\nbuild pretty standard stuff such as address, phone number, etc. in the\ndatabase. Then, if you wanted to build a database of restaurants on\ntop of the places, instead of repeating yourself and replicating those\nfields in the Restaurant model, you could make Restaurant have\na OneToOneField to Place (because a\nrestaurant "is a" place; in fact, to handle this you'd typically use\ninheritance, which involves an implicit\none-to-one relation).
As with ForeignKey, a recursive relationship can be defined and references to as-yet\nundefined models can be made.
OneToOneField fields also accept an optional\nparent_link argument.
OneToOneField classes used to automatically become\nthe primary key on a model. This is no longer true (although you can manually\npass in the primary_key argument if you like).\nThus, it's now possible to have multiple fields of type\nOneToOneField on a single model.
It's perfectly OK to relate a model to one from another app. To do this, import\nthe related model at the top of the file where your model is defined. Then,\njust refer to the other model class wherever needed. For example:
\nfrom django.db import models\nfrom geography.models import ZipCode\n\nclass Restaurant(models.Model):\n # ...\n zip_code = models.ForeignKey(\n ZipCode,\n on_delete=models.SET_NULL,\n blank=True,\n null=True,\n )\nDjango places only two restrictions on model field names:
\nA field name cannot be a Python reserved word, because that would result\nin a Python syntax error. For example:
\nclass Example(models.Model):\n pass = models.IntegerField() # 'pass' is a reserved word!\nA field name cannot contain more than one underscore in a row, due to\nthe way Django's query lookup syntax works. For example:
\nclass Example(models.Model):\n foo__bar = models.IntegerField() # 'foo__bar' has two underscores!\nThese limitations can be worked around, though, because your field name doesn't\nnecessarily have to match your database column name. See the\ndb_column option.
SQL reserved words, such as join, where or select, are allowed as\nmodel field names, because Django escapes all database table names and column\nnames in every underlying SQL query. It uses the quoting syntax of your\nparticular database engine.
If one of the existing model fields cannot be used to fit your purposes, or if\nyou wish to take advantage of some less common database column types, you can\ncreate your own field class. Full coverage of creating your own fields is\nprovided in Writing custom model fields.
\nMeta optionsLink to this heading#Give your model metadata by using an inner class Meta, like so:
from django.db import models\n\nclass Ox(models.Model):\n horn_length = models.IntegerField()\n\n class Meta:\n ordering = ["horn_length"]\n verbose_name_plural = "oxen"\nModel metadata is "anything that's not a field", such as ordering options\n(ordering), database table name (db_table), or\nhuman-readable singular and plural names (verbose_name and\nverbose_name_plural). None are required, and adding class\nMeta to a model is completely optional.
A complete list of all possible Meta options can be found in the model\noption reference.
objectsThe most important attribute of a model is the\nManager. It's the interface through which\ndatabase query operations are provided to Django models and is used to\nretrieve the instances from the database. If no\ncustom Manager is defined, the default name is\nobjects. Managers are only accessible via\nmodel classes, not the model instances.
Define custom methods on a model to add custom "row-level" functionality to your\nobjects. Whereas Manager methods are intended to do\n"table-wide" things, model methods should act on a particular model instance.
This is a valuable technique for keeping business logic in one place -- the\nmodel.
\nFor example, this model has a few custom methods:
\nfrom django.db import models\n\nclass Person(models.Model):\n first_name = models.CharField(max_length=50)\n last_name = models.CharField(max_length=50)\n birth_date = models.DateField()\n\n def baby_boomer_status(self):\n "Returns the person's baby-boomer status."\n import datetime\n if self.birth_date < datetime.date(1945, 8, 1):\n return "Pre-boomer"\n elif self.birth_date < datetime.date(1965, 1, 1):\n return "Baby boomer"\n else:\n return "Post-boomer"\n\n def _get_full_name(self):\n "Returns the person's full name."\n return '%s %s' % (self.first_name, self.last_name)\n full_name = property(_get_full_name)\nThe last method in this example is a property.
\nThe model instance reference has a complete list\nof methods automatically given to each model.\nYou can override most of these -- see overriding predefined model methods,\nbelow -- but there are a couple that you'll almost always want to define:
\n__str__() (Python 3)A Python "magic method" that returns a unicode "representation" of any\nobject. This is what Python and Django will use whenever a model\ninstance needs to be coerced and displayed as a plain string. Most\nnotably, this happens when you display an object in an interactive\nconsole or in the admin.
\nYou'll always want to define this method; the default isn't very helpful\nat all.
\n__unicode__() (Python 2)Python 2 equivalent of __str__().
get_absolute_url()This tells Django how to calculate the URL for an object. Django uses\nthis in its admin interface, and any time it needs to figure out a URL\nfor an object.
\nAny object that has a URL that uniquely identifies it should define this\nmethod.
\nThere's another set of model methods that\nencapsulate a bunch of database behavior that you'll want to customize. In\nparticular you'll often want to change the way save() and\ndelete() work.
You're free to override these methods (and any other model method) to alter\nbehavior.
\nA classic use-case for overriding the built-in methods is if you want something\nto happen whenever you save an object. For example (see\nsave() for documentation of the parameters it accepts):
from django.db import models\n\nclass Blog(models.Model):\n name = models.CharField(max_length=100)\n tagline = models.TextField()\n\n def save(self, *args, **kwargs):\n do_something()\n super(Blog, self).save(*args, **kwargs) # Call the "real" save() method.\n do_something_else()\nYou can also prevent saving:
\nfrom django.db import models\n\nclass Blog(models.Model):\n name = models.CharField(max_length=100)\n tagline = models.TextField()\n\n def save(self, *args, **kwargs):\n if self.name == "Yoko Ono's blog":\n return # Yoko shall never have her own blog!\n else:\n super(Blog, self).save(*args, **kwargs) # Call the "real" save() method.\nIt's important to remember to call the superclass method -- that's\nthat super(Blog, self).save(*args, **kwargs) business -- to ensure\nthat the object still gets saved into the database. If you forget to\ncall the superclass method, the default behavior won't happen and the\ndatabase won't get touched.
It's also important that you pass through the arguments that can be\npassed to the model method -- that's what the *args, **kwargs bit\ndoes. Django will, from time to time, extend the capabilities of\nbuilt-in model methods, adding new arguments. If you use *args,\n**kwargs in your method definitions, you are guaranteed that your\ncode will automatically support those arguments when they are added.
Another common pattern is writing custom SQL statements in model methods and\nmodule-level methods. For more details on using raw SQL, see the documentation\non using raw SQL.
\nDjango におけるモデルの継承は Python における普通のクラスの継承とはかなり異なった方法で行われます、しかし最も最初の段階で基本となる考えは共通しています。それはその基底クラスが django.db.models.Model のサブクラスでなければならないという事です。
下すべき決定事項は親モデルを (保持するデータベースのテーブルと共に) 独自の権限を持ったモデルとするか、それとも親モデルは単に子モデルを通じてのみ参照できる共通情報を持っているだけの存在とするかという事だけです。
\nDjango において可能な継承には 3 つの方式が有ります。
\n往々にして、子モデルそれぞれに対して一々定義し直さないで済ませたい情報を保持するためだけに親クラスを用いようとするでしょう。そのクラスは単体で用いられることはありません、抽象基底クラス こそあなたが必要とする物でしょう。
もし既存のモデル (完全に別のアプリケーション等から取得した) のサブクラスを作成していてモデルそれぞれにデータベース上のテーブルを定義したい場合、 複数テーブルの継承 を利用するとよいでしょう。
最後に、もしあるモデルの Python レベルでの振る舞いを、そのモデルのフィールドをいかなる形でも変更せずに修正したい場合は プロキシモデル を利用できます。
抽象基底クラスは大量のモデルに共通の情報を持たせたい場合に有用です。基礎となるクラスを記述してその Meta クラス内に abstract=True を記述します。そうするとそのモデルはデータベース上にテーブルを構築するために用いられることは無くなります。その変わり、他のモデルの基底クラスとして用いられた場合、そのモデル上のフィールドは子クラスのフィールドに追加されます。抽象基底クラスに定義したのと同じ名前のフィールドが継承した子に存在する場合はエラーとなります (Django が例外を送出します)。
実装例:
\nfrom django.db import models\n\nclass CommonInfo(models.Model):\n name = models.CharField(max_length=100)\n age = models.PositiveIntegerField()\n\n class Meta:\n abstract = True\n\nclass Student(CommonInfo):\n home_group = models.CharField(max_length=5)\nStudent モデルは name、age そして home_group の 3 つのフィールドを持つことになります。 CommonInfo モデルは抽象基底クラスであるため、通常の Django モデルとしては利用できません。データベース上にテーブルを生成したりマネージャを持ったりせず、そしてインスタンス化されたり直接値を保存する事もできません。
大抵の状況において、このモデル継承の方式がまさにあなたが必要としていた物となるでしょう。この方式では、データベースの領域では子モデル毎に一つずつだけのテーブルを作る事しかできませんが、共通で持ちたい情報を Python の水準で分離できます。
\nMeta 継承Link to this heading#抽象基底クラスを作成した際、Django は基底クラスから利用できる Meta インナークラスを全て子クラスの属性値にします。もしある子クラスが自身の Meta クラスを定義しなければ、親クラスの Meta クラスを継承します。もし子クラスが親の Meta クラスを拡張したい場合は、継承したクラスのサブクラス化が可能です。以下のようになります:
\nfrom django.db import models\n\nclass CommonInfo(models.Model):\n # ...\n class Meta:\n abstract = True\n ordering = ['name']\n\nclass Student(CommonInfo):\n # ...\n class Meta(CommonInfo.Meta):\n db_table = 'student_info'\nDjango は抽象基底クラスの Meta クラスに対して一つの変更を施します: Meta 属性を子クラスに導入する前に、 abstract=False を設定します。これは抽象基底クラスを継承した子クラスは自身を自動的に抽象基底クラスにはしない事を意味します。言うまでもなく、他の抽象基底クラスを継承した抽象基底クラスを作る事はできます。継承する都度 abstract=True を設定する事を忘れなければ良いだけです。
抽象基底クラスの Meta クラスに持っても意味をなさない属性がいくつか存在します。例えば、属性値 db_table を持つことは継承した子クラス (の中で自身の Meta を定義していない物) が全て同じデータベース上のテーブルを利用する事を意味しますが、それは期待する動作と明らかに異なるでしょう。
Django によってサポートされている二番目のモデル継承は継承依存関係内の各モデル自身が関係を構築するものです。各モデルはデータベース上のテーブルに対応しており、個別に選択と作成ができます。依存関係は子となるモデルとそれぞれの親となるモデルの関係(自動的に作成される OneToOneField を通して構築される)を表現する物です。例えば:
from django.db import models\n\nclass Place(models.Model):\n name = models.CharField(max_length=50)\n address = models.CharField(max_length=80)\n\nclass Restaurant(Place):\n serves_hot_dogs = models.BooleanField(default=False)\n serves_pizza = models.BooleanField(default=False)\nデータはデータベースの異なるテーブルに存在しますが、 Place のフィールドは全て Restaurant でも利用できます。以下は共に処理可能です:
>>> Place.objects.filter(name="Bob's Cafe")\n>>> Restaurant.objects.filter(name="Bob's Cafe")\nPlace を取得すれば Restaurant も取得することになり、小文字のモデル名を用いることで Place オブジェクトから Restaurant オブジェクトを取得できます:
>>> p = Place.objects.get(id=12)\n# If p is a Restaurant object, this will give the child class:\n>>> p.restaurant\n<Restaurant: ...>\nしかしながら、上の例において p が Restaurant オブジェクト ではない (継承を用いず Place オブジェクトが直接作成されたもしくは他のクラスの親であった)場合、 p.restaurant を参照すると Restaurant.DoesNotExist 例外を創出します。
複数のテーブルを継承する状況では、子クラスにとって親クラスの Meta クラスを継承する事には意味が有りません。全ての Meta オプションは既に親クラスにおいて適用されておりそれを再度定義する事は矛盾した挙動を示すことに繋がります(これは基礎となるクラスの存在を当然の機能としては期待できない抽象基底クラスと対照的です)。
\nそのため子モデルは親モデルの Meta クラスへのアクセスを持ちません。しかし、限られた状況において子モデルが親モデルから挙動を継承する場合が有ります:もし子モデルが ordering 属性もしくは get_latest_by 属性を設定しなかった場合、これらを親モデルから継承します。
もし親モデルが ordering 属性を持っており子モデルに既定のデータ並び順を持たせたくない場合、明示的に無効化する事ができます:
\nclass ChildModel(ParentModel):\n # ...\n class Meta:\n # Remove parent's ordering effect\n ordering = []\n複数テーブルの継承は親モデルと子モデルの関連付けに暗黙的な OneToOneField を利用するため、先の例で示されたように、親から子に情報を移動させることは可能です。しかしその関連付けには ForeignKey および ManyToManyField に付与されたデフォルトの related_name の値を利用します。もしこの種類の関連付けを親モデルのサブクラスに対して用いる場合、 related_name 属性を各フィールドに 定義しなければなりません 。もし設定を忘れれば、Django はバリデーション例外を送出します。
例として、上で用いた Place クラスを再度用いて、また別のサブクラスを ManyToManyField によって作成してみましょう:
class Supplier(Place):\n customers = models.ManyToManyField(Place)\nこの処理の結果はエラーとなります:
\nReverse query name for 'Supplier.customers' clashes with reverse query\nname for 'Supplier.place_ptr'.\n\nHINT: Add or change a related_name argument to the definition for\n'Supplier.customers' or 'Supplier.place_ptr'.\ncustomers フィールドに related_name を追加する事でこのエラーを解消できます: models.ManyToManyField(Place, related_name='provider')。
先に述べたように、Django は自動的に OneToOneField による子クラスから抽象クラスでないあらゆる親モデルへの関連付けを自動的に作ります。もしこの親モデルを指す属性値の名前を設定したい場合は、あるフィールドが親クラスに関連を逆引きするための物であることを示すために、独自の OneToOneField を作り parent_link=True を設定できます。
複数テーブルの継承 を利用しているとき、あるモデルのサブクラス毎に新たなデータベースのテーブルが作成されます。これは基底クラスに存在しない追加のデータフィールドをサブクラスが保存する場所が必要なため、通常必要とされる動作です。しかしながら、モデルの Python 上の振る舞いを変更したい事も有ります -- デフォルトのマネージャーを変更したり、新たなメソッドを追加したりする場合です。
\nプロキシモデルによる継承が利用できるのはこういった状況です:オリジナルのモデルのための プロキシ を作るのです。プロキシモデルで通してインスタンスを作成、削除、更新して (プロキシされない) オリジナルのモデルを利用しているかのようにデータを保存できます。プロキシを利用した場合に生じる違いは、オリジナルのモデルに変更を加えることなく、デフォルトのモデルのソート順やマネージャーの設定をプロキシ上で変更できるという点です。
\nプロキシモデルは通常のモデルと同様に定義されます。Django にそれがプロキシモデルである事を伝えるには Meta クラスの proxy 属性値を True にします。
例として、Person モデルにメソッドを追加すると仮定します。以下のように記述することで実現できます:
from django.db import models\n\nclass Person(models.Model):\n first_name = models.CharField(max_length=30)\n last_name = models.CharField(max_length=30)\n\nclass MyPerson(Person):\n class Meta:\n proxy = True\n\n def do_something(self):\n # ...\n pass\nMyPerson クラスはその親である Person クラス同様に同じデータベースのテーブルを操作しています。特に、Person の新たなインスタンスは全て MyPerson を通じてアクセス可能であり、逆も同様です:
>>> p = Person.objects.create(first_name="foobar")\n>>> MyPerson.objects.get(first_name="foobar")\n<MyPerson: foobar>\nあるモデルに対して並び順の既定値を定義したい場合もプロキシモデルを利用できます。普段は Person モデルの並び順を特に指定していないが、定期的に last_name 属性に基づいて並び替える場合にプロキシを利用できます。とても簡単に利用できます:
class OrderedPerson(Person):\n class Meta:\n ordering = ["last_name"]\n proxy = True\nこれで通常の Person に対する問い合わせでは特に結果は並び替えられず OrderedPerson に対する問い合わせでは last_name に基づいて並び替えられます。
プロキシモデルは Meta の属性値を 通常のモデルと同様に 継承します。
QuerySets はリクエストされたモデルを返し続けるLink to this heading#Person オブジェクトに対して問い合わせた場合に Django に、あえて言えば、 MyPerson オブジェクトを返させる事はできません。プロキシオブジェクトのポイントはオリジナルの Person に依存しているコードはそちらを使いつつ、新たに含んだ (他のコードがどんな形であれ依存しない) 拡張を使うコードを書けるという点です。 Person モデル (や他の全てのモデル) を新たに作った何物かに置き換える方法ではありません。
プロキシモデルは厳格に一つの抽象的でないモデルクラスを継承しなければなりません。複数の非抽象クラスを、異なるデータベースのテーブル上の列と列を接続しない、プロキシモデルとして継承する事はできません。プロキシモデルは、いかなるモデルのフィールドも定義 しない 、抽象モデルクラスをいくらでも継承できます。プロキシモデルはまた共通の非抽象な親クラスを持つプロキシモデルをいくらでも継承できます。
\n\nプロキシモデル上にモデルのマネージャーを定義しない場合、そのプロキシモデルはマネージャーを親のモデルから継承します。プロキシモデル上にマネージャーを定義する場合、親クラス上のマネージャーで定義されて利用可能な物が有ったとしても、そのマネージャーがデフォルトになります。
\n前節の例を使うと、 Person モデルに問い合わせる場合は以下のようにデフォルトマネージャーを変更して用いることができます:
from django.db import models\n\nclass NewManager(models.Manager):\n # ...\n pass\n\nclass MyPerson(Person):\n objects = NewManager()\n\n class Meta:\n proxy = True\n既存の物を置き換えることなく、プロキシモデルに新たなマネージャーを追加したい場合は、 カスタムマネージャー の説明に記述されたテクニックを用いることができます: 新たに実装したマネージャーを含んだ基底クラスを作成し、これを元々の基底クラスに続けて多重継承してください:
\n# Create an abstract class for the new manager.\nclass ExtraManagers(models.Model):\n secondary = NewManager()\n\n class Meta:\n abstract = True\n\nclass MyPerson(Person, ExtraManagers):\n class Meta:\n proxy = True\n上記の操作が頻繁に必要となる事は無いでしょうが、このような実装も可能なのです。
\nプロキシモデルの継承は、あるモデルの Meta クラスにおける managed 属性を用いて Django に管理されないモデルを作成するのにかなり似ています。
Meta.db_table を入念に設定する事で既に存在するモデルとそれに対応する Python メソッドを隠ぺいする管理対象外モデルを作成できます。しかしながら、この操作は変更を加えた際に定義を複製して同期する際にとても冗長で変更に弱い物となります。
一方、プロキシモデルはプロキシするモデルと全く同じように振る舞うことを企図しています。それらのモデルは直接フィールドとマネージャーを継承しているため、常に親モデルに同期しています。
\n原則としては:
\nもし既存のモデルやデータベースのテーブルを反映したいが元となるテーブルのカラムの全てを必要とする訳ではない場合は、 Meta.managed=False を利用してください。このオプションはデータベースのビューやテーブルを Django の管理下に置きたくない場合に通常有用となります。
もしあるモデルの Python の箇所の振る舞いだけを変更したいが、元となるモデルと同じフィールドを保持したい場合は Meta.proxy=True を使用してください。この設定はデータ保存時にプロキシモデルが、元となるモデル側の保管構造の完全な複製となるように諸々を設定します。
Python におけるサブクラス化と同様に、 Django のモデルは複数の親モデルを継承する事ができます。Python で通常用いられる名前解決の規則が適用されることを念頭に置いてください。特定の名称のオブジェクト (例えば Meta クラスを持っていた場合、最初に定義されたモデルのクラスが利用され、それ以外は無視されます。
\n通常は複数の親モデルを継承する必要はありません。この機能が有用な主な状況はクラスの "ミックスイン" 、ミックスイン用クラスを継承する全てのクラスに特別なフィールドやメソッドを追加させる技術、を利用する場合です。情報の特定の箇所がどこに由来するか突き止めるため奮闘しなくて済むように、継承の依存関係を可能な限り簡単で直観的な状態で維持するようにして下さい。
\n共通の id 主キーフィールドを持った複数のモデルを継承すると例外が送出されることに注意してください。多重継承を正常に使うために、基底モデル内で明示的に AutoField を利用できます。
class Article(models.Model):\n article_id = models.AutoField(primary_key=True)\n ...\n\nclass Book(models.Model):\n book_id = models.AutoField(primary_key=True)\n ...\n\nclass BookReview(Book, Article):\n pass\nもしくは共通の祖先となるモデルに AutoField を保持してください:
class Piece(models.Model):\n pass\n\nclass Article(Piece):\n ...\n\nclass Book(Piece):\n ...\n\nclass BookReview(Book, Article):\n pass\n通常の Python のクラス継承では、親クラスから継承したあらゆる属性を子クラスがオーバーライドできます。Django では、この挙動は通常モデルのフィールドに対して許容されません。もし非抽象なモデルの基底クラスが author フィールドを持っていたとしたら、そのモデルの基底クラスを継承したあらゆるモデルクラス内では author という名称の属性値を別のモデルのフィールドや属性として定義できなくなります。
この制約は抽象モデルを継承したモデルのフィールドに対しては適用されません。こういったフィールドは別のフィールドや値によってオーバーライドされるか field_name = None を設定することで削除する事ができます:
Overriding fields in a parent model leads to difficulties in areas such as\ninitializing new instances (specifying which field is being initialized in\nModel.__init__) and serialization. These are features which normal Python\nclass inheritance doesn't have to deal with in quite the same way, so the\ndifference between Django model inheritance and Python class inheritance isn't\narbitrary.
This restriction only applies to attributes which are\nField instances. Normal Python attributes\ncan be overridden if you wish. It also only applies to the name of the\nattribute as Python sees it: if you are manually specifying the database\ncolumn name, you can have the same column name appearing in both a child and\nan ancestor model for multi-table inheritance (they are columns in two\ndifferent database tables).
Django will raise a FieldError if you override\nany model field in any ancestor model.
The manage.py startapp command creates an application\nstructure that includes a models.py file. If you have many models,\norganizing them in separate files may be useful.
To do so, create a models package. Remove models.py and create a\nmyapp/models/ directory with an __init__.py file and the files to\nstore your models. You must import the models in the __init__.py file.
For example, if you had organic.py and synthetic.py in the models\ndirectory:
myapp/models/__init__.pyfrom .organic import Person\nfrom .synthetic import Robot\nExplicitly importing each model rather than using from .models import *\nhas the advantages of not cluttering the namespace, making code more readable,\nand keeping code analysis tools useful.