models數據模型學習筆記

        每一個應用通常都會定義一個或多個models，這個數據models其實是與數據庫相關的，models中的每一個屬性都是數據庫當中的一個字段，每一個字段是數據庫中的一個列。在models中定義的每一個類至關於數據庫當中的table.如

 

 

[python] view plain copy

1. class  Musician(models.Model):  
2. 　　First_name = models.CharField(max_length = 50 )  
3. 　　Last_name = models.CharField(max_length = 50 )  
4. 　　Instrument = models.CharField(max_length = 100 )  
5. 　　  
6. class Album(models.Model):  
7. 　　Artist = models.ForeignKey(Musician)  
8. 　　Name = models.CharField(max_length = 100)  
9. 　　Release_date = models.DateField()  
10. 　　Num_starts = models.IntegerField()  

 

 

        如上所示，每一個class的屬性都是models中的某些字段類的實例，如Name是models.CharField的實例。Models中有許多的字段屬性類。而且這些字段屬性類均有一些參數，用於修飾這些class內的屬性，如Name是CharField的實例，限定其最大字符爲100字節.那麼，這些字段屬性類都有哪些參數呢？下面列出一些經常使用的參數：

null:若爲true，dnango將在數據庫相應的字段中容許存儲null值，不然設爲flase

blank: 與null有點相似，可是不一樣，它主要用於確認一些如表單中是否帶有一些內容數據，若是blank設爲true,則容許表單內容爲空，不然設爲flase.

choices:帶此參數的字段通常爲2維的列表或元組，類中的屬性在定義時若含此參數，在頁面上將顯示一個select box框，其選項也被限定於choices給定的具體值，以下：

[python] view plain copy

1. YEAR__IN_SCHOOL_CHOICES = (  
2. 　(‘FR’, ‘Freshman’),  
3. 　(‘SO’, ‘Sophomore’),  
4. 　(‘JR’, ‘Junior’),  
5. 　(‘SR’, ‘Senior’),  
6. 　(‘GR’, ‘Graduate’),  
7. 　)  

        注：每一個元組中的第一個參數如’FR’等將被存於數據庫中，第二個參數將顯示在select box中。對於一個給定的model對象實例，choices字段顯示的值能夠經過get_YOURFIELD_display方法來訪問，以下：

[python] view plain copy

1. 　　From django.db import models  
2. 　　Class Person(models.Model):  
3. 　　    SHIRT_SIZES = (  
4. 　　(‘S’, ‘Small’),  
5. 　　(‘M’, ‘Medium’),  
6. 　　(‘L’, ‘Large’),  
7. 　　    )  
8. 　　    name = models.CharField(max_length = 60 )  
9. 　　shirt_size = models.CharField(max_length = 1, choices = SHIRT_SIZES)  
10. 　　  
11. >>>p = Person(name =」zhm」, shirt_size = ‘L’)  
12. >>>p.save()  
13. >>>p.shirt_size  
14. u’L’  
15. >>>p.get_shirt_size_display()  
16. u’Large’   

default: 字段的默認值,能夠是個值或者是個callable的對象。若是是callable的，在每次新對象被建立時，它將被調用。

 

help_text: 

primary_key: 設爲true時爲model的primary_key.若不設置，則系統會自動添加一個IntegerField字段爲primary_key,每一個model必需要有一個字段被設置成primary_key = true.

 

自動的主鍵字段：默認時，django會給每一個model下面一個字段：

Id = models.AutoField(primary_key = true).這是一個自增的主鍵，若是要覆蓋系統的主鍵字段，能夠在model中的任何字段中設置primary_key = true便可。

 

Verbose field names(冗長的字段名稱）：

        除了ForeignKey, ManyToManyField, OneToOneField外，其它每種字段類型如CharField均有一個可選的第一個固定參數：Verbose Name.若是沒有給出這個參數值，django會自動的建立它，而自動建立的verbose name=字段實例名.以下：

 

[python] view plain copy

1. first_name = models.CharField(「person’s first name」, max_length = 30)  

 

此時verbose name = 「person’s first name」

而當

 

[python] view plain copy

1. first_name = models.CharField(max_length = 30)  

 

它的verbose name = 「first name」

另外，因爲ForeignKey, ManyToManyField及OneToOneField其第一個參數應爲一個model class,因此它的verbose name應該是顯示給出：

 

[python] view plain copy

1. Poll = models.ForeignKey(Poll, verbose_name = 「the related poll」)  
2. Sites = models.ManyToManyField(Site, verbose_name = 「list of sites」)  
3. Place = models.OneToOneField(Place, verbose_name = 「related place 「)  

 

 

Relationships

        主要有三類：many-to-one, many-to-many, one-to-one

Many-to-one 關係

        要定義一個多對一的關係，使用django.db.models.ForeignKey.其使用方法與其它字段類型同樣，如CharField，沒有任何區別,ForeignKey須要一個固定的參數，基於某個關係模型的類，舉個例子，好比一輛汽車與工廠的關係，工廠能夠建立許多的汽車，可是一輛汽車只能屬於某一個工廠。因此能夠用如下方式來建立：

[python] view plain copy

1. class Manufacturer(models.Model):  
2. 　　#...  
3. class Car(models.Model):  
4. 　　manufacturer = models.ForeignKey(Manufacturer)  
5. 　　#...  

        汽車是因爲某個工廠建立的，因此Car class中須要增長工廠的相關信息，這種關係表示爲ForeignKey. 而它的第一個參數爲Manufacturer，是一個model的名稱，這個ForeignKey也能夠接收其它參數，用於定義這些關係如何發生做用，不過這些參數都是可選的，之後本身能夠查看相關資料。

 

Many-to-many關係

        定義多對多關係可使用ManyToMany字段類型。其使用方法與其它字段類型一致。與ForeignKey同樣，它也要接受一個固定的參數，一個與之發生關係的model class的名稱。能夠舉這麼個例子來描述多對多的關係，好比說一個月餅上有許多的芝麻，而芝麻也能夠存在於多個月餅之上，因此它們的關係就能夠按如下方式來表示：

[python] view plain copy

1. class MoonCake(models.Model):  
2. 　　#...  
3. class Sesame(models.Model):  
4. 　　mooncakes = models.ManyToMany(MoonCake)  
5. 　　#...  

        建議ManyToMany對象以複數形式來表達一組相關的多個model對象，如上的mooncakes.此外，ManyToMany能夠在任意兩個model中，這個沒有任何關係，可是不能在兩個模型內均存在，即上面的ManyToMany也能夠定義在MoonCake內：sesames = models.ManyToMany(Sesame)

        通常來講，ManyToMany實例應該定義在那些將要在表單(form)中被編輯的對象內。如上面的月餅與芝麻的關係中，咱們更能想到的是，月餅擁有不少芝麻，而更少想到芝麻在多個月餅上，因此上面的關係是經過這種想法定義的，故在芝麻中定義ManyToMany.這樣MoonCake表單可讓用戶來選擇那些芝麻。

 

更復雜的Many-to-many關係：

        簡單的表述就是一我的，它能夠參加各類興趣小組，即每種興趣小組有許多的人員，這顯然是多對多的關係，可是除此以外，還須要其它的額外的信息，好比關於人員加入小組的時期，加入的緣由等，因此須要一箇中間耦合的modle來進行鏈接。具體代碼能夠表述以下：

[python] view plain copy

1. class Person(models.Model):  
2.     name = models.CharField(max_length = 128)  
3.     def __unicode__(self):  
4.         return self.name  
5.   
6. class Group(models.Model):  
7.     name = models.CharField(max_length=128)  
8.     members = models.ManyToMany(Person, through = ‘Membership’)  
9.     def __unicode__(self):  
10.         return self.name  
11.      
12. class Membership(models.Model):  
13.     person = models.ForeignKey(Person)  
14.     group = models.ForeignKey(Group)  
15.     date_joined = models.DateField()  
16.     invite_reason = models.CharField(max_length = 64)  

 

        請注意Group當中的」through」參數。當創建了一箇中間model時，如上面的Membership，將顯式的用外鍵foreignkey指定涉及到多對多關係的那些models.這些顯式的聲明定義了這兩個models的關係是怎樣的。下面來實際使用上面定義的模型：

[python] view plain copy

1. >>> ringo = Person.objects.create(name = ‘Ringo Starr」)  
2. >>> paul = Person.objects.create(name = 「Paul McCartney」)  
3. >>> beatles = Group.objects.create(name = 「The Beetles」)  
4. >>> m1 = Membership( person = ringo, group = beatles,  
5. ...       date_joined = date(1962, 8, 16)  
6. ...       invite_reason = 「Needed a new drummer」)  
7. >>> m1.save()  
8. >>> beatles.members.all()  
9. [<Person: Ringo Starr>]  
10. >>> ringo.group_set.all()  
11. [<Group: The Beatles>]  
12. >>> m2 = Membership.objects.create(person = paul, group = beatles,  
13. ...      date_joined = date(1960,8,1)  
14. ...      invite_reason = 「Wanted to form a band.」)  
15. >>> beatles.member.all()  
16. [<Person: Ringo Starr>],[<Person: Paul McCartney>]  

 

        與簡單正常的多對多關係不同，不能使用add, create或者賦值來建立這種關係對象,如：

 

[html] view plain copy

1. beatles.members.add(john)  
2. atles.members.create(name=」George Harrison」)  
3. Beatles.members = [join,paul,ringo, george]  

 

        以上這種方式對複雜的多對多關係是不可行的。這是由於直接建立建立Person與Group之間的對象關係沒法表達其他額外的信息，這些信息須要由Membership模型來提供。因此建立這種多對多關係對象的惟一方式就是建立中間件model對象的實例。因此remove()方法也不適合於複雜的多對多對象，相應有一個替代的函數clear()，

[python] view plain copy

1. >>>beatles.members.clear()  

這是可行的。

 

        建立複雜多對多模型後的對象查詢方式以下：

[python] view plain copy

1. >>> Group.objects.filter(members__name__startswith=’Paul’)  
2. [<Group: The Beatles>]  
3.   
4. >>> Person.objects.filter(group__name=’The Beatles’, membership__date_joined__gt = date(1961,1,1))  
5. [<Person: Ringo Starr>]  
6.   
7. >>> ringos_membership = Membership.objects.get(group = beatles, person=ringo)  
8. >>> ringos_membership.date_joined  
9. datetime.date(1962,8,16)  
10. >>> ringos_membership.invite_reason  
11. u’Needed a new drummer  
12.   
13. >>> ringos_membership = ringo.membership_set.get(group = beatles)  
14. >>> ringos_membership.date_joined  
15. datetime.date(1962,8,16)  
16. >>> ringos_membership.invite_reason  
17. u’Needed a new drummer  

One-to-one關係

        定義這種關係使用OneToOneField.須要一個固定參數：某個關係model的class,這種關係能夠理解成繼承的關係，好比建立了一個’place’的數據庫，裏面含有address, phone等標準的信息，若是你再建立一個‘餐館‘數據庫，它是創建在’place’數據庫之上的，由於‘餐館’也須要一些地址信息，因此將‘餐館’用OneToOneField定義到’place’之上。

 

跨文件的models

        能夠引用來自另外一個應用的model，只須要將另外一個應用的model import進來，而後就可使用了。見以下例子：

[python] view plain copy

1. from geography.models import ZipCode  
2. class Restaurant(models.Model):  
3. 　　#...  
4.     zip_code = models.ForeignKey(ZipCode)  

 

字段名稱的限制

1 不能是Python保留的關鍵字

2 不能含有2個‘_’，如：

 

[python] view plain copy

1. Class Example(models.Model):  
2. foo__bar = models.IntegerField() #error  

 

固然，django也是容許咱們自定義字段類型，能夠查閱相關文檔。

 

Meta Options

經過使用內部嵌套的class Meta能夠給定model的metadata，以下：

 

[python] view plain copy

1. Class ox(models.Model):  
2. 　　Horn_length = models.IntegerField()  
3.       
4. 　　Class Meta:  
5. 　　    ordering = [‘horn_length’]  
6. 　　    verbose_name_plural = 「oxen」  

 

此Meta的各類options有不少，能夠查看相關資料。

 

Model methods

須要知道的常常會用到的一系列函數方法：

__unicode__()

返回unicode表示的對象，這是python與django使用的，當model實例須要被強迫或顯示成文本字符時。

 

get_absolute_url():告訴django怎樣計算對象的url,django通常在它的admin接口上使用，不管什麼時候admin都須要知道一個對象的url.

 

覆蓋預約義的model 方法

便可以定製一些model的方法，常常要改變的是save()和delete()工做。

當在保存一個對象時你但願要進行一些其它額外的操做時，能夠改寫成以下方式：

[python] view plain copy

1. Class Blog(models.Model):  
2. 　　#....  
3. 　　def save(self, *args, **kwargs):  
4. 　　    do_something()  
5. 　　    super(Blog, self).save(*args, **kwargs) # call the real save()method  
6. 　　    do_something_else()  

 

Model繼承

    與python中正常的類繼承差很少，但要分清的是你是否要讓父類的model成爲它各自獨立的model（擁有各自獨立的數據庫表），仍是要讓父類保存通訊的數據信息，這樣就能夠在子model中可視了。

    在django中一共有三種方式的model繼承：

    1 父model用來保存信息，這樣就沒必要要輸入到子model中，因此這時父類不會以獨立的方式使用，這種方式爲抽象基類abstract base classes方式

    2 若是你是現有model的子類（有可能來自另外一個應用），須要讓每一個model都擁有它自己的數據庫表，mutil-table多表繼承採用的是這種方式

    3 最後，若是你要修改python級的model, 而不改變model的各字段，你可使用Proxy models方式。

Abstract base classes

    當你須要把一些共享的信息放入某個model中時，使用抽象基類的繼承方式是很是有用的。按正常的方式先寫好model,而後增長clss Meta，將屬性abstract設爲true便可。而後對於其它的model，要繼承於抽象基類，這樣抽像model的字段會被添加到子類中。以下：

[python] view plain copy

1. class CommonInfo(models.Model):  
2. 　　name = models.CharField(max_length = 100)  
3. 　　age = models.PositiveIntegerField()  
4. 　　  
5. 　　class Meta:  
6. 　　    Abstract = True  
7. 　　  
8. class Student(CommonInfo):  
9. 　　home_group = models.CharField(max_length = 5)  

 

    這樣Student就有三個字段：name, age, home_group,因此CommonInfo不能夠用做正常的Django model，由於它只是一個抽象基類,它並不生成一個數據庫，不能直接實例化或直接保存數據。因此這種抽象基類是很是有用的，它以python的方式提供了一種方法來提取出公共信息，同時僅當子model在建立數據庫時纔會建立相應的數據。

 

Meta的繼承

    當抽象基類被建立，django的作法是讓基類內部的Meta子類做爲一個可用的屬性。若是子類沒有聲明它本身的Meta類型，這將從父類的Meta中繼承過來，若是子類要擴展父類的Meta，能夠再進行子類化，以下例子

[python] view plain copy

1. class CommonInfo(models.Model):  
2. 　　name = models.CharField(max_length = 100)  
3. 　　age = models.PositiveIntegerField()  
4. 　　  
5. 　　class Meta:  
6. 　　    abstract = True  
7. 　　Ordering = [‘name’]  
8. 　　  
9. class Student(CommonInfo):  
10. 　　home_group = models.CharField(max_length = 5)  
11. 　　  
12. 　　class Meta(CommonInfo.Meta):  
13. 　　    db_table = ‘student_info’  

    Django的確對抽像基類中的Meta進行過一次修改，在子類進行安裝Meta屬性以前，它對abstract設置爲false,這意味着子類不會自動的成爲抽像基類，固然，若是咱們本身想讓子類成爲抽像基類的話，能夠顯式地設置abstruct爲true便可。

    注：有時有些屬性在將抽像類中的Meta類包含進來時會發生一些沒法很差理解的行爲。如包含db_table意味着全部的子類（沒必要描述他們本身的Meta)將使用基類全部的相同數據庫表，這讓子類也成爲abstract了，這就不是咱們想要的了。

 

當心related_name屬性參數

    若在ForeignKey或ManyToManyField中使用related_name屬性，必須讓字段名稱具備惟一性。不然將會引發一些問題，由於這個字段將會被包含到各個子類中，而每次此屬性字段都具備相同的值。

    要解決這個問題，在使用related_name在抽像類中時，注意，僅僅針對抽像類，名稱的部分要包含’%(app_label)s’和’%(class)s’。

    1 ‘%(class)s’ 將會被使用這個字段的底層類的名稱所代替。

    2 ‘%(app_label)s’將會被子類所在的底層應用名稱所代替。每一個安裝的應用都是惟一的，應用內的每一個model名稱也是惟一的。

    如如下例子，給定一個應用app common/models.py:

[python] view plain copy

1. class Base(models.Model):  
2. 　　m2m=models.ManyToManyField  
3. 　　        (OtherModel, related_name = 「%(app_label)s_%(class)s_related」)  
4.       
5. 　　class Meta:  
6. 　　    Abstract = True  
7.   
8. class ChildA(Base):  
9. 　　Pass  
10. class ChildB(Base):  
11. 　　Pass  

    接着還有另外一個應用rare/models.py;

[python] view plain copy

1. from common.models import Base  
2. class ChildB(Base):  
3.     pass  

 

    這樣，ChindA當中的m2m名稱將是common_childa_related， 同時ChindB中的m2m名稱爲common_childb_related，而另外一應用rare中的childB中的m2m爲rare_childb_related.這樣能夠保證惟一性。

    注意：若是不指定related_name屬性，系統會有默認的名稱，能夠查看相關資料。

 

 

Multi-table inheritance

Django支持的第二種model繼承方式是繼承父類的子model是各自獨立的，每種模型與其數據庫表相關聯，可進行分別獨立地建立與查詢操做。這種繼承關係將子model與它的每一個父model進行了鏈接（django自動採用OneToOneField的方式進行鏈接)，以下：

[python] view plain copy

1. class Place(models.Model):  
2. 　　name = models.CharField(max_length=50)  
3. 　　address = models.CharField(max_length=80)  
4. 　　  
5. class Restaurant(Place):  
6. 　　serves_hot_dogs = models.BooleanField()  
7. 　　serves_pizza = models.BooleanField()  

 

雖然數據保存在這兩個不一樣的數據庫表中，但Place中的全部字段在Restaurant中都可被訪問，（也能夠這麼理解：Place主要存儲全部相似於Restaurant各類商店的地址，Restaurant對象只能訪問其自己在Place中存放的地址，而Place則能夠訪問全部商店的地址和名稱），見以下例子：

[python] view plain copy

1. >>> Place.objects.filter(name=」Bob’s Cafe」)  
2. >>> Restaurant.objects.filter(name=」Bob’s Cafe」)  

 

Place包含着一個Restaurant的地址，既然知道了Restaurant的地址，因此咱們能夠從Place對象訪問到Restaurant對象，訪問的方式是使用小寫的Restaurant model名稱以下：

[python] view plain copy

1. >>> p = Place.objects.get(id = 12) #先獲取Restaurant對象的地址  

 

[python] view plain copy

1. #若是p是一個Restaurant對象，即p是一個子類  
2. >>>.p.restaurant #請注意，是小寫,這樣能夠直接訪問Restaurant對象  
3. <Restaurant:....>  

 

       因此咱們能夠得出結論，有兩種狀況，

       1若是p僅僅是Place的一條記錄，且這條記錄並非Restaurant關聯的，即這種記錄是Place獨有的。

       2 若p這條記錄不是Restaurant的地址，而是其它商店如Apple店的地址

在上述兩種狀況下經過p.restaurant訪問則會出現問題了。

 

 

關於Mutil-table inheritance中的Meta

在這種多表繼承中的狀況下，若是子類從父類中繼承它的Meta class，這種狀況是不合理的。全部的Meta Option都是應用於它的父類，若是繼承到子類中會產生一些衝突（這種狀況與抽象基類相反，抽象基類並不存在這種方式）

所以子model並不訪問它的父類的Meta class, 可是也有一些少量狀況能夠從父類繼承，好比，若是子類並無給出ordering屬性或者是get_latest_by屬性，那麼這些屬性將從他們的父類Meta class中繼承。

可是若是父類具備ording且你不想從父類中繼承它的ording，能夠顯式的將其設置爲disable，以下：

 

[python] view plain copy

1. class ChildModel( ParentModel):  
2.     ...  
3.     class Meta:  
4.         #remove parent’s ording effect  
5.         Ordering = []  

 

Inheritance and reverse relations

因爲多表繼承使用隱式的OneToOneField來鏈接父子model,如上例所示這可讓父model訪問至子model，可是，若是對於使用了一些如ForeignKey和ManyToManyField關係的model而言，這些關鍵字(ForeignKey和ManyToManyField)所帶的參數related_name的值是默認的，若是你想把這些關係繼承至其它model的子類時，必須在這些字段中顯示的提供related_name屬性，若是咱們不這麼操做，django在校驗validata或者syncdb操做時會引起一個error，如：

[python] view plain copy

1. Class Supplier(Place):  
2. 　　#必須在全部的關係中說明related_name  
3. 　　Customers = models.ManyToManyField(Restaurant, related_name = 「provider」)  

 

父model的鏈接字段說明

        如上提到，若是在基於非抽象型數據關係model時，django將在父子model中自動的建立OneToOneField以鏈接二者，這樣子model能夠訪問父model相應的字段，從父model中的對象也能夠間接的訪問子model的對象，可是若是在子model中想要更改父model中所提供的字段名稱時，能夠本身顯式的用OneToOneField（在參數中添加設置parent_link = True）來建立這種關係，以鏈接至父model.

 

Proxy models

        代理模型。代理model繼承的目的在於爲原始的model建立一個代理，咱們能夠進行建立，刪除，更新代理模型的實例，而且操做的結果將會保存在原始模型中，即，經過代理摸型間接的操做了原始模型。區別在於經過代理模型，不須要修改原始模型就能夠直接改變原始模型的一些東西，好比改變默認的model ordering或者默認的manager等。

代理model的聲明與正常的model沒什麼區別，只是要告訴django它是一個proxy的，方式爲在Meta中添加proxy屬性爲True.

例如，例設咱們如今要對前面提到的Person model添加一個方法，能夠以下操做：

[python] view plain copy

1. class MyPerson(Person):  
2.     class Meta:  
3.         Proxy = True  
4. def do_something(self):  
5.     ...  

        上面定義的MyPerson model，對它實例的操做結果能夠發生在它的父類Person身上，特別的，Person的新對象也能夠經過MyPerson來訪問，反之亦然：

[python] view plain copy

1. >>> p = Person.objects.create(first_name=」foobar」)  
2. >>> MyPerson.objects.get(first_name=」foobar」)  
3. <MyPerson: foobar>  

 

咱們能夠經過代理模型對原模型進行不一樣方式的排序，以下，能夠增長last_name屬性進行排序：

[python] view plain copy

1. class OrderedPerson(Person):  
2. 　　class Meta:  
3. 　　    ordering = [「last_name」]  
4. 　　    proxy = True  

 

        正常的原始Peson model的查詢是無序的，但OrderedPerson查詢後的排序是基於last_name來進行。咱們不可能經過Person來查詢並讓django返回MyPerson對象。另外，用代理並非說是以一種本身建立的模型來取代Person model的方式。

父類(基類的）一些約束

        Proxy model必須從一個（注意：是一個）非抽象的model類中繼承，不能從多個非抽象model中繼承，由於proxy model並無在不一樣的數據庫表的多行之間提供一些鏈接，proxy model也能夠從一些抽象基類中繼承，前提條件是他們不能定義model字段。

Proxy model會從非抽象父類model中繼承一些他們沒有定義的Meta選項.

  

Proxy model managers

        若是沒有詳細的給出proxy model的模型管理器(manager)，那它將從父model中繼承，若是在proxy model中定義了管理器，那麼它將取代父model的管理器，成爲默認的管理器，可是在父類中定義的這些管理器也仍是能夠訪問的。

如下是上述的例子，當你查詢Person model時你能夠改變它的默認管理器：

 

[python] view plain copy

1. class NewManager(models.Manager):  
2.     ...  
3. class MyPerson(Peson):  
4.     objects = NewManager()  
5.     class Meta:  
6.       Proxy = True   

 

    若是咱們想增長新的管理器至Proxy，而不會取代現有的默認管理器，可使用相關文檔描述的技術細節，它的主要方法是，建立一個包含新的管理器的基類，而後繼承它，緊接在primary基類以後，以下：

 

1. #爲新管理器建立一個抽象類  
2. class ExtraManagers(models.Model):  
3.     secondary = NewManager()  
4.     class Meta:  
5.         Abstract = True  
6. class MyPerson(Person, ExtraManagers): #緊接在Person以後  
7.     class Meta:  
8.          proxy = True;  

    咱們可能不會常常這樣作，可是有時也有須要的時候，因此這裏先了解一下。

 

關於Multiple inheritance

    與python的子類同樣，Django的model能夠從多個父model中繼承，正常的python命名規則也一樣適用，繼承的第一個基類的Meta將被使用，其他基類的Meta將會被忽略。

通常來講，不多會從多個父model中繼承，主要的使用原則就是越簡單越好，這樣能夠避免老是去尋找一些特殊的來自其它類中的信息。

 

Models的字段名是不能被隱匿的

    在正常的python繼承狀況下，它容許子類覆蓋父類的一些屬性，而在Django,這是不容許的，由於若是一個基類model有一個字段稱爲author,那麼在你建立的另一個model中，若是它繼承了前面這個基類，則它是不能再建立一個名爲author的字段。若是你覆蓋一個父類當中的字段，django會產生一個FieldError錯誤。