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()

ORM表操作的更多相关文章

  1. Django之ORM表操作

    ORM表操作 1.ORM单表操作 首先想操作表的增删改查,需要先导入这个表,以之前创建的UserInfo表为例,在app下的views.py中导入 from app import models def ...

  2. 1127 模型层orm表操作

    目录 昨日回顾 模型层 1.配置测试脚本 1.1 应用下tests文件 1.2 新建任意名称文件 2. 数据的增删改查 2.1 创建数据 2.2 修改数据 2.3 删除数据 2.4查询数据 十三门徒 ...

  3. python——Django(ORM连表操作)

    千呼万唤始出来~~~当当当,终于系统讲了django的ORM操作啦!!!这里记录的是django操作数据库表一对多.多对多的表创建及操作.对于操作,我们只记录连表相关的内容,介绍增加数据和查找数据,因 ...

  4. Django ORM多表操作

    多表操作 创建模型 实例:我们来假定下面这些概念,字段和关系 作者模型:一个作者有姓名和年龄. 作者详细模型:把作者的详情放到详情表,包含生日,手机号,家庭住址等信息.作者详情模型和作者模型之间是一对 ...

  5. web框架开发-Django模型层(1)之ORM简介和单表操作

    ORM简介 不需要使用pymysql的硬编码方式,在py文件中写sql语句,提供更简便,更上层的接口,数据迁移方便(有转换的引擎,方便迁移到不同的数据库平台)…(很多优点),缺点,因为多了转换环节,效 ...

  6. ORM 多表操作查询及增删改查

    ------------------------------------------只有对前途乐观的人,才能不怕黑暗,才能有力量去创造光明.乐观不是目的,而是人生旅途中的一种态度. 多表操作 创建模型 ...

  7. Django学习手册 - ORM 数据创建/表操作 汇总

    ORM 查询的数据类型: QuerySet与惰性机制(可以看作是一个列表) 所谓惰性机制:表名.objects.all()或者.filter()等都只是返回了一个QuerySet(查询结果集对象),它 ...

  8. ORM 简介 单表操作

    cls超 Django基础五之django模型层(一)单表操作 本节目录 一 ORM简介 二 单表操作 三xxx 一 ORM简介 MVC或者MVC框架中包括一个重要的部分,就是ORM,它实现了数据模型 ...

  9. django创建ORM模型、通过ORM模型操作单个表、ORM模型常用字段

    一.ORM简介 ORM ,全称Object Relational Mapping,中文叫做对象关系映射,通过ORM我们可以通过类的方式去操作数据库,而不用再写原生的SQL语句.通过把表映射成类,把行作 ...

随机推荐

  1. JAVA集合类汇总

    一.集合与数组 数组(可以存储基本数据类型)是用来存现对象的一种容器,但是数组的长度固定,不适合在对象数量未知的情况下使用. 集合(只能存储对象,对象类型可以不一样)的长度可变,可在多数情况下使用. ...

  2. MongoDB之bson的介绍

    MongoDB之bson的介绍 1. 什么是bson BSON是一种类json的一种二进制形式的存储格式,简称Binary JSON,它和JSON一样,支持内嵌的文档对象和数组对象,但是BSON有JS ...

  3. java CyclicBarrier

    import java.io.IOException; import java.util.Random; import java.util.concurrent.BrokenBarrierExcept ...

  4. Mercurial使用简单介绍【转】

    Mercurial可以使异地开发进行统一的版本管理,比如一个项目有一部分人在银行内部开发无法用外网,另一部分人在公司开发,这两部分人需要一个统一的版本管理工具,mercurial这时候可以发挥作用 m ...

  5. Windows2003/2008/2008 R2下易语言点支持库配置就退出的问题

    问题: 请问一个问题,我的电脑上win2003系统的,安装了易语言后,一点支持库配置就会自动退出.这是为什么啊? 解决方法如下: 删除 lib下的wmp.npk,重新打开易语言就可以了.

  6. linux学习心得之目录树开端与/etc(图文)

    linux学习心得之目录树开端与/etc(图文) linux中“一切皆文件”,学习linux一年了,在学习过程中对目录树的一点心得,分享给大家,有不对的地方敬请斧正. 不多说了,先上图: 根目录: / ...

  7. Linux SSH下安装Java并设置环境

    我是用Xshell进行远程连接阿里云服务器的,所以jdk不好下载. 我使用的是Winscp远程软件,在window上下载了jdk然后再上传到Linux服务器上 下面是安装的步骤 1.下载jdk8 登录 ...

  8. Git 常用命令整理(转)

    初始化配置 #配置使用git仓库的人员姓名 git config --global user.name "Your Name Comes Here" #配置使用git仓库的人员em ...

  9. docker-compose.yml(2)

    实例2:version: '3'services: user-service: image: "$DOCKER_SERVICE_IMAGE_TAG" network_mode: & ...

  10. openstack 部署笔记--nova

    控制节点 配置用户与服务 $ . admin-openrc $ openstack user create --domain default --password-prompt nova $ open ...