Sebuah model adalah tunggal, sumber pasti dari informasi tentang data anda. Itu mengandung bidang-bdiang penting dan perilaku dari data anda masih sedang menyimpan. Umumnya, stiap model memetakan pada sebuah tabel basisdata tunggal.
\nDasar:
\nSetiap model adalah kelas Python yang subkelas django.db.models.Model.
Setiap atribut dari model mewakili bidang basisdata.
Dengan semua ini, Django memberikan API akses-basisdata dibangkitkan-otomatis; lihat Membuat query.
Model contoh ini menentukan Person, yang mempunyai first_name dan last_name:
from django.db import models\n\n\nclass Person(models.Model):\n first_name = models.CharField(max_length=30)\n last_name = models.CharField(max_length=30)\nfirst_name dan last_name adalah fields dari model. Setiap bidang ditentukan sebagai atribut kelas, dan setiap atribut memetakan pada sebuah kolom basisdata.
Model Person diatas akan membuat sebuah tabel basisdata seperti ini:
CREATE TABLE myapp_person (\n "id" bigint NOT NULL PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,\n "first_name" varchar(30) NOT NULL,\n "last_name" varchar(30) NOT NULL\n);\nBeberapa catatan teknis:
\nNama dari tabel, myapp_person, otomatis berasal dari beberapa metadata model tetapi dapat ditimpa. Lihat Nama tabel untuk rincian lebih.
Sebuah bidang id ditambahkan secara otomatis, tetapi perilaku ini dapat dikesampingkan. Lihat Bidang primary key otomatis.
SQL CREATE TABLE dalam contoh ini dibentuk menggunakan sintaksis PostgreSQL, tetapi itu perlu dicatat Django menggunakan SQL disesuaikan pada backend basisdata ditentukan dalam settings file anda.
Sekali anda telah menentukan model anda, anda butuh memberitahu Django anda sedang akan menggunakan model-model tersebut. Lakukan ini dengan menyunting berkas pengaturan anda dan merubah pengaturan INSTALLED_APPS untuk menambah nama dari modul yang mengandung models.py anda.
Sebagai contoh, jika model-model untuk aplikasi anda tinggal dalam modul myapp.models (struktur paket yang dibuat untuk sebuah aplikasi oleh tulisan manage.py startapp), INSTALLED_APPS harus membaca, dalam bagian:
INSTALLED_APPS = [\n # ...\n "myapp",\n # ...\n]\nKetika anda menambah aplikasi baru pada INSTALLED_APPS, pastikan menjalankan manage.py migrate, pilihannya membuat perpindahan untuk mereka dahulu dengan manage.py makemigrations.
Bagian paling penting dari sebuah model -- dan hanya membutuhkan bagian dari sebah model -- adalah daftar bidang basisdata itu tentukan. Bidang-bidang ditentukan oleh atribut kelas. Hati-hati tidak memilih nama bidang yang bertentangan dengan models API seperti clean, save, atau delete.
Contoh:
\nfrom django.db import models\n\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\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()\nSetiap bidang dalam model anda harus berupa sebuah instance dari kelas Field sesuai. Django menggunakan jenis kelas bidang untuk menentukan sedikit hal:
Jenis kolom, yang memberitahu basisdata maca apa dari data disimpan (sebagai contoh INTEGER, VARCHAR, TEXT).
HTML awalan widget untuk digunakan ketika membangun sebuah bidang formulir (sebagai contoh <input type="text">, <select>).
Persyaratan pengesahan minimal, digunakan di admin Django dan di formulir dibangkitkan-otomatis.
Django dibekali dengan lusinan dari jenis-jenis siap pakai; anda dapat menemukan daftar lengkap dalam model field reference. Anda dapat dengan mudah menulis bidang-bidang anda sendiri jika satu siap-pakai Django tidak melakukan trik; lihat Bagaimana membuat bidang model disesuaikan.
\nSetiap bidang-bidang mengambil kumpulan tertentu dari argumen bidang-tertentu (didokumentasikan dalam model field reference). Sebagai contoh, CharField (dan subkelasnya) membutuhkan sebuah argumen max_length yang menentukan ukuran dari bidang basisdata VARCHAR digunakan untuk menyimpan data.
Ada juga sekumpulan dari argumen umum tersedia pada semua jenis bidang. Semua adalah pilihan. Mereka sepenuhnya dijelaskan dalam reference, tetapi ini adalah ringkasan cepat dari satu kebanyakan sering-digunakan:
\nnullJika True, Django akan menyimpan nilai-nilai kosong sebagai NULL di basisdata. Awalan adalah False.
blankJika True, bidang diizinkan menjadi kosong. Awalan adalah False.
Catat bahwa ini berbeda dari null. blank adalah pengesahan-terkait. Jika sebuah bidang mempunyai blank=True, pengesahan formulir akan mengizinkan masukan dari sebuah nilai kosong. Jika sebuah bidang mempunyai blank=False, bidang akan diwajibkan.
choicesA sequence of 2-value tuples, a mapping, an\nenumeration type, or a callable (that\nexpects no arguments and returns any of the previous formats), to use as\nchoices for this field. If this is given, the default form widget will be a\nselect box instead of the standard text field and will limit choices to the\nchoices given.
\nDaftar pilihan kelihatan seperti ini:
\nYEAR_IN_SCHOOL_CHOICES = [\n ("FR", "Freshman"),\n ("SO", "Sophomore"),\n ("JR", "Junior"),\n ("SR", "Senior"),\n ("GR", "Graduate"),\n]\nUnsur pertama dalam setiap tuple adalah nilaiyang akan disimpan dalam basisdata. Unsur kedua ditampilkan oleh widget formulir bidang.
\nDiberikan sebuah instance model, nilai tampilan untuk sebuah bidang dengan choices dapat diakses menggunakan metode get_FOO_display(). Sebagai contoh:
from django.db import models\n\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'\nYou can also use enumeration classes to define choices in a concise\nway:
from django.db import models\n\n\nclass Runner(models.Model):\n MedalType = models.TextChoices("MedalType", "GOLD SILVER BRONZE")\n name = models.CharField(max_length=60)\n medal = models.CharField(blank=True, choices=MedalType, max_length=10)\nContoh-contoh lebih jauh tersedia dalam model field reference.
\ndefaultNilai awalan untuk bidang. Ini dapat berupa nilai atau obyek callable. Jika callable itu akan diapnggil setiap waktu obyek baru dibuat.
\ndb_defaultThe database-computed default value for the field. This can be a literal\nvalue or a database function.
\nIf both db_default and Field.default are set, default will\ntake precedence when creating instances in Python code. db_default will\nstill be set at the database level and will be used when inserting rows\noutside of the ORM or when adding a new field in a migration.
help_textTeks "help" tambahan untuk ditampilkan dengan widget formulir. Itu sangat berguna untuk dokumentasi bahkan jika bidang anda tidak digunakan pada formulir.
\nprimary_keyJika True, bidang ini adalah primary key untuk model.
If you don't specify primary_key=True for\nany fields in your model, Django will automatically add a field to hold\nthe primary key, so you don't need to set\nprimary_key=True on any of your fields\nunless you want to override the default primary-key behavior. For more,\nsee Bidang primary key otomatis.
Bidang kunci utama adalah hanya-baca. Jika anda merubah nilai dari primaru key pada sebuah obyek yang ada dan kemudian menyimpan itu, sebuah obyek baru akan dibuat bersama satu yang lama. Sebagai contoh:
\nfrom django.db import models\n\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<QuerySet ['Apple', 'Pear']>\nuniqueJika True, bidang ini harus unik diseluruh tabel.
Lagi, ini hanya gambaran pendek dari kebanyakan pilihan bidang umum. Rincian penuh dapat ditemukan di common model field option reference.
\nBy default, Django gives each model an auto-incrementing primary key with the\ntype specified per app in AppConfig.default_auto_field or globally in the\nDEFAULT_AUTO_FIELD setting. For example:
id = models.BigAutoField(primary_key=True)\nIf you'd like to specify a custom primary key, specify primary_key=True on one of your fields. If Django sees you've explicitly\nset Field.primary_key, it won't add the automatic id column.
Setiap model membutuhkan setidaknya satu bidang untuk memiliki primary_key=True (antara dinyatakan jelas atau ditambahkan otomatis).
Setiap jenis bidang, kecuali untuk ForeignKey, ManyToManyField dan OneToOneField, mengambil sebuah pilihan argumen penempatan pertama -- sebuah nama bertele-tele. Jika nama bertele-tele tidak diberikan, DJango akan otomatis membuat itu menggunakan nama atribut bidang, merubah garis bawah menjadi ruang.
Dalam contoh ini, nama bertele-tele adalah "person's first name":
first_name = models.CharField("person's first name", max_length=30)\nDalam contoh ini, nama bertele-tele adalah "first name":
first_name = models.CharField(max_length=30)\nForeignKey, ManyToManyField dan OneToOneField membutuhkan argumen pertama untuk jadi kelas model, jadi gunakan argumen kata kunci verbose_name:
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)\nKebiasaan tidak menghuruf besarkan huruf pertama dari verbose_name. Django akan otomatis menghuruf besarkan huruf pertama dimana itu dibutuhkan.
Jelas, kekuatan dari hubungan basisdata bergantung dalam tabel berkaitan ke setiap lainnya. Django menawarkan cara menentukan tiga jenis paling umum dari hubungan basisdata: many-to-one, many-to-many dan one-to-one.
\nUntuk menentukan hubungan many-to-one, gunakan ForeignKey. Anda menggunakan itu seperti jenis Field lainnya: dengan menyertakan itu sebagai sebuah atribut kelas dari model anda.
ForeignKey membutuhkan sebuah argumen penempatan: kelas dimana model terkait.
Sebagai contoh, jika sebuah model Car mempunyai Manufacturer -- yaitu, Manufacturer membuat banyak mobil tetapi setiap car hanya mempunyai satu Manufacturer -- gunakan pengertian berikut:
from django.db import models\n\n\nclass Manufacturer(models.Model):\n # ...\n pass\n\n\nclass Car(models.Model):\n manufacturer = models.ForeignKey(Manufacturer, on_delete=models.CASCADE)\n # ...\nAnda dapat juga membuat recursive relationships (sebuah obyek dengan hubungan many-to-one ke diri sendiri) dan relationships to models not yet defined; lihat the model field reference untuk rincian.
\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 call the field whatever you\nwant. For example:
class Car(models.Model):\n company_that_makes_it = models.ForeignKey(\n Manufacturer,\n on_delete=models.CASCADE,\n )\n # ...\nUntuk menentukan hubungan many-to-many, gunakan ManyToManyField. Anda menggunakan itu seperti jenis Field lainnya: dengan menyertakan itu sebagai sebuah atribut kelas dari model anda.
ManyToManyField membutuhkan argumen penempatan: kelas pada yang model yang terkait.
Sebagai contoh, jika Pizza mempunyai banyak obyek Topping--yaitu, sebuah Topping dapat berupa pada banyak pizza dan setiap Pizza mempunyai banyak taburan -- ini adalah bagaimana anda mewakili itu:
from django.db import models\n\n\nclass Topping(models.Model):\n # ...\n pass\n\n\nclass Pizza(models.Model):\n # ...\n toppings = models.ManyToManyField(Topping)\nSeperti ForeignKey, anda dapat juga membuat recursive relationships (sebuah obyek dengan hubungan many-to-many ke itu sendiri) dan relationships to models not yet defined.
Disarankan, tetapi tidak wajib, bahwa nama dari sebuah ManyToManyField (toppings dalam contoh diatas) menjadi plural menggambarkan kumpulan dari obyek model terkait.
Itu tidak masalah model mana mempunyai ManyToManyField, tetapi anda harus menaruh itu dalam satu dari model - tidak keduanya.
Umumnya, instance ManyToManyField harus pergi ke obyek yang akan disunting pada sebuah formulir. Dalam contoh diatas, toppings``berada dalam ``Pizza (daripada toppings memiliki Pizza ManyToManyField ) karena itu lebih alami untuk berpikir tentang sebuah pizza mempunyai taburan berada pada banyak pizza. Cara itu menyetel diatas, formulir Pizza akan membiarkan pengguna memilih taburan.
Bidang ManyToManyField juga menerima sejumlah dari argumen tambahan yang dijelaskan dalam the model field reference. Pilihan-pilihan ini membantu menentukan bagaimana hubungan harus bekerja; semua adalah pilihan.
When you're only dealing with many-to-many relationships such as mixing and\nmatching pizzas and toppings, a standard\nManyToManyField is all you need. However, sometimes\nyou may need to associate data with the relationship between two models.
Sebagai contoh, pertimbangkan kasus dari sebuah aplikasi melacak kelompok musikal yang milik pemusik. Ada hubungan many-to-many diantara seorang dan kelompok yang mereka adalah anggota, jadi anda dapat menggunakan sebuah ManyToManyField untuk mewakili hubungan ini. Bagaimanapun, ada banyak dari rincian tentang keanggotaan yang mungkin ingin dikumpulkan, seperti tanggal dimana seseorang bergabung kelompok.
Untuk keadaan ini, Django mengizinkan anda menentukan model yang akan digunakan untuk menentukan hubungan many-to-many. Anda dapat kemudian menaruh bidang-bidang tambahan pada model menengah. Model menengah dikaitkan dengan ManyToManyField menggunakan argumen through untuk menunjuk model yang akan bertindak sebagai sebuah perantara. Untuk contoh pemusik kami, kode akan terlihat sesuatu seperti ini:
from django.db import models\n\n\nclass Person(models.Model):\n name = models.CharField(max_length=128)\n\n def __str__(self):\n return self.name\n\n\nclass Group(models.Model):\n name = models.CharField(max_length=128)\n members = models.ManyToManyField(Person, through="Membership")\n\n def __str__(self):\n return self.name\n\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)\n\n class Meta:\n constraints = [\n models.UniqueConstraint(\n fields=["person", "group"], name="unique_person_group"\n )\n ]\nKetika anda menyetel model perantara, anda jelas menentukan foreign key pada model-model yang terlibat dalam hubungan many-to-many. Pernyataan jelas ini menentukan bagaimana dua model terkait.
\nIf you don't want multiple associations between the same instances, add a\nUniqueConstraint including the from and to\nfields. Django's automatically generated many-to-many tables include such a\nconstraint.
Ada beberapa batasan pada model menengah:
\nModel perantara anda harus mengandung satu - dan *hanya` satu - foreign key pada model sumber (ini akan berupa Group dalam contoh kami), atau anda harus menentukan jelas foreign key Django harus gunakan untuk hubungan menggunakan ManyToManyField.through_fields. Jika anda mempunyai lebih dari satu foreign key dan through_fields tidak ditentukan, kesalahan pengesahan akan dimunculkan. Pembatasan yang mirip berlaku pada foreign key ke model sasaran (ini akan berupa Person dalam contoh kami).
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 through_fields is not specified,\nthe first foreign key will be taken to represent the source side of the\nManyToManyField, while the second will be taken to represent the target\nside. If there are more than two foreign keys though, you must specify\nthrough_fields to explicitly indicate which foreign\nkeys to use, otherwise a validation error will be raised.
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(\n... person=ringo,\n... group=beatles,\n... date_joined=date(1962, 8, 16),\n... invite_reason="Needed a new drummer.",\n... )\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(\n... person=paul,\n... group=beatles,\n... date_joined=date(1960, 8, 1),\n... invite_reason="Wanted to form a band.",\n... )\n>>> beatles.members.all()\n<QuerySet [<Person: Ringo Starr>, <Person: Paul McCartney>]>\nYou can also use add(),\ncreate(), or\nset() to create\nrelationships, as long as you specify through_defaults for any required\nfields:
>>> beatles.members.add(john, through_defaults={"date_joined": date(1960, 8, 1)})\n>>> beatles.members.create(\n... name="George Harrison", through_defaults={"date_joined": date(1960, 8, 1)}\n... )\n>>> beatles.members.set(\n... [john, paul, ringo, george], through_defaults={"date_joined": date(1960, 8, 1)}\n... )\nYou may prefer to create instances of the intermediate model directly.
\nIf the custom through table defined by the intermediate model does not enforce\nuniqueness on the (model1, model2) pair, allowing multiple values, the\nremove() call will\nremove all intermediate model instances:
>>> Membership.objects.create(\n... person=ringo,\n... group=beatles,\n... date_joined=date(1968, 9, 4),\n... invite_reason="You've been gone for a month and we miss you.",\n... )\n>>> beatles.members.all()\n<QuerySet [<Person: Ringo Starr>, <Person: Paul McCartney>, <Person: Ringo Starr>]>\n>>> # This deletes both of the intermediate model instances for Ringo Starr\n>>> beatles.members.remove(ringo)\n>>> beatles.members.all()\n<QuerySet [<Person: Paul McCartney>]>\nThe 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, you can issue\nqueries. Just as with normal many-to-many relationships, you can query using\nthe attributes of the many-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", membership__date_joined__gt=date(1961, 1, 1)\n... )\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.'\nUntuk menentukan hubungan one-to-one, gunakan OneToOneField. Anda dapat menggunakan itu hanya seperti jenis Field lainnya: dengan menyertakan itu sebagai sebuah atribut kelas dari model anda.
Ini adalah paling berguna pada primaty key dari sebuah obyek ketika obyek itu "extends" obyek lain di beberapa cara.
\nOneToOneField membutuhkan argumen penempatan: kelas dimana model yang terkait.
Sebagai contoh, jika anda sedang membangun sebuah basisdata dari "places", anda akan membangun hal yang cukup standar seperti alamat, nomor telepon, dll dalam basisdata. Kemudian, jika anda ingin membangun sebuah basisdata restoran di atas tempat-tempat, daripada mengulangi anda sendiri dan meniru bidang-bidang tersebut dalam model Restaurant, anda dapat membuat Restaurant memiliki kelas OneToOneField pada Place (karena sebuah restauran "adalah sebuah" tempat; faktanya, untuk menangani ini anda biasanya menggunakan inheritance, yang melibatkan sebuah hubungan jelas one-to-one).
Seperti ForeignKey, recursive relationship dapat ditentukan dan references to as-yet undefined models dapat dibuat.
Bidang OneToOneField juga menerima sebuah argumen pilihan parent_link.
OneToOneField digunakan untuk otomatis menjadi primary key pada model. Ini tidak lagi benar (meskipun anda dapat manual melewatkan dalam argumen primary_key jika anda suka). Dengan demikian, itu sekarang memungkinkan memiliki banyak bidang dari jenis OneToOneField pada model tunggal.
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,\nrefer to the other model class wherever needed. For example:
\nfrom django.db import models\nfrom geography.models import ZipCode\n\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 )\nAlternatively, you can use a lazy reference to the related model, specified as\na string in the format "app_label.ModelName". This does not require the\nrelated model to be imported. For example:
from django.db import models\n\n\nclass Restaurant(models.Model):\n # ...\n zip_code = models.ForeignKey(\n "geography.ZipCode",\n on_delete=models.SET_NULL,\n blank=True,\n null=True,\n )\nSee lazy relationships for more details.
\nDjango menempatkan beberapa pembatasan di nama bidang model:
\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!\nSebuah nama bidang tidak dapat mengandung lebih dari satu garis bawah dalam sebuah baris, karena cara bekerja sintaksis pencarian permintaan Django. Sebagai contoh:
\nclass Example(models.Model):\n foo__bar = models.IntegerField() # 'foo__bar' has two underscores!\nSebuah nama bidang tidak dapat berakhir dengan sebuah garis bawah, untuk alasan yang sama.
A field name cannot be check, as this would override the check\nframework's Model.check() method.
Batasan-batasan ini dapat dipecahkan, meskipun, karena nama bidang anda tidak butuh harus cocok nama kolom basisdata anda. Lihat pilihan db_column .
Kata-kata pemesan SQL, seperti join, where atau select, adalah diizinkan sebagai nama bidang model, karena Django meloloskan semua nama-nama tabel basisdata dan nama-nama kolom di setiap permintaan SQL pokok. Itu menggunakan sintaksis mengutip dari mesin basisdata tertentu anda.
Jika satu dari bidang-bidang model yang ada tidak dapat digunakan untuk memenuhi tujuan anda, atau jika anda berharap mengambil keuntungan dari beberapa jenis kolom basisdata kurang umum, anda dapat membuat kelas bidang anda sendiri. Cakupan penuh dari membuat bidang-bidang anda sendiri disediakan dalam Bagaimana membuat bidang model disesuaikan.
\nMetaLink to this heading#Memberikan model anda metadata dengan menggunakan class Meta sebelah dalam, seperti begitu:
from django.db import models\n\n\nclass Ox(models.Model):\n horn_length = models.IntegerField()\n\n class Meta:\n ordering = ["horn_length"]\n verbose_name_plural = "oxen"\nMetadata model adalah "apapun yang bukan sebuah bidang", seperti pilihan pengurutan (ordering), nama tabel basisdata (db_table), atau nama-nama tunggal dan jamal dapat-dibaca-manusia (verbose_name dan verbose_name_plural). Tidak satupun diwajibkan, dan menambahkan class Meta pada sebuah model adalah sepenuhnya pilihan.
Daftar lengkap dar semua kemungkinan pilihan Meta dapat ditemukan dalam model option reference.
objectsAtribut paling penting dari sebuah model adalah Manager. Itu adalah antarmuka melalui tindakan permintaan basisdata mana yang disediakan pada model-model dan digunakan pada retrieve the instances dari basisdata. Jika tidak ada penyesuaian Manager ditentukan, nama awalan adalah objects. Pengelola hanya dapat diakses melalui kelas-kelas model, bukan instance-instance model.
Tentukan metode penyesuaian pada sebuah model untuk menambah fungsionalitas "tingkat-baris" pada obyek-obyek anda. Sedangkan metode Manager dimaksudkan melakukan hal-hal "lebar-tabel", metode model harus bertindak pada instance model tertentu.
Ini adalah teknik bernilai untuk menjaga logika bisnis dalam satu tempat -- model.
\nSebagai contoh, model ini mempunyai beberapa cara penyesuaian:
\nfrom django.db import models\n\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\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 @property\n def full_name(self):\n "Returns the person's full name."\n return f"{self.first_name} {self.last_name}"\nCara terakhir di contoh ini adalah property.
\nmodel instance reference mempunyai daftar lengkap dari methods automatically given to each model. Anda dapat menimpa kebanyakan dari ini -- lihat overriding predefined model methods, dibawah -- tetapi ada sepasang yang anda akan hampir selalu ingin tentukan:
\n__str__()"magic methode" Python yang mengembalikan sebuah string mewakili obyek apapun. Ini adalah apa Python dan Django akan gunakan ketika sebuah instance model butuh dipaksa dan ditampilkan sebagai sebuah string kosong. Kebanyakan terutama, ini terjadi ketika anda menampilkan sebuah obyek dalam sebuah konsol interaktif atau dalam admin.
\nAnda akan selalu ingin menentukan cara ini; cara awal tidak membantu sama sekali.
\nget_absolute_url()Ini memberitahu Django bagaimana menghitung URL untuk sebuah obyek. Django menggunakan ini dalam antarmuka adminnya, dan kapan pun itu butuh mencari tahu untuk sebuah obyek.
\nObyek apapun yang mempunyai sebuah URL yang unik mencirikan itu harus menentukan metode ini.
\nAda kumpulan lain dari model methods yang mengenkapsulasi sekolompok perilaku basisdata yang anda akan ingin sesuaikan. Khususnya anda akan sering ingin dirubah merubah cara save() dan delete() bekerja.
Anda bebas untuk menimpa metode ini (dan cara model lainnya) untuk merubah perilaku.
\nSebuah penggunaan-kasus klasik untuk menimpa metode-metode siap pakai jika anda ingin sesuatu terjadi ketika anda menyimpan sebuah obyek. Sebagai contoh (lihat save() untuk dokumentasi dari parameter-parameter itu terima):
from django.db import models\n\n\nclass Blog(models.Model):\n name = models.CharField(max_length=100)\n tagline = models.TextField()\n\n def save(self, **kwargs):\n do_something()\n super().save(**kwargs) # Call the "real" save() method.\n do_something_else()\nAnda dapat juga mencegah mengatakan:
\nfrom django.db import models\n\n\nclass Blog(models.Model):\n name = models.CharField(max_length=100)\n tagline = models.TextField()\n\n def save(self, **kwargs):\n if self.name == "Yoko Ono's blog":\n return # Yoko shall never have her own blog!\n else:\n super().save(**kwargs) # Call the "real" save() method.\nIt's important to remember to call the superclass method -- that's\nthat super().save(**kwargs) business -- to ensure that the object still\ngets saved into the database. If you forget to call the superclass method, the\ndefault behavior won't happen and the database 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 **kwargs bit does. Django\nwill, from time to time, extend the capabilities of built-in model methods,\nadding new keyword arguments. If you use **kwargs in your method\ndefinitions, you are guaranteed that your code will automatically support those\narguments when they are added.
If you wish to update a field value in the save() method, you may\nalso want to have this field added to the update_fields keyword argument.\nThis will ensure the field is saved when update_fields is specified. For\nexample:
from django.db import models\nfrom django.utils.text import slugify\n\n\nclass Blog(models.Model):\n name = models.CharField(max_length=100)\n slug = models.TextField()\n\n def save(self, **kwargs):\n self.slug = slugify(self.name)\n if (\n update_fields := kwargs.get("update_fields")\n ) is not None and "name" in update_fields:\n kwargs["update_fields"] = {"slug"}.union(update_fields)\n super().save(**kwargs)\nSee Menentukan bidang-bidang mana yang disimpan for more details.
\n\nPola umum lain sdang menulis pernyataan SQL penyesuaian dalam metode-metode model dan metode-metode tingkat-modul. Untuk rincian lebih pada menggunakan SQL mentah, lihat dokumentasi pada using raw SQL.
\nWarisan model dalam Django bekerja hampir sama pada cara biasa warisan kelas bekerja dalam Python, tetapi dasar-dasar pada permulaan dari halaman harus masih diikuti. Itu berarti kelas dasar harus mensubkelaskan django.db.models.Model.
Satu-satunya keputusan yang anda punya untuk membuat apakah anda ingin model-model induk menjadi model-model dalam hak mereka sendiri (dengan tabel-tabel basisdata mereka sendiri), atau jika induk hanya menampung dari informasi umum yang akan hanya nampak melalui model-model anak.
\nAda tiga gaya warisan yang mungkin di Django.
\nSering, anda akan hanya ingin menggunakan kelas induk untuk menampung informasi yang anda tidak ingin miliki untuk mengetikkan setiap model anak. Kelas ini tidak akan pernah digunakan dalam pengasingan, jadi Kelas-kelas dasar abstrak adalah apa yang anda kejar.
Jika anda sedang mensubkelaskan sebuah model yang ada (mungkin sesuatu dari aplikasi lain seluruhnya) dan ingin setiap model memiliki tabel basisdata itu sendiri, Warisan banyak-tabel adalah cara untuk pergi.
Akhirnya, jika anda hanya ingin merubah perilaku tingkat-Python dari sebuah model, tanpa merubah bidang-bidang model dalam cara apapun, anda dapat menggunakan Model proxy.
Abstract base classes are useful when you want to put some common\ninformation into a number of other models. You write your base class\nand put abstract=True in the Meta\nclass. This model will then not be used to create any database\ntable. Instead, when it is used as a base class for other models, its\nfields will be added to those of the child class.
Sebuah contoh:
\nfrom django.db import models\n\n\nclass CommonInfo(models.Model):\n name = models.CharField(max_length=100)\n age = models.PositiveIntegerField()\n\n class Meta:\n abstract = True\n\n\nclass Student(CommonInfo):\n home_group = models.CharField(max_length=5)\nModel Student akan mempunyai tiga bidang: name, age dan home_group. Model CommonInfo tidak dapat digunakan sebagai model Django biasa, sejak itu adalah sebuah kelas dasar abstrak. Itu tidak membangkitkan sebuah tabel basisdata atau mempunyai sebuah pengelola, dan tidak dapat di instansiasikan atau disimpan langsung.
Fields inherited from abstract base classes can be overridden with another\nfield or value, or be removed with None.
Untuk banyak penggunaan, jenis ini dari warisan model akan tepatnya apa yang anda inginkan. Itu menyediakan sebuah cara untuk faktor luar informasi umum pada tingkat Python, selagi masih hanya membuat satu tabel basisdata per model anak pada tingkat basisdata.
\nMeta warisanLink to this heading#Ketika sebuah kelas dasar abstrak dibuat, Django membuat kelas sebelah dalam Meta apapun anda nyatakan di kelas dasar tersedia sebagai sebuah atribut. Jika sebuah kelas anak tidak menyatakan kelas Meta nya sendiri, itu akan mewarisi Meta induk. Jika anak ingin memperpanjang kelas Meta induk, itu dapat mensubkelaskan itu. Sebagai contoh:
\nfrom django.db import models\n\n\nclass CommonInfo(models.Model):\n # ...\n class Meta:\n abstract = True\n ordering = ["name"]\n\n\nclass Student(CommonInfo):\n # ...\n class Meta(CommonInfo.Meta):\n db_table = "student_info"\nDjango does make one adjustment to the Meta class of an\nabstract base class: before installing the Meta\nattribute, it sets abstract=False. This means that children of abstract\nbase classes don't automatically become abstract classes themselves. To make\nan abstract base class that inherits from another abstract base class, you need\nto explicitly set abstract=True on the child.
Beberapa atribut tidak akan masuk akal untuk disertakan dalam kelas Meta dari sebuah kelas dasar abstrak. Sebagai coontoh, menyertakan db_table akan berarti bahwa semua kelas-kelas anak (satu yang tidak menentukan milik mereka Meta) akan menggunakan tabel basisdata sama, yang hampir pasti bukan yang anda inginkan.
Due to the way Python inheritance works, if a child class inherits from\nmultiple abstract base classes, only the Meta options\nfrom the first listed class will be inherited by default. To inherit Meta options from multiple abstract base classes, you must\nexplicitly declare the Meta inheritance. For example:
\nfrom django.db import models\n\n\nclass CommonInfo(models.Model):\n name = models.CharField(max_length=100)\n age = models.PositiveIntegerField()\n\n class Meta:\n abstract = True\n ordering = ["name"]\n\n\nclass Unmanaged(models.Model):\n class Meta:\n abstract = True\n managed = False\n\n\nclass Student(CommonInfo, Unmanaged):\n home_group = models.CharField(max_length=5)\n\n class Meta(CommonInfo.Meta, Unmanaged.Meta):\n pass\nJenis kedua dari warisan model didukung oleh Django adalah ketika setiap model dalam hirarki adalah sebuah model semua oleh itu sendiri. Setiap model berhubungan ke tabel basisdata itu sendiri dan dapat diminta dan dibuat sendiri-sendiri. Hubungan warisan memperkenalkan tautan diantara model anak dan setiap dari induknya (melalui dibuat-otomatis OneToOneField). Sebagai contoh:
from django.db import models\n\n\nclass Place(models.Model):\n name = models.CharField(max_length=50)\n address = models.CharField(max_length=80)\n\n\nclass Restaurant(Place):\n serves_hot_dogs = models.BooleanField(default=False)\n serves_pizza = models.BooleanField(default=False)\nAll of the fields of Place will also be available in Restaurant,\nalthough the data will reside in a different database table. So these are both\npossible:
>>> Place.objects.filter(name="Bob's Cafe")\n>>> Restaurant.objects.filter(name="Bob's Cafe")\nIf you have a Place that is also a Restaurant, you can get from the\nPlace object to the Restaurant object by using the lowercase version of\nthe model name:
>>> p = Place.objects.get(id=12)\n# If p is a Restaurant object, this will give the child class:\n>>> p.restaurant\n<Restaurant: ...>\nBagaimanapun, jika p dalam contoh-contoh diatas bukan sebuah Restaurant (itu telah dibuat langsung sebagai sebuah obyek Place atau induk dari beberapa kelas lain(, mengacu pada p.restaurant akan memunculkan sebuah pengecualian Restaurant.DoesNotExist.
OneToOneField dibuat-otomatis pada Restaurant yang mengkaitkan itu ke Place terlihat seperti ini:
place_ptr = models.OneToOneField(\n Place,\n on_delete=models.CASCADE,\n parent_link=True,\n primary_key=True,\n)\nAnda dapat menimpa bidang itu dengan menyatakan OneToOneField anda sendiri dengan parent_link=True pada Restaurant.
Meta dan warisan banyak-tabelLink to this heading#Dalam keadaan warisan banyak-tabel, itu tidak masuk akal untuk sebuah kelas anak mewarisi dari kelas Meta induknya. Semua pilihan Meta telah diberlakukan ke kelas induk dan memberlakukan mereka kembali akan biasanya hanya membawa ke perilaku bertentangan (ini adalah berlawanan dengan kasus kelas dasar abstrak, dimana kelas dasar tidak ada dalam hak itu sendiri).
\nJadi sebuah model anak tidak mempunyai akses ke kelas Meta induknya. Bagaimanapun, ada sedikit kasus terbatas ketika anak mewarisi perilaku dari induk: jika anak tidak menentukan sebuah atribut ordering atau sebuah atribut get_latest_by, itu akan mewarisi ini dari induknya.
Jika induk mempunyai sebuah pengurutan dan anda tidak ingin anak mempunyai pengurutan alami, anda dapat jelas meniadakan itu:
\nclass ChildModel(ParentModel):\n # ...\n class Meta:\n # Remove parent's ordering effect\n ordering = []\nBecause multi-table inheritance uses an implicit\nOneToOneField to link the child and\nthe parent, it's possible to move from the parent down to the child,\nas in the above example. However, this uses up the name that is the\ndefault related_name value for\nForeignKey and\nManyToManyField relations. If you\nare putting those types of relations on a subclass of the parent model, you\nmust specify the related_name\nattribute on each such field. If you forget, Django will raise a validation\nerror.
Sebagai contoh, menggunakan kelas Place diatas lagi, mari kita membuat subkelas lain dengan sebuah ManyToManyField:
class Supplier(Place):\n customers = models.ManyToManyField(Place)\nThis results in the error:
\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'.\nMenambahkan related_name ke bidang customers seperti berikut akan menyelesaikan kesalahan: models.ManyToManyField(Place, related_name='provider').
Sebagai disebutkan, Django akan otomatis membuat sebuah OneToOneField menghubungkan ke kelas anak anda kembali ke model induk bukan-abtrak apapun. Jika anda ingin mengendalikan nama dari atribut menghubungkan kembali ke induk, anda dapat membuat OneToOneField anda sendiri dan menyetel parent_link=True untuk menunjukkan bahwa bidang anda menghubungkan kembali ke kelas induk.
Ketika menggunakan multi-table inheritance, tabel basisdata baru dibuat untuk setiap subkelas dari model. Ini biasanya keinginan kebiasaan, sejak subkelas butuh tempar menyimpan bidang data tambahan apapun yang tidak hadir pada kelas dasar. Terkadang, bagaimanapun, anda hanya ingin merubah kebiasaan Python dari model -- mungkin merubah pengelola awalan, atau menambah metode baru.
\nIni adalah kegunaan warisan model proxy: membuat sebuah proxy untuk model asli. Anda dapat membuat, menghapus dan memperbaharui instance-instance dari model proxy dan semua data akan disimpan seperti jika anda sedang menggunakan model (bukan-proxy) asli. Perbedaannya adalah bahwa anda dapat merubah hal-hal seperti pengurutan model awalan atau pengelola awalan dalam proxy, tanpa harus merubah aslinya.
\nModel proxy dinyatakan seperti model-model biasa. Anda memberitahu Django bahwa model proxynya dengan mengatur atribut proxy dari kelas Meta menjadi False.
Sebagai contoh, misalnya anda ingin menambahkan sebuah metode ke model Person. Anda dapat melakukannya seperti ini:
from django.db import models\n\n\nclass Person(models.Model):\n first_name = models.CharField(max_length=30)\n last_name = models.CharField(max_length=30)\n\n\nclass MyPerson(Person):\n class Meta:\n proxy = True\n\n def do_something(self):\n # ...\n pass\nThe MyPerson class operates on the same database table as its parent\nPerson class. In particular, any new instances of Person will also be\naccessible through MyPerson, and vice-versa:
>>> p = Person.objects.create(first_name="foobar")\n>>> MyPerson.objects.get(first_name="foobar")\n<MyPerson: foobar>\nYou could also use a proxy model to define a different default ordering on\na model. You might not always want to order the Person model, but regularly\norder by the last_name attribute when you use the proxy:
class OrderedPerson(Person):\n class Meta:\n ordering = ["last_name"]\n proxy = True\nSekarang permintaan Person biasa akan tidak diurutkan dan permintaan OrderedPerson akan diurutkan berdasarkan last_name.
Model-model proxy mewarisi atribut Meta in the same way as regular models.
QuerySet masih mengembalikan model yang telah dimintaLink to this heading#Tidak ada jalan Django kembali, katakan, sebuah obyek MyPerson kapanpun anda meminta untuk obyek Person. Sebuah queryset untuk obyek Person akan mengembalikan jenis-jenis itu dari obyek. Titik keseluruhan dari obyek proxy adalah bahwa kode bergantung pada Person asli akan menggunakan itu dan kode anda sendiri dapat menggunakan perpanjangan anda sertakan (yang tidak ada kode lain bergantung bagaimanapun) Itu bukan sebuah cara mengganti Person (atau model lain) dimanapun dengan sesuatu dari pembuatan anda sendiri.
Sebuah model proxy harus mewarisi dari tepatnya satu kelas model bukan-abstrak. Anda tidak dapat mewarisi dari banyak model bukan-abstrak sebagai model proxy tidak menyediakan hubungan apapun diantara baris-baris dalam tabel-tabel basisdata berbeda. Sebuah model proxy dapat mewarisi dari angka apapun dari kelas-kelas model abstrak, menyediakan mereka tidak menentukan bidang-bidang model apapun. Sebuah model proxy mungkin juga mewarisi dari angka apapun dari model-model proxy yang berbagi kelas induk bukan-abstrak umum.
\nJika anda tidak menentukan pengelola model apapun pada model proxy, itu mewarisi pengelola dari induk modelnya. Jika anda menentukan sebuah pengelola pada model proxy, itu akan menjadi awalan, meskipun pengelola apapun ditentukan pada kelas-kelas induk akan masih tersedia.
\nMelanjutkan contoh kami dari atas, anda dapat merubah pengelola awalan digunakan ketika anda meminta model Person seperti ini:
from django.db import models\n\n\nclass NewManager(models.Manager):\n # ...\n pass\n\n\nclass MyPerson(Person):\n objects = NewManager()\n\n class Meta:\n proxy = True\nJika anda ingin menambahkan sebuah pengelola baru pada Proxy, tanpa mengganti awalan yang ada, anda dapat menggunakan teknik-teknik digambarkan dalam dokumentasi custom manager : buat sebuah kelas dasar mengandung pengelola baru dan mewarisi itu setelah kelas dasar utama:
\n# Create an abstract class for the new manager.\nclass ExtraManagers(models.Model):\n secondary = NewManager()\n\n class Meta:\n abstract = True\n\n\nclass MyPerson(Person, ExtraManagers):\n class Meta:\n proxy = True\nAnda mungkin tidak butuh melakukan ini terlalu sering, tetapi, ketika anda melakukan, sangat memungkinkan.
\nWarisan model proxy mungkin terlihat cukup mirip untuk membuat sebuah model tidak dikendalikan, menggunakan atribut managed pada kelas Meta model.
Dengan pengaturan hati-hati dari Meta.db_table anda dapat membuat sebuah model tidak dikendalikan yang membayangi sebuah model yang ada dan menambahkan metode-metode Python pada itu. Bagaimanapun, bahwa akan menjadi berulang dan rentan ketika anda butuh menjaga kedua salinan sinkronisasi jika anda membuat perubahan apapun.
Di sisi lain, model-model proxy berusaha untuk berperilaku tepatnya seperti model mereka sedang memproxikan. Mereka selalu dalam sinkronisasi dengan model induk sejak mereka langsung mewarisi bidang-bidang dan pengelolanya.
\nAturan-aturan umum adalah:
\nJika anda sedang mencerminkan model yang ada atau tabel basisdata dan tidak ingin semua kotom tabel basisdata asli, gunakan Meta.managed=False. Pilihan itu biasanya berguna untuk permodelan tampilan basisdata dan tabel tidak dibawah kendali Django.
Jika anda ingin merubah perilaku hanya-Python dari sebuah model, tetapi menjaga semua bidang sama sebagai dalam aslinya, gunakan Meta.proxy=True. Ini menyetel sehingga model proxy adalah sebuah salinan tepat dari struktur penyimpanan dari model asli ketika data disimpan.
Sama seperi pensubkelasan Python, itu memungkinkan untuk model Django untuk mewarisi dari banyak model induk. Mengingat bahwa aturan keputusan nama Python biasa berlaku. Kelas dasar pertama yang nama tertentu (sebagai contoh Meta 1) muncul akan menjadi satu yang digunakan; sebagai contoh, ini berarti bahwa jika banyak induk mengandung kelas Meta 2, hanya satu pertama yang akan digunakan, dan semua lainnya akan diabaikan.
\nUmumnya, anda tidak akan butuh mewarisi banyak induk. Kasus-kegunaan utama dimana ini berguna adalah untuk kelas "mix-in": menambahkan bidang ekstra tertentu atau metode pada setiap kelas yang mewarisi mix-in. Coba untuk menjaga hirarki warisan anda sesederhana dan semudah mungkin sehingga anda tidak harus berjuang bekerja diluar dimana potongan tertentu dari informasi berasal.
\nCatat bahwa mewarisi dari banyak model yang mempunyai primary key id umum akan memunculkan sebuah kesalahan. Untuk penggunaan benar warisan banyak, anda dapat menggunakan AutoField jelas dalam model dasar.
class Article(models.Model):\n article_id = models.AutoField(primary_key=True)\n ...\n\n\nclass Book(models.Model):\n book_id = models.AutoField(primary_key=True)\n ...\n\n\nclass BookReview(Book, Article):\n pass\nAtau gunakan leluhur paling umum untuk menahan AutoField. Ini mewajibkan menggunakan sebuah OneToOneField secara jelas dari setiap model induk pada leluhur umum untuk menghindari bentrokan diantara bidang yang otomatis dibangkitkan dan diwarisi oleh anak:
class Piece(models.Model):\n pass\n\n\nclass Article(Piece):\n article_piece = models.OneToOneField(\n Piece, on_delete=models.CASCADE, parent_link=True\n )\n ...\n\n\nclass Book(Piece):\n book_piece = models.OneToOneField(Piece, on_delete=models.CASCADE, parent_link=True)\n ...\n\n\nclass BookReview(Book, Article):\n pass\nDalam warisan kelas Python biasan itu diizinkan untuk kelas anak menimpa atribut apapun dari kelas induk. Dalam Django, ini tidak biasanya diizinkan untuk bidang model. Jika kelas dasar model bukan-abstrak mempunyai sebuah bidang disebut author, anda tidak dapat membuat bidang model lain atau menentukan sebuah atribut disebut author dalam kelas apapun yang mewarisi dari kelas dasar.
Batasan ini tidak berlaku ke bidang model diwarisi dari sebuah model abstrak. Bidang itu mungkin ditimpa dengan bidang atau nilai lain, atau dipindahkan dengan mengatur field_name = None.
Menimpa bidang-bidang dalam model induk membawa ke kesulitan dalam kawasan seperti pengawalan instance baru (menentukan bidang mana sedang diawalkan dalam Model.__init__) dan serialisasi. Ini adalah fitur-fitur yang warisan kelas Python biasa tidak harus berurusan dengan cara yang sama, jadi perbedaan diantara kelas warisan model Django tidak berubah-ubah.
Pembatasan ini hanya berlaku pada atribut-atribut yang adalah instance Field. Atribut Python biasa dapat ditimpa jika anda harapkan. Itu juga hanya berlaku pada nama dari atribut seperti Python lihat: jika anda sedang secara manual menentukan nama kolom basisdata, anda dapat mempunyai nama kolom sama muncul di kedua model anak dan leluhur untuk warisan banyak-tabel (mereka adalah kolom-kolom dalam dua tabel-tabel basisdata berbeda).
Django akan memunculkan sebuah FieldError jika anda menimpa bidang model apapun dalam model pendahulu apapun.
Note that because of the way fields are resolved during class definition, model\nfields inherited from multiple abstract parent models are resolved in a strict\ndepth-first order. This contrasts with standard Python MRO, which is resolved\nbreadth-first in cases of diamond shaped inheritance. This difference only\naffects complex model hierarchies, which (as per the advice above) you should\ntry to avoid.
\nPerintah manage.py startapp membuat sebuah struktur aplikasi yang menyertakan sebuah berkas models.py. Jika anda mempunyai banyak model, mengorganisasikan mereka dalam berkas-berkas terpisah mungkin membantu.
Untuk melakukannya, buat sebuah paket models. Pindahkan models.py dan buat sebuah direktori myapp/models/ dengan sebuah berkas __init__.py dan berkas-berkas untuk menyimpan model-model anda. Anda harus mengimpor model-model dalam berkas __init__.py.
Sebagai contoh, jika anda mempunyai organic.py dan synthetic.py dalam direktori models:
myapp/models/__init__.pyfrom .organic import Person\nfrom .synthetic import Robot\nJelas mengimpor setiap model daripada menggunakan from .models import * mempunyai keuntungan dari tidak berantakan namespace, membuat kode lebih dapat dibaca, dan menjaga alat analisa kode berguna.