2 个文件          1,266 字节

               3 个目录 77,168,365,568 可用字节

(webproject) C:\webproject\mysite>python manage.py sqlmigrate polls 0001_initial   #查看sql语句是否是指定要求的

(webproject) C:\webproject\mysite>python manage.py shell  #进入交互式命令行

>>> from django.utils import timezone

>>> from polls.models import Question,Choice

>>> q = Question(question_text="what's new", pub_date=timezone.now())

>>> q.save()

>>> q.id

1

>>> q.pk   #django默认会增加id为pk

1

>>> q.question_text

"what's new"

>>> q.pub_date

datetime.datetime(2019, 1, 2, 6, 49, 16, 612213, tzinfo=)

>>> from polls.models import Question,Choice

>>> from django.utils import timezone

>>> q = Question.objects.create(question_text="how are you?", pub_date=timezone.now())

>>> q = Question.objects.create(question_text="what's the weather?", pub_date=timezone.now())

>>> q = Question.objects.create(question_text="fuck you!", pub_date=timezone.now())

>>> q

>>> q.was_published_recently()

True

>>> d = timezone.now() - timezone.timedelta(days=2)

>>> q.pub_date = d

>>> q.save()

>>> q.was_published_recently()

False

常用Field types：

https://docs.djangoproject.com/en/2.1/ref/models/fields/#choices

name = models.CharField(max_length=30)   #实例化时是py中的数据类型

num = models.IntegerField()

website = models.URLField()

email = models.EmailField()

models.AutoField()   #定义AI或PK时用

models.BooleanField()

models.TextField()

models.DateField()   #接收py中datetime对象，自动转为sql中的数据结构

models.PositiveIntegerField()   #正数

Relationship fields

关系：

authors = models.ManyToManyField(Author)   #many-to-many，如用户和组，博客项目中文章和标签；

publisher = models.ForeignKey(Publisher)   #many-to-one，如外键，1个问题有多个选项，1个选项只能属1个问题；如汽车-工厂；

moodels.OneToOneField()   #one-to-one，如Restaurant餐馆和place地点，如丈夫-妻子；

Field options：

field参数：

null   #default is False，mysql中空值用null表示，不能用''（''表示字符串的空串）

blank

choices   #同sqlalchemy中enum，展示在前端为不能让用户自己定义，而是在下拉列表中选择

default

help_text   #sql中的comment；form中的备注信息

primary_key   #默认自动加id作为主键，若显式指定将不会有默认id主键

unique

verbose_name   #若有定义，在form中将把此处定义的值大写，中间的_改为空格，显示为form中的label

例：

class Group(models.Model):

    pass

class User(models.Model):

    groups = models.ManyToManyField(Group)

例：

class Place(models.Model):

    name = models.CharField(max_length=50)

    address = models.CharField(max_length=80)

class Restaurant(models.Model):

    place = models.OneToOneField(Place, primary_key=True)

    servers_hot_dogs = models.BooleanField(default=False)

    servers_pizza = models.BooleanField(default=False)

例：

class Manufacturer(models.Model):

    pass

class Car(models.Model):

    manufacturer = models.ForeignKey(Manufacturer)

Meta options：

元编程，改变之前表中定义的元数据信息；

abstract   #abstract = True，this model will be an abstract base class，声明是基类，数据库将不会建此表

db_table   #db_table = 'music_album'指定表名

get_latest_by   #get_latest_by = 'order_date'指定此字段按升序，get_latest_by = ['-priority','order_date']指定priority按降序，order_date按升序；查询时Question.objects.latest()要先定义get_latest_by根据哪个字段走

ordering   #对象的默认顺序，获取对象列表，默认升序，前缀-降序，前缀?随机randomly，ordering = ['pub_date']，ordering = ['-pub_date', 'author']

unique_together   #联合唯一键，unique_together('driver','restaurant')

indexes   #联合索引

managed

verbose_name   #admin后台中显示的名字

重写save()方法：

from django.db import models

class Blog(models.Model):

         name = models.CharField(max_length=100)

         tagline = models.TextField()

         def save(self, *args, **kwargs):

                   do_something()

                   super(Blog, self).save(*args, **kwargs)   #import,call the real save() method，一定要调用父类的save()，否则不会保存到数据库

                   do_something()

模型继承：

抽象基类：

若只使用父类中的信息，用继承，而不用在子类模型中重复输入与父类相同的那些字段；

抽象出的基类不会单独使用；

使用Meta option，abstract = True，声明是基类，数据库将不会建此表；.

若子类不实现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:   #若子类不实现Meta，默认会继承

        db_table = 'student_info'

多表继承：

若继承一个已存在的模型且想让每个模型都有它自己的数据库表，应使用多表继承；

每一个层级下的每个model都是一个真正意义上完整的model，每个model都有专属的数据库表，都可查询和创建数据库表；

继承关系在子model和它的每个父类之间都添加一个链接，自动创建OneToOneField；

父类Place中未在Meta中定义abstract=True，子类Restaurant在查看表结构时，不会继承父类的name和address，而是主键place_str_id上有指针指向父类中的字段；

子类继承父类，子类创建的记录，父类中会自动有；

例：

class Place(models.Model):

    name = models.CharField(max_length=50)

    address = models.CharField(max_length=80)

class Restaurant(Place):

    servers_hot_dogs = models.BooleanField(default=False)

    servers_pizza = models.BooleanField(default=False)

sqlite> .schema publish_place

CREATE TABLE IF NOT EXISTS "publish_place" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "name" varchar(50) NOT NULL, "address" varchar(80) NOT NULL);

sqlite> .schema publish_restaurant

CREATE TABLE IF NOT EXISTS "publish_restaurant" ("place_ptr_id" integer NOT NULL PRIMARY KEY REFERENCES "publish_place" ("id"), "servers_hot_dogs" bool NOT NU

LL, "servers_pizza" bool NOT NULL);

>>> from publish.models import Place,Restaurant

>>> Place.objects.create(name='tsinghua', address='zhongguancun')

>>> Restaurant.objects.create(name='jia',address='bj',servers_hot_dogs=True,servers_pizza=False)

>>> p0 = Place.objects.get(name='tsinghua')

>>> p1 = Place.objects.get(name='jia')

>>> p2 = Restaurant.objects.get(name='tsinghua')   #X

……"C:\Users\Administrator\py_env\webproject\lib\site-packages\django\db\models\query.py", line 379, in get

    self.model._meta.object_name

publish.models.DoesNotExist: Restaurant matching query does not exist.

>>> p3 = Restaurant.objects.get(name='jia')

>>> p0.restaurant   #X

……"C:\Users\Administrator\py_env\webproject\lib\site-packages\django\db\models\fields\related_descriptors.py", line 404, in __get__

    self.related.get_accessor_name()

django.db.models.fields.related_descriptors.RelatedObjectDoesNotExist: Place has no restaurant.

>>> p1.restaurant

代理继承：

使用多表继承时，model的每个子类都会创建一张新数据表，因为子类需要一个空间来存储不包含在基类中的字段数据（如servers_hot_dogs、servers_pizza），有时只想更改model在py层的行为实现，如改默认的manager，或添加一个新方法，这时用代理继承；

为原始模型创建一个代理，可创建、删除、更新代理model的实例，而且所有的数据都可象使用原始model一样被保存；

不同之处在于，可在代理model中改变默认的排序设置和默认的manager，更不会对原始model产生影响；

使用Meta option，proxy = True，对代理model的声明；

MyPerson只是一个代理，数据库中不会创建该表，MyPerson类和其父类Person操作同一个数据表，特别之处，Person的实例也可通过MyPerson访问；

例：

class Person(models.Model):

    first_name = models.CharField(max_length=30)

    last_name = models.CharField(max_length=30)

class MyPerson(Person):

    class Meta:

        proxy = True

    def do_something(self):

        pass

>>> from publish.models import Person,MyPerson

>>> p = Person.objects.create(first_name='foobar')

>>> MyPerson.objects.get(first_name='foobar')

多重继承：

同多表继承，会自动添加2个OneToOneField，注意，2个基类的默认id要重新命名，否则添加OneToOneField会有问题，也不允许子类重写父类字段；

例：

class Article(models.Model):

    article_id = models.AutoField(primary_key=True)

class Book2(models.Model):

    book_id = models.AutoField(primary_key=True)

class Book2Review(Book, Article):

    pass