ORM表操作

1.在python脚本中调用django环境

在根文件夹下，创建test.py文件

import os
if __name__ == '__main__':
    os.environ.setdefault("DJANGO_SETTINGS_MODULE",'day76.settings')
    import django
    django.setup()

2.单表增删改查

-查询api   <1> all():                  查询所有结果                     <2> filter(**kwargs):       它包含了与所给筛选条件相匹配的对象          <3> get(**kwargs):          返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。 注意：返回的是查找到的对象，不是queryset对象。   <4> exclude(**kwargs):      它包含了与所给筛选条件不匹配的对象      <5> order_by(*field):       对查询结果排序('-id')      <6> reverse():              对查询结果反向排序             <8> count():                返回数据库中匹配查询(QuerySet)的对象数量。      <9> first():                返回第一条记录         <10> last():                返回最后一条记录           <11> exists():              如果QuerySet包含数据，就返回True，否则返回False       <12> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列                        model的实例化对象，而是一个可迭代的字典序列   <13> values_list(*field):   它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列              <14> distinct():            从返回结果中剔除重复纪录

-基于双下划线的模糊查询   Book.objects.filter(price__in=[100,200,300])   Book.objects.filter(price__gt=100)   Book.objects.filter(price__lt=100)   Book.objects.filter(price__gte=100)   Book.objects.filter(price__lte=100)   Book.objects.filter(price__range=[100,200])   Book.objects.filter(title__contains="python")   Book.objects.filter(title__icontains="python")   Book.objects.filter(title__startswith="py")   Book.objects.filter(pub_date__year=2012)

import os
if __name__ == '__main__':
    os.environ.setdefault("DJANGO_SETTINGS_MODULE",'day76.settings')
    import django
    django.setup()
    from app01 import models
    import datetime
    #一、 增，插入数据的两种方式：
    #时间可以传字符串，也可以传日期格式
    ctime=datetime.datetime.now()
    # 方式1：
    # book1=models.Book.objects.create(name='红楼梦',price=25.8,publish='南京出版社',author='曹雪芹',create_date=ctime)
    # print(book1.name)
    # 方式2：先实例化产生对象，然后调用save方法，保存
    # book2=models.Book(name='西游记',price=65.5,publish='东京出版社',author='吴承恩',create_date='2018-05-05')
    # book2.save()
    # print(book2.name)
    #二、删
    # 方式1：
    # ret=models.Book.objects.filter(name='西游记').delete()#ret是影响的行数，因为找到的对象是queryset，可能不止一个值
    # print(ret)
    # 方式2：
    # models.Book.objects.filter(name='西游记').first().delete()#找到指定的对象，然后进行删除
    # 三、修改
    # models.Book.objects.filter(name='西游记').update(price=85)#这个修改的是queryset对象，可能有多个值
    # book=models.Book.objects.filter(name='西游记').first()#这个修改的是找到的单个书对象，无法使用update方法
    # book.price=50#找到对象，修改它的price值
    # book.save()#然后进行保存
    # 四、查询
    # *******查询是重点******#
    '''
    1)all()                     查询所有结果
    2)filter(**kwargs)          包含了与所给筛选条件相匹配的对象
    3)get(**kwargs)             返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有，都会报错
    4)exclude(**kwargs)         它包含了与所给筛选条件不匹配的对象
    5)order_by(*field)          对查询结果排序
    6)reverse()                 对查询结果反向排序
    8)count()                   返回数据库中匹配查询（QuerySet）的对象数量
    9)first()                   返回第一条记录
    10)last()                   返回最后一条记录
    11)exists()                 如果queryset包含数据，就返回True，否则返回False
    12)values(*field)           返回一个valuequeryset一个特殊的queryset，运行后得到的并不是一系列model的实例化对象，而是一个可迭代的字典序列
    13)values_list(*field)      它与vaule()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
    14)distinct()               从返回结果中剔除重复记录

    基于双下划线的模糊查询
        Book.objects.filter(price__in=[100,200,300])
        Book.objects.filter(price__gt=100)
        Book.objects.filter(price__lt=100)
        Book.objects.filter(price__gte=100)
        Book.objects.filter(price__lte=100)
        Book.objects.filter(price__range=[100,200])
        Book.objects.filter(title__contains="python")
        Book.objects.filter(title__icontains="python")
        Book.objects.filter(title__startswith="py")
        Book.objects.filter(pub_date__year=2012)
    '''
    # all
    # ret=models.Book.objects.all()#查询所有
    # print(ret)
    # ret=models.Book.objects.filter(name='西游记').first()#查询名字为西游记的第一个
    # res=models.Book.objects.filter(name='西游记')[1]#查询名字为西游记的第二个,不支持负数
    # print(ret,res)
    # filter可以传多个参数,用逗号分隔，他们之间是and关系
    # ret=models.Book.objects.filter(name='西游记',price=50)
    # print(ret.query)#query是打印相关sql语句
    # get
    # ret=models.Book.objects.get(name='三国演义')#使用get只在值只有一个时才能用，不然报错,返回的是对象，不是query对象。通常用id来查
    # print(ret)
    # ret=models.Book.objects.get(id=1)
    # print(ret)
    # exclude
    # ret=models.Book.objects.exclude(name='西游记')#查询名字不叫西游记的书，结果也是queryset对象
    # print(ret)
    # ret=models.Book.objects.exclude(name='西游记',price=50)#查询除了名字叫西游记且价格为50的以外的所有书
    # print(ret)
    #order_by排序
    # ret=models.Book.objects.order_by('price')#按价格升序排，也可以传多个
    # print(ret)
    # ret=models.Book.objects.order_by('-price')#按价格降序排
    # print(ret)
    #reverse倒序
    # ret=models.Book.objects.order_by('price').reverse()#反向排序
    # print(ret)
    #count查结果个数，返回数据库中匹配查询queryset的对象数量
    # ret=models.Book.objects.all().count()
    # print(ret)
    # first和last第一个和最后一个
    # ret=models.Book.objects.all().first()
    # res=models.Book.objects.all().last()
    # print(ret,res)
    #exists,返回结果是布尔类型
    # ret=models.Book.objects.filter(name='python').exists()
    # print(ret)
    #values,里面包含了要查询的字段，如果不传值，则默认打印所有字段,返回的对象，里面有字典形式的数据
    # res=models.Book.objects.filter(name='python').values()
    # ret=models.Book.objects.filter(name='红楼梦').values('name','price')
    # print(ret,res)
    #value_list与values非常相似，它返回的是一个元组序列，values返回的是一个字典序列
    #distinct去重，只有都不一样才会去重,可以配合values使用
    # ret=models.Book.objects.all().values('name').distinct()
    # print(ret)

    #基于双下划线的模糊查询
    #__gt大于,__lt小于
    # ret=models.Book.objects.filter(price__lt=40)
    # res=models.Book.objects.filter(price__gt=40)
    # print(ret,res)
    #__gte大于等于，__lte小于等于
    # ret=models.Book.objects.filter(price__gte=85)
    # print(ret)
    # ret=models.Book.objects.filter(price__lte=50)
    # print(ret)
    #in 在某个选择范围中
    # ret=models.Book.objects.filter(price__in=[50,85,60])
    # print(ret)
    #range在某个区间中，是全闭区间（但是好像只有前后封闭的是整数才能取到）
    # ret=models.Book.objects.filter(price__range=[25,85])
    # print(ret)
    #contains内容包含某个字符
    # ret=models.Book.objects.filter(name__contains='p')
    # print(ret)
    #icontains忽略大小写
    # ret=models.Book.objects.filter(name__icontains='P')
    # print(ret)
    #startwith以...开头
    # ret=models.Book.objects.filter(name__startswith='p')
    # print(ret)
    #endswith以...结尾
    # ret=models.Book.objects.filter(name__endswith='on')
    # print(ret)
    #pub_date__year查询某年的对象
    # ret=models.Book.objects.filter(create_date__year=2015)
    # print(ret)

3.多表模型创建

OneToOneField要写to哪个表，to_filed=不写的话，默认是与id（一般是自增主键）相对应

ForeignKey要写to哪个表，to_filed=不写的话，默认是与id（一般是自增主键）相对应

创建唯一性约束时，要加上unique=True

sex_num=models.IntegerField(unique=True)

有时会创建联合唯一约束（这种情况多发生在两个字段分别关联外键），创建联合唯一约束有很多局限性，会降低查询性能。创建联合唯一约束的目的是为了不写脏数据

class UpAndDown(models.Model):
    nid = models.AutoField(primary_key=True)
    user = models.ForeignKey(to='UserInfo', to_field='nid')
    article = models.ForeignKey(to='Article', to_field='nid')
    is_up = models.BooleanField()

    class Meta:
        # 写这些,只是为了不写脏数据,联合唯一
        unique_together = (('user', 'article'),)

from django.db import models

# Create your models here.
'''
使用了OneToOneField和ForeignKey,模型表的字段，后面会自动加上_id
ManyToManyField会自动创建第三张表
*****重点
一对一关系：OneToOneField
一对多关系：ForeignKey
多对多关系：ManyToManyField

'''
class Publish(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=12)
    addr = models.CharField(max_length=64)
    email = models.EmailField(max_length=20)  # email,实际上是varchar
    def __str__(self):
        return self.name

class Author(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=12)
    sex = models.IntegerField()  # 整型
    # 可以用foreignkey，但是得设置唯一性约束，会报警告，不建议用
    authordetail = models.OneToOneField(to='Authordetail', to_field='id')
    def __str__(self):
        return self.name

class Authordetail(models.Model):
    id = models.AutoField(primary_key=True)
    phone = models.CharField(max_length=12)
    addr = models.CharField(max_length=64)
    def __str__(self):
        return self.id

class Book(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=12)
    price = models.DecimalField(max_digits=5,decimal_places=1)
    publish=models.ForeignKey(to='Publish',to_field='id')#to表示关联哪张表，to_field表示关联哪个字段
    authors=models.ManyToManyField(to='Author')#多对多会自动创建第三张表
    def __str__(self):
        return self.name

4.多表增删改查

update在pycharm没有tab提示

注意多表的add，remove，set的用法

add绑定多对多关系

book.authors.add(1,4)可接对象或数字

book.authors.remove(1,2)可接对象或数字

book.authors.clear()清空被关联对象集合

book.author.set((1,4))先清空后设置，只能接一个参数，可以传列表，元组。

import os
if __name__ == '__main__':
    os.environ.setdefault('DJANGO_SETTINGS_MODULE','day77.settings')
    import django
    django.setup()
    from app01.models import *
    #一对多新增数据
    # 方式1：
    #外键输入id时，可以输字符串，也可以输数字
    # ret=Book.objects.create(name='狼图腾',price=48.8,publish_id='2')
    # print(ret)
    # 方式2：存对象
    # publish=Publish.objects.filter(name='北京出版社').first()
    # ret=Book.objects.create(name='花仙子',price=55.8,publish=publish)
    # print(ret)
    #一对多修改数据
    # 方式1：
    # book=Book.objects.get(pk=1)
    # book.publish_id=3
    # book.save()
    # 方式2：#publish既可以传数字，也可以传对象,但是为了使用起来看起来方便，还是publish对对象，publish_id对数字
    # publish=Publish.objects.filter(id=3).first()
    # Book.objects.filter(id=1).update(publish=publish)
    #多对多关系
    #add添加
    #为西游记新增lqz作者
    # book=Book.objects.filter(name='西游记').first()
    # book.authors.add(1,2)#可以直接添加数字
    # author=Author.objects.filter(id=3).first()
    # book = Book.objects.filter(name='西游记').first()
    # book.authors.add(author)#也可以添加对象
    #remove删除
    # author = Author.objects.filter(id=3).first()
    # book = Book.objects.filter(name='西游记').first()
    # # book.authors.remove(1)#可以传数字
    # book.authors.remove(author)#可以传对象，不要数字和对象混着用
    #clear清除所有
    # book = Book.objects.filter(name='西游记').first()
    # book.authors.clear()
    #set先清空再添加
    # book = Book.objects.filter(name='西游记').first()
    # book.authors.set([1,3])#必须穿一个可迭代的数据，传列表就完事了。

    #基于对象的跨表查询
    #1.一对一
    #正向查询 author--关联字段在author--authordetail--按字段
    #反向     authordetail--关联字段在author--author--按表名小写
    #查询作者lqz的手机号
    #1)正向查
    # ret=Author.objects.filter(name='lqz').first().authordetail.phone
    # print(ret)
    # ret=Author.objects.filter(name='lqz').first().authordetail.phone
    # print(ret)
    #2)反向查 查询地址为上海的作者名字
    # authordetail=Authordetail.objects.filter(addr='上海').first()
    # author=authordetail.author
    # print(author.name)
    # res=Authordetail.objects.filter(author__name='lqz').first().phone
    # print(res)
    #2.一对多
    # 正向: 正向查询按字段
    #正向查询，查询西游记这本书的出版社邮箱
    # ret=Book.objects.filter(name='西游记').first().publish.email
    # print(ret)
    # 反向: 反向按表名小写_set.all()
    #反向查询，查询地址是北京的出版社出版的图书
    # ret=Book.objects.filter(publish__addr='北京')
    # print(ret)
    # publish=Publish.objects.filter(addr='北京').first()
    # books=publish.book_set.all()#一个出版社可以出版多个图书，是一个出版社对多个图书的关系，所以是publish.book_set.all()
    # print(books)
    #多对多
    # 正向: 正向查询按字段
    # 反向查询: 反向按表名小写_set.all()
    #  ** ** ** 基于对象的查询, 多次查询(子查询)
    #正向查询西游记这本书所有的作者
    # ret=Book.objects.filter(name='西游记').first().authors.all()
    # print(ret)
    #反向查询lqz写过的所有的书
    # lqz=Author.objects.filter(name='lqz').first()
    # books=lqz.book_set.all()
    # print(books)
    #查询西游记这本书所有作者的手机号，基于对象的查询，多次查询（子查询）
    # authors=Book.objects.filter(name='西游记').first().authors.all()
    # for author in authors:
    #     print(author.authordetail.phone)

    #基于双下划线的查询，连表查询
    #一对一
    #查询lqz作者的手机号
    #以author表作为基表    正向查询，跨表的话按字段
    # ret=Author.objects.filter(name='lqz').values('authordetail__phone')
    # print(ret)
    #以authordetail作为基表    反向查询，跨表的话，表名按小写
    # ret=Authordetail.objects.filter(author__name='lqz').values('phone')
    # print(ret)

5.基于双下划线的增删改查

#基于双下划线的跨表查询

import os
if __name__ == '__main__':
    os.environ.setdefault('DJANGO_SETTINGS_MODULE','day77.settings')
    import django
    django.setup()
    from app01.models import *
    #基于双下划线的一对多查询
    #查询出版社为北京出版社的所有图书的名字
    # ret=Publish.objects.filter(name='北京出版社').values('book__name','book__price')
    # print(ret)
    #查询北京出版社出版的价格大于19的书
    # ret=Publish.objects.filter(name='北京出版社',book__price__gt=19).values('book__name')
    # print(ret)

    #多对多
    #查询西游记的所有作者名字
    # ret=Book.objects.filter(name='西游记').values('authors__name')
    # print(ret)
    #查询图书价格大于30的所有作者的名字
    # ret=Book.objects.filter(price__gt=30).values('authors__name')
    # print(ret)
    #连续跨表
    #查询北京出版社出版过的所有书籍的名字以及作者名字
    # ret=Publish.objects.filter(name='北京出版社').values('book__name','book__authors__name')
    # print(ret)

只有查询到的结果是queryset对象时，才能打印queryset的query，也就是查询的sql语句

books = models.Book.objects.filter(authors__name='lqz')
    print(books.query)

6.聚合查询

使用聚合函数首先要导入相应模块

from django.db.models import Avg,Count,Max,Min,Sum

aggregate()是queryset的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。

简单记忆方法：聚合要父母agree，所以是aggregate函数

聚合查询查出的结果是字典

 from django.db.models import Avg, Count, Max, Min, Sum
    #聚合查询，在mysql数据库不用做上下比较，从头到尾取完数据可以直接进行统计的用aggregate
    #使用聚合函数，Avg,Count,Max,Min,Sum等跨表查询可能不会智能提示，
    #计算所有图书的平均价格
    # ret=Book.objects.all().aggregate(Avg('price'))
    # print(ret)
    #计算图书的最高价格和最低价格
    # ret=Book.objects.all().aggregate(Max('price'),Min('price'))
    # print(ret)

7.分组查询

简单记忆方法：分组，分成一个一个的，是an，所以是annotate函数

以什么为分组，就以什么为基表开始查。

查询出的结果是queryset对象，里面有一大堆的字典

#分组查询，其实就是要在mysql做那种上下进行比较的筛选，这时候用annotate，也就是分组
    #统计每一本书作者个数
    # ret=Book.objects.all().annotate(c=Count('authors'))#意思是把所有书的对象筛选出来，然后算有多少个作者
    # for r in ret:
    #     print(r.c)
    # ret=Book.objects.all().annotate(c=Count('authors')).values('name','c')#不循环，直接取值
    # print(ret)

    #统计每一个出版社的最便宜的书（以谁group by 就以谁为基表）
    # ret=Publish.objects.all().annotate(c=Min('book__price')).values('name','c')
    # print(ret)
    #统计每一本以py开头的书籍的作者个数
    # ret=Book.objects.filter(name__startswith='py').annotate(c=Count('authors')).values('c')
    # print(ret.query)
    #总结 group by 谁，就以谁做基表，filter过滤，annotate去分组，values取值
    #总结终极版本
        #values在前，表示group by，再后表示取值(其实默认查询都会写values在前一次，group by的是id。)
        #filter在前，表示过滤（where），在后，表示having(对分组之后的结果再进行过滤)
    #统计每一本以py开头的书籍的作者个数（和上面的sql语句一样）
    # ret=Book.objects.all().values('pk').filter(name__startswith='py').annotate(c=Count('authors')).values('name','c')
    # print(ret.query)
    #查询每个作者出的书的总价格
    # ret=Author.objects.all().values('id').annotate(c=Sum('book__price')).values('name','c')
    # print(ret)
    #查询写的书的总价格大于30的所有作者
    # ret=Author.objects.all().annotate(c=Sum('book__price')).filter(c__gt=30).values('name','c')
    # print(ret)

8.F函数

F函数一般用于同一个对象的不同字段，其数据进行对比时，比如一本书的评论数大于阅读数，这时就需要用到F函数进行包裹一下。

#F函数
    from  django.db.models import F
    #为了字段=后面的值，不能放字段，所以用F函数包裹一下就可以了
    #查询阅读数大于评论数的书
    # ret=Book.objects.filter(read_num__gt=F('meat_num'))
    # print(ret)
    #把所有书的评论数加1
    # Book.objects.all().update(read_num=F('read_num')+1)
    #把西游记这本书阅读数－5
    # Book.objects.filter(name='西游记').update(read_num=F('read_num')-5)

9.Q函数

 #Q函数    为了构造与&,或|,非~的关系
    from django.db.models import Q
    #查询作者名字是lqz或egon的书
    # book=Book.objects.filter(Q(authors__name='lqz')|Q(authors__name='egon')).distinct()
    # print(book)
    #查询作者不是lqz的书
    # ret=Book.objects.filter(~Q(authors__name='lqz'))
    # print(ret)

10.ORM字段参数

null　　　　　　可以为空

unique　　　　  唯一性约束

default　　　　  默认值

db_index　　　为该字段建索引

只给日期型和时间型用

　　auto_now_add　　新增数据时，默认把当前时间存入

　　auto_now　　　　修改的时候，默认把当前时间存入

　　related_name　　反向操作时，使用的字段名，用于代替原反向查询时的'表名_set'（一般情况下不用）

11.元信息

在models里建表时，可以在表里定义一个Meta类，里面封装了一些数据库的信息，主要字段如下：

db_table　　　　　　　　ORM在数据库中的表名默认是app_类名，可以通过db_table可以重写表名

index_together　　　　　联合索引

unique_together　　　　 联合唯一索引

ordering　　　　　　　　指定默认按什么字段排序

class Test(models.Model):
    name=models.CharField(max_length=12)
    class Meta:
        db_table='test'

12.choice

前面在建表时，在作者表，有一项是性别，1是男，2是女。在不数据库不怎么变动，这种映射关系不改变的情况下，可以使用choice

class Author(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    mychoice=((1,'男'),(2,'女'))
    sex = models.IntegerField(choices=mychoice)
    addr = models.CharField(max_length=64)
    authordetail = models.OneToOneField(to='AuthorDetail', to_field='id', null=True)
    def __str__(self):
        return self.name

这时候，当想要在取值时，直接打印出男女性别结果时，可以使用get_sex_display()的方法。注意，是查到的对象调用get_sex_display()方法，不是queryset调用get_sex_display()方法.

if __name__ == '__main__':
    os.environ.setdefault('DJANGO_SETTINGS_MODULE','ff12.settings')
    import django
    django.setup()
    from app01 import models
    author=models.Author.objects.filter(pk=3).first()
    author2=models.Author.objects.filter(pk=1).first()
    print(author.get_sex_display())
    print(author2.get_sex_display())

注意，当取的值，比如sex是3，没有相应男女关系映射时，这时候直接显示的是3。如果取的值有相应男女关系映射时，比如sex是1，则显示“男”。

当然，还有一种方法是做外键关联，另一张表写上“男”“女”。这样在取值时，可以去这张表进行查。只是在这里不太适合，在这里性别选项不会再多出变动，所以可以直接在数据库用choice选项。遇到其他情况，比如说VIP1-VIP10,金牌VIP,钻石VIP等等这种比较复杂的关系映射，甚至还有可能会进行变更的情况，这种情况下建议用外键关联而不是用choice。

13.only

需求：一个表有很多很多个字段，如果只要其中的一两个字段，name，我们只需要取出这一两个字段就可以了，效率会提升

import os
if __name__ == '__main__':
    os.environ.setdefault('DJANGO_SETTINGS_MODULE','ff12.settings')
    import django
    django.setup()
    from app01 import models
    ret=models.Book.objects.all().only('name')
    print(ret)
    print(ret[0])
    print(ret.first().price)

这么做的原因是为了优化sql查询，减轻mysql服务器的压力。

defer：除了指定之外的其他字段的所有值。同样查出来的也是存放在queryset中的对象

import os
if __name__ == '__main__':
    os.environ.setdefault('DJANGO_SETTINGS_MODULE','ff12.settings')
    import django
    django.setup()
    from app01 import models
    ret=models.Book.objects.all().defer('name')
    print(ret)
    print(ret[0].price)

14.手动创建第三张表

自动创建第三张表使用manytomany的方法的话，字段无法自己定制，甚至连插数据都找不到表。因此有了自己手动创建第三张表，根据业务需要进行自行定制相应字段等。

class Book(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    pub_date = models.DateTimeField()
    publish = models.ForeignKey(to='Publish', to_field='id')
    #to是和哪张表进行关联，through是手动创建的第三张表，through_fields是关联的字段，通过author向book字段进行关联（可以理解为author是自身上看不见的一个字段）
    author = models.ManyToManyField(to='Author',through='Book2Author',through_fields=('book','author'))
    def __str__(self):
        return self.name
class Book2Author(models.Model):
    id=models.AutoField(primary_key=True)
    book=models.ForeignKey(to='Book',to_field='id')
    author=models.ForeignKey(to='Author',to_field='id')
    test=models.CharField(max_length=32)
class Author(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    mychoice = ((1, '男'), (2, '女'))
    sex = models.IntegerField(choices=mychoice)
    addr = models.CharField(max_length=64)
    authordetail = models.OneToOneField(to='AuthorDetail', to_field='id', null=True)
    def __str__(self):
        return self.name

这时，再进行要帮书籍添加作者时，则需要调用第三张表

import os
if __name__ == '__main__':
    os.environ.setdefault('DJANGO_SETTINGS_MODULE','ff12.settings')
    import django
    django.setup()
    from app01 import models
    book=models.Book.objects.filter(pk=1).first()
    models.Book2Author.objects.create(test='haha',book_id=1,author_id=3)

15.建表可以选择DateField和DateTimeField

视业务需求而定

DateField可以选择用filter(pub_date='2018-12-12')这种形式去过滤

但是DateTimeField则不行，因为DateTimeField带了时分秒。

所以DateTimeField可以用filter(pub_date__day='28')

前端<input type='date'>传过来的时间带了时分秒？

16删除

级联删除：可以近似的把它理解成一个触发器，主表数据没了，外键关联部分也会跟着一起删除

publish = models.ForeignKey(to='Publish',to_field='nid',on_delete=models.CASCADE)

17.当models配置了choice选项时，显示其文字信息

# 固定用法:get_字段名字_display()
        user_type_name = request.user.get_user_type_display()