Django学习三有关表的创建查询类

创建表

首先要清楚他们之间的映射关系

 表明<---------------->类名

 字段<---------------->属性

 表记录<---------------->类实例对象

在models中创建表

from django.db import models

# Create your models here.
class Book(models.Model):
    # AutoField 自增的数据类型
    nid = models.AutoField(primary_key=True)
    title = models.CharField(max_length=32)
    publishDate = models.DateField()
    price = models.DecimalField(max_digits=5, decimal_places=2)
    # 这一句话是一共5位数，整数位3位，小数位2位

    # 整个表都构建好了并且都插入数据后往里面添加字段的时候就用这种方法
    wordNum=models.IntegerField(default=0)
    # publish构建的外键
    publish = models.ForeignKey("Publish",related_name="bookList")  #一对多
    authorlist=models.ManyToManyField("Author",related_name="bookauthor")   #多对多  会自动创建book与author的第三张表
              # models.OneToOneField()   #一对一

    # 这一句话是一共5位数，整数位3位，小数位2位
    # def __str__(self):
    #     return self.title

class Publish(models.Model):
        name = models.CharField(max_length=32)
        addr = models.CharField(max_length=32)

        def __str__(self):
            return self.name

class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()

    def __str__(self):
        return self.name

class AuthorDetail(models.Model):
    tel = models.IntegerField()
    addr = models.CharField(max_length=32)  # 一对一
    author = models.OneToOneField("Author")

建好表之后再对字段进行增删查

关联表记录的操作

表关系：
   1.一对多
   2.多对多
   3.一对一


   这里牵扯到的是book  author  publish，首先理清楚这几个的关系
    书和出版社一对多  书和作者 多对多  


添加纪录
     创建一对多
    publish=models.ForeignKey("Publish",related_name="bookList")


   一对多添加：区别在于
   第一种是自己赋值
   第二种是先拿到对象再对对象进行赋值

    添加一对多方式一：
    models.Book.objects.create(title="平凡的世界",price=56,publishDate="2017-10-11",publish_id=1)


     添加一对多方式二：
     首先拿到出版社名称，再进行添加
      pubObj=models.Publish.objects.filter(name="人民出版社")[0]
      models.Book.objects.create(title="平凡的世界",price=56,publishDate="2017-10-11",publish=pubObj)

     多对多添加：
     涉及到ManyToManyFiled

   创建多对多：
    authorlist=models.ManyToManyFiled("Author",related_name="booklist")

    多对多添加

    首先添加一本书，再给这本书添加两个作者
    book_obj=models.Book.objects.craete(title="平凡的世界",price=56,publishDate="2017-10-11",publish_id=1)
    其次将两个作者对象
    alex_obj=models.Author.objects.filter(name="alex")[0]
    egon_obj=models.Author.objects.filter(name="egon")[0]

    将作者对象添加到书籍
    print(book_obj.authorlist.add(alex_obj.egon_obj))
     

查询记录

  正向查询
     一对多
      查询一本书的出版社的名字
     book_obj=models.Book.objects.filter(title="简爱")[0]
     print(book_obj.publish.name)
  
     
     多对多
      查询一本书的所有作者
   
       book_obj=models.Book.objects.filter(title="简爱")[0]
       print(book_obj.authorlist.all())
     

  反向查询
    一对多

    查询人民出版社出版的书的名字

    pubObj=models.Publish.objects..fiflter(name="人民出版社").[0]
    print(pubObj.bookList.all())

 

    多对多

    yuan写的所有书的名字和价格

     aut_boj=models.Author.objects.get(name="yuan")
     print(aut_obj.book_set.all().values("title","price"))



解除
    modelsbook_obj=models.Book.objects.filter(title="红楼梦").first()
    authorList=models.Author.objects.filter(id__lt=3)
    print(book_obj.authorlist.remove(*authorList))

清除
    book_obj = models.Book.objects.filter(title="红楼梦").first()
    book_obj.authorlist.clear()

一对一的正向查询和反向查询


正向查询
   查询手机号为123456的作者的姓名

    aut_obj=models.AuthorDetail.objects.filter(tel="123456").first()
    print(aut_obj.author.name)

反向查询

   ut_obj=models.Author.objects.filter(name="yuan").first()
    # 也可以用related_name="abc"
    print(aut_obj.authordetail.tel)

查询表记录

1. all()      查询所有结果,拿到queryset集合对象
    book_all=models.Book.objects.all()
    print(book_all)  #[<Book: 简爱>, <Book: python>, <Book: 从你的全世界路过>, <Book: 哈哈>]>

     2. filter()       包含了所给筛选项相匹配的对象
    book_auth=models.Book.objects.filter(auth="兰博")
    print(book_auth)  #<QuerySet [<Book: 从你的全世界路过>, <Book: 街角咖啡>]>

     3.get()  包含和给出筛选项相匹配的对象，有且只有一个，多了或者超过就会报错
    book_price=models.Book.objects.get(price=48)
    print(book_price)  #简爱

    book_price=models.Book.objects.get(price=23)
    print(book_price)    # 直接报错，报错代码为： get() returned more than one Book -- it returned 2!


     4.exclude()   包含与所给筛选项不匹配的对象
    boo      k_auth=models.Book.objects.exclude(auth="兰博")
    print(book_auth)  #<QuerySet [<Book: 简爱>, <Book: python>, <Book: 哈哈>]>


    5.values() 返回一个valueQueryset---一个特殊的Queryset，运行后得到的不是一系列的model实例化对象，而是
    可迭代的字典序列
    book_price=models.Book.objects.filter(auth="yuan").values("title","price")
    print(book_price)  #<QuerySet [{'title': 'python', 'price': Decimal('22.00')}]>
    记住这个里面返回的是一个可迭代的字典


    6.order_by()  对查询结果排序

    book_price=models.Book.objects.all().order_by("price")
    print(book_price)
    <QuerySet [<Book: python>, <Book: 从你的全世界路过>, <Book: 哈哈>, <Book: 简爱>, <Book: 街角咖啡>]>
    按价格从低到高排序


    7. reverse() 对查询结果反向排序
    book_price=models.Book.objects.all().order_by("price").reverse()
    print(book_price)
    < QuerySet[ < Book: 街角咖啡 >, < Book: 简爱 >, < Book: 从你的全世界路过 >, < Book: 哈哈 >, < Book: python >] >


    8.distinct() 从返回结果中剔除重复记录
    book_price = models.Book.objects.filter(price=23).values("title","auth")
    print(book_price)
    < QuerySet[{'title': '从你的全世界路过', 'auth': '兰博'}, {'title': '哈哈', 'auth': '啊哈哈'}, {'title': '街角咖啡', 'auth': '兰 博'}, {'title': '街角咖啡', 'auth': ' 兰博'}]>


  为了能体现去重上下两个做比较得出

    book_price = models.Book.objects.filter(price=23).values("title", "auth").distinct()
    print(book_price)
    QuerySet[{'title': '从你的全世界路过', 'auth': '兰博'}, {'title': '哈哈', 'auth': '啊哈哈'}, {'title': '街角咖啡', 'auth': '兰 博'}]>

   9.value_list()和values非常相似，只不过values返回字典而这个返回元祖
    book_price=models.Book.objects.filter(auth="yuan").values("title","price")
    print(book_price)  #<QuerySet [{'title': 'python', 'price': Decimal('22.00')}]>

    book_price=models.Book.objects.filter(auth="yuan").values_list("title","price")
    print(book_price) <QuerySet [('python', Decimal('22.00'))]>

    10.count()  返回数据库中匹配查询Queryset的对象数量
    book_auth=models.Book.objects.filter(auth="兰博").count()
    print(book_auth)    # 3

    11.first() 返回第一条记录
    ret=models.Book.objects.all().first()
    print(ret)     #简爱

    12.last()  返回最后一条记录
    ret=models.Book.objects.all().last()
    print(ret)   #街角咖啡


    13.exists()   如果Queryset包含数据就返回True，否则就返回false
     ret=models.Book.objects.filter(auth="兰博").exists()
     print(ret)      #True

    ret=models.Book.objects.filter(auth="aaa").exists()
    print(ret)    #False

    return HttpResponse("OK")


==============================================================================

 双下划线之单表查询
     __lt    小于
     __gt    大于
     __lte   小于等于
     __gte   大于等于
     __in    等于

    ret=models.Book.objects.filter(nid__lt=5,nid__gt=1)
    print(ret)    #<QuerySet [<Book: 简爱>

    ret=models.Book.objects.filter(nid__in=[3,7,9])
    print(ret)  #<QuerySet [<Book: 简爱>, <Book: 从你的全世界路过>, <Book: 街角咖啡>]>


    ret=models.Book.objects.exclude(nid__in=[3,7,9])   #not  in

    print(ret)
    < QuerySet[ < Book: 哈哈 >, < Book: 街角咖啡 >] >

    ret=models.Book.objects.filter(publishDate__year=2017,publishDate__month=10)
    < QuerySet[ < Book: 简爱 >, < Book: 从你的全世界路过 >, < Book: 哈哈 >, < Book: 街角咖啡 >, < Book: 街角咖啡 >] >

    ret=models.Book.objects.filter(auth__startswith="兰")
    < QuerySet[ < Book: 从你的全世界路过 >, < Book: 街角咖啡 >, < Book: 街角咖啡 >] >
    print(ret)

   return HttpResponse("OK")

双下划线的跨表查询

============双下划线的跨表查询===============

一对多

1.查询简爱这本书的出版地址
 方法一：  正向  按字段
  ret=models.Book.objects.filter(title="简爱").values("publish__addr")
  print(ret)
方法二：
  ret=models.Publish.objects.filter(bookList__title="简爱").values("addr")
  print(ret)
 方法三
  book_obj=models.Book.objects.filter(title="简爱")[0]
  print(book_obj.publish.addr)


2.查询人民出版社出过的书籍价格和名字
方法一：按表名
  ret=models.Publish.objects.filter(name="人民出版社").values("bookList__title","bookList__price")
  print(ret)
  return HttpResponse("ok")
方法二：
  ret=models.Book.objects.filter(publish__name="人民出版社").values("title","price")
  print(ret)
方法三：
  pubObj=models.Publish.objects.filter(name="人民出版社")[0]
  print(pubObj.bookList.all().values("price","title"))
  return HttpResponse("OK")

多对多
1.查询egon出过的所有书籍的名字
方法一
 ret=models.Author.objects.filter(name="egon").values("bookauthor__title")
 print(ret)
方法二
 ret=models.Book.objects.filter(authorlist__name="egon").values("title")
 print(ret)
2.查询egon出版过的所有书籍名称以及出版社名称
3.手机号以123开头的作者出版过的所有书籍名称以及出版社名称
 方法一
ob=models.AuthorDetail.objects.filter(tel__startswith="123").first()
print(ob.author.bookauthor.all().values("title","publish__name"))
方法二
ret=models.Book.objects.filter(authorlist__authordetail__tel__startswith="123").values("title","publish__name")
print(ret)
 return HttpResponse("ok")

聚合函数

=================聚合函数=======================
from  django.db.models import Avg, Sum, Count, Max, Min
聚合函数：aggregate
查询所有图书的价格和平均价格

ret = models.Book.objects.all().aggregate(priceSum=Sum("price"), priceAvg=Avg("price"))
print(ret)

return HttpResponse("ok")

分组函数annote函数
查询每一本书的作者个数
def query(request):
    book_list = models.Book.objects.all().annotate(c=Count("authorlist__name"))
    for book_obj in book_list:
        print(book_obj.c)

        # 查询每一个出版社出版过的最便宜的书籍
    ret = models.Book.objects.all().annotate(Min("price"))
    print(ret)

    return HttpResponse("ok")