models数据模型学习札记

models数据模型学习笔记

        每个应用一般都会定义一个或多个models，这个数据models实际上是与数据库相关的，models中的每个属性都是数据库当中的一个字段，每个字段是数据库中的一个列。在models中定义的每个类相当于数据库当中的table.如

class  Musician(models.Model):
　　First_name = models.CharField(max_length = 50 )
　　Last_name = models.CharField(max_length = 50 )
　　Instrument = models.CharField(max_length = 100 )
　　
class Album(models.Model):
　　Artist = models.ForeignKey(Musician)
　　Name = models.CharField(max_length = 100)
　　Release_date = models.DateField()
　　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给定的具体值，如下：

　YEAR__IN_SCHOOL_CHOICES = (
　　(‘FR’, ‘Freshman’),
　　(‘SO’, ‘Sophomore’),
　　(‘JR’, ‘Junior’),
　　(‘SR’, ‘Senior’),
　　(‘GR’, ‘Graduate’),
　　)

        注：每个元组中的第一个参数如’FR’等将被存于数据库中，第二个参数将显示在select box中。对于一个给定的model对象实例，choices字段显示的值可以通过get_YOURFIELD_display方法来访问，如下：

　　From django.db import models
　　Class Person(models.Model):
　　    SHIRT_SIZES = (
　　(‘S’, ‘Small’),
　　(‘M’, ‘Medium’),
　　(‘L’, ‘Large’),
　　    )
　　    name = models.CharField(max_length = 60 )
　　shirt_size = models.CharField(max_length = 1, choices = SHIRT_SIZES)
　　
>>>p = Person(name =”zhm”, shirt_size = ‘L’)
>>>p.save()
>>>p.shirt_size
u’L’
>>>p.get_shirt_size_display()
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=字段实例名.如下：

first_name = models.CharField(“person’s first name”, max_length = 30)

此时verbose name = “person’s first name”

而当

first_name = models.CharField(max_length = 30)

它的verbose name = “first name”

另外，由于ForeignKey, ManyToManyField及OneToOneField其第一个参数应为一个model class,所以它的verbose name应该是显示给出：

Poll = models.ForeignKey(Poll, verbose_name = “the related poll”)
Sites = models.ManyToManyField(Site, verbose_name = “list of sites”)
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需要一个固定的参数，基于某个关系模型的类，举个例子，比如一辆汽车与工厂的关系，工厂可以创建许多的汽车，但是一辆汽车只能属于某一个工厂。所以可以用以下方式来创建：

class Manufacturer(models.Model):
　　#...
class Car(models.Model):
　　manufacturer = models.ForeignKey(Manufacturer)
　　#...

        汽车是由于某个工厂创建的，所以Car class中需要增加工厂的相关信息，这种关系表示为ForeignKey. 而它的第一个参数为Manufacturer，是一个model的名称，这个ForeignKey也可以接收其它参数，用于定义这些关系如何发生作用，不过这些参数都是可选的，以后自己可以查看相关资料。

Many-to-many关系

        定义多对多关系可以使用ManyToMany字段类型。其使用方法与其它字段类型一致。与ForeignKey一样，它也要接受一个固定的参数，一个与之发生关系的model class的名称。可以举这么个例子来描述多对多的关系，比如说一个月饼上有许多的芝麻，而芝麻也可以存在于多个月饼之上，所以它们的关系就可以按以下方式来表示：

class MoonCake(models.Model):
　　#...
class Sesame(models.Model):
　　mooncakes = models.ManyToMany(MoonCake)
　　#...

        建议ManyToMany对象以复数形式来表达一组相关的多个model对象，如上的mooncakes.此外，ManyToMany可以在任意两个model中，这个没有任何关系，但是不能在两个模型内均存在，即上面的ManyToMany也可以定义在MoonCake内：sesames = models.ManyToMany(Sesame)

        一般来说，ManyToMany实例应该定义在那些将要在表单(form)中被编辑的对象内。如上面的月饼与芝麻的关系中，我们更能想到的是，月饼拥有很多芝麻，而更少想到芝麻在多个月饼上，所以上面的关系是通过这种想法定义的，故在芝麻中定义ManyToMany.这样MoonCake表单可以让用户来选择那些芝麻。

更复杂的Many-to-many关系：

        简单的表述就是一个人，它可以参加各种兴趣小组，即每种兴趣小组有许多的人员，这显然是多对多的关系，但是除此之外，还需要其它的额外的信息，比如关于人员加入小组的时期，加入的原因等，所以需要一个中间耦合的modle来进行连接。具体代码可以表述如下：

　　class Person(models.Model):
　　    name = models.CharField(max_length = 128)
　　    def __unicode__(self):
　　        return self.name
　　
　　class Group(models.Model):
　　    name = models.CharField(max_length=128)
　　    members = models.ManyToMany(Person, through = ‘Membership’)
　　    def __unicode__(self):
　　        return self.name
　　   
　　class Membership(models.Model):
　　    person = models.ForeignKey(Person)
　　    group = models.ForeignKey(Group)
　　    date_joined = models.DateField()
　　    invite_reason = models.CharField(max_length = 64)

        请注意Group当中的”through”参数。当建立了一个中间model时，如上面的Membership，将显式的用外键foreignkey指定涉及到多对多关系的那些models.这些显式的声明定义了这两个models的关系是怎样的。下面来实际使用上面定义的模型：

　　>>> ringo = Person.objects.create(name = ‘Ringo Starr”)
　　>>> paul = Person.objects.create(name = “Paul McCartney”)
　　>>> beatles = Group.objects.create(name = “The Beetles”)
　　>>> m1 = Membership( person = ringo, group = beatles,
　　...       date_joined = date(1962, 8, 16)
　　...       invite_reason = “Needed a new drummer”)
　　>>> m1.save()
　　>>> beatles.members.all()
　　[<Person: Ringo Starr>]
　　>>> ringo.group_set.all()
　　[<Group: The Beatles>]
　　>>> m2 = Membership.objects.create(person = paul, group = beatles,
　　...      date_joined = date(1960,8,1)
　　...      invite_reason = “Wanted to form a band.”)
　　>>> beatles.member.all()
　　[<Person: Ringo Starr>],[<Person: Paul McCartney>]

        与简单正常的多对多关系不一样，不能使用add, create或者赋值来创建这种关系对象,如：

    beatles.members.add(john)
　　beatles.members.create(name=”George Harrison”)
    Beatles.members = [join,paul,ringo, george]

        以上这种方式对复杂的多对多关系是不可行的。这是因为直接创建创建Person与Group之间的对象关系无法表达其余额外的信息，这些信息需要由Membership模型来提供。所以创建这种多对多关系对象的唯一方式就是创建中间件model对象的实例。所以remove()方法也不适合于复杂的多对多对象，相应有一个替代的函数clear()，

　　>>>beatles.members.clear()

这是可行的。

        创建复杂多对多模型后的对象查询方式如下：

　　>>> Group.objects.filter(members__name__startswith=’Paul’)
　　[<Group: The Beatles>]
　　
　　>>> Person.objects.filter(group__name=’The Beatles’, membership__date_joined__gt = date(1961,1,1))
　　[<Person: Ringo Starr>]
　　
　　>>> ringos_membership = Membership.objects.get(group = beatles, person=ringo)
　　>>> ringos_membership.date_joined
　　datetime.date(1962,8,16)
　　>>> ringos_membership.invite_reason
　　u’Needed a new drummer
　　
　　>>> ringos_membership = ringo.membership_set.get(group = beatles)
　　>>> ringos_membership.date_joined
　　datetime.date(1962,8,16)
　　>>> ringos_membership.invite_reason
　　u’Needed a new drummer

One-to-one关系

        定义这种关系使用OneToOneField.需要一个固定参数：某个关系model的class,这种关系可以理解成继承的关系，比如创建了一个’place’的数据库，里面含有address, phone等标准的信息，如果你再创建一个‘餐馆‘数据库，它是建立在’place’数据库之上的，因为‘餐馆’也需要一些地址信息，所以将‘餐馆’用OneToOneField定义到’place’之上。

 

跨文件的models

        可以引用来自另一个应用的model，只需要将另一个应用的model import进来，然后就可以使用了。见如下例子：

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

字段名称的限制

1 不能是python保留的关键字

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

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

当然，django也是允许我们自定义字段类型，可以查阅相关文档。

Meta Options

通过使用内部嵌套的class Meta可以给定model的metadata，如下：

Class ox(models.Model):
　　Horn_length = models.IntegerField()
    
　　Class Meta:
　　    ordering = [‘horn_length’]
　　    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()工作。

当在保存一个对象时你希望要进行一些其它额外的操作时，可以改写成如下方式：

Class Blog(models.Model):
　　#....
　　def save(self, *args, **kwargs):
　　    do_something()
　　    super(Blog, self).save(*args, **kwargs) # call the real save()method
　　    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的字段会被添加到子类中。如下：

class CommonInfo(models.Model):
　　name = models.CharField(max_length = 100)
　　age = models.PositiveIntegerField()
　　
　　class Meta:
　　    Abstract = True
　　
class Student(CommonInfo):
　　home_group = models.CharField(max_length = 5)

    这样Student就有三个字段：name, age, home_group,所以CommonInfo不可以用作正常的Django model，因为它只是一个抽象基类,它并不生成一个数据库，不能直接实例化或直接保存数据。所以这种抽象基类是非常有用的，它以python的方式提供了一种方法来提取出公共信息，同时仅当子model在创建数据库时才会创建相应的数据。

 

Meta的继承

    当抽象基类被创建，django的做法是让基类内部的Meta子类作为一个可用的属性。如果子类没有声明它自己的Meta类型，这将从父类的Meta中继承过来，如果子类要扩展父类的Meta，可以再进行子类化，如下例子

class CommonInfo(models.Model):
　　name = models.CharField(max_length = 100)
　　age = models.PositiveIntegerField()
　　
　　class Meta:
　　    abstract = True
　　Ordering = [‘name’]
　　
class Student(CommonInfo):
　　home_group = models.CharField(max_length = 5)
　　
　　class Meta(CommonInfo.Meta):
　　    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:

class Base(models.Model):
　　m2m=models.ManyToManyField
　　        (OtherModel, related_name = “%(app_label)s_%(class)s_related”)
    
　　class Meta:
　　    Abstract = True

class ChildA(Base):
　　Pass
class ChildB(Base):
　　Pass

    接着还有另一个应用rare/models.py;

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

    这样，ChindA当中的m2m名称将是common_childa_related， 同时ChindB中的m2m名称为common_childb_related，而另一应用rare中的childB中的m2m为rare_childb_related.这样可以保证唯一性。

    注意：如果不指定related_name属性，系统会有默认的名称，可以查看相关资料。

(.....待续...)