聚合函数与F/Q表达式

聚合函数 取名： field + __ + 聚合函数名字 ，如：price__avg；可传关键字参数修改名字：avg=Avg("price")；

aggregate：不会返回一个 QuerySet 对象，而是返回一个字典，key为聚合函数的名字，value为聚合函数执行结果；

annotate：返回一个 QuerySet 对象；

相同点：

1. 都可执行聚合函数；可在任何的‘QuerySet’对象上调用，因此只要返回了‘QuerySet’对象，即可进行链式调用，如 index5 中获取年度销售总额，可先过滤年份再求聚合函数；

不同点：

1.  aggregate 返回一个字典，字典中存储聚合函数执行的结果；而 annotate 返回一个 QuerySet对象 ，并在查找的模型上添加一个聚合函数的属性；
2.  aggregate 不会做分组，而 annotate 会使用 Group by 字句进行分组，只有调用该字句才能对每一条数据求聚合函数的值；

• 数据库中的内容：

• models.py文件：

  from django.db import models
  
  class Author(models.Model):
      '''作者模型'''
      name = models.CharField(max_length=100)
      age = models.IntegerField()
      email = models.EmailField()
  
      class Meta:
          db_table = 'author'
  
  class Publisher(models.Model):
      '''出版社模型'''
      name = models.CharField(max_length=300)
  
      class Meta:
          db_table = 'publisher'
  
  class Book(models.Model):
      '''图书模型'''
      name = models.CharField(max_length=300)
      pages = models.IntegerField()
      price = models.FloatField()
      rating = models.FloatField()
      author = models.ForeignKey(Author,on_delete=models.CASCADE)
      publisher = models.ForeignKey(Publisher,on_delete=models.CASCADE)
  
      class Meta:
          db_table = 'book'
  
  class Bookorder(models.Model):
      '''图示订单模型'''
      book = models.ForeignKey('Book',on_delete=models.CASCADE)
      price = models.FloatField()
      create_time = models.DateTimeField(auto_now_add=True,null=True)
  
      class Meta:
          db_table = 'book_order'

• views.py文件：

  from django.shortcuts import render
  from django.http import HttpResponse
  from .models import Author,Publisher,Book,Bookorder
  from django.db.models import Avg,Count,Max,Min,Sum
  from django.db import connection
  
  def index(request):
      # 获取所有图书定价的平均价（使用aggregate）；Avg：平均值；
      result = Book.objects.aggregate(Avg('price'))
      print(result)
      print(connection.queries)
      return HttpResponse('index')
      # >>>{'price__avg': 97.25}
      # >>>{'price__avg': 97.25}
      # {'sql': 'SELECT AVG(`book`.`price`) AS `price__avg` FROM `book`'；
  
  def index2(requset):
      # 获取每一本销售的平均价格（使用annotate）；
      books = Book.objects.annotate(avg=Avg('bookorder__price'))
      for book in books:
          print("%s:%s" % (book.name,book.avg))
      print(connection.queries)
      return HttpResponse('index2')
      #三国演义:89.33333333333333
      # 水浒传:93.5
      # 西游记:None
      # 红楼梦:None
      # `book_order` ON (`book`.`id` = `book_order`.`book_id`) GROUP BY `book`.`id` ORDER BY NULL'；
  
  def index3(request):
      # book 表中总共有多少本书；
      # Count：求某个数据的的个数；
      result = Book.objects.aggregate(nums=Count('id'))
      # author 表中总共有多少个不同的邮箱；
      # 使用‘distinct=True’剔除重复的值；
      results = Author.objects.aggregate(book_num=Count('email',distinct=True))
      
      # 统计每本书的销量
      books = Book.objects.annotate(book_nums=Count('bookorder'))
      for book in books:
          print("%s:%s" % (book.name,book.book_nums))
      print(books)
      print(connection.queries)
      return HttpResponse("index3")
      # 三国演义:3
      # 水浒传:2
      # 西游记:0
      # 红楼梦:0
  
  
  def index4(request):
      result = Author.objects.aggregate(max=Max('age'),min=Min('age'))
      # 每本图书售卖前的最大及最小价格；
      books = Book.objects.annotate(max=Max("bookorder__price"),min=Min("bookorder__price"))
      for book in books:
          print("%s:%s:%s" % (book.name,book.max,book.min))
      print(connection.queries)
      return HttpResponse("index4")
  
      # 三国演义:95.0:85.0
      # 水浒传:94.0:93.0
      # 西游记:None:None
      # 红楼梦:None:None
  
  
  def index5(request):
      # 求所有图书的销售总额；
      result = Book.objects.aggregate(total=Sum("price"))
      print(result)
      print(connection.queries)
      # {'total': 389.0}
      # {'sql': 'SELECT SUM(`book`.`price`) AS `total` FROM `book`', 'time': '0.001'}；
  
      # 求每一本图书的销售总额；
      books = Book.objects.annotate(total=Sum('bookorder__price'))
      for book in books:
          print("%s:%s" % (book.name,book.total))
      print(connection.queries)
      # 三国演义: 268.0
      # 水浒传: 187.0
      # 西游记: None
      # 红楼梦: None
      
  
      # 求2018年度的销售总额；
      result = Bookorder.objects.filter(create_time__year=2019).aggregate(total=Sum("price"))
      # 求2018年度每一本图书的销售总额；
      books = Book.objects.filter(bookorder__create_time__year=2019).annotate(total=Sum("bookorder__price"))
      for book in books:
          print("%s:%s" % (book.name,book.total)  )
      print(connection.queries)
      # 三国演义: 268.0
      # 水浒传: 187.0
      # `book_order`.`create_time` BETWEEN '2019-01-01 00:00:00' AND '2019-12-31 23:59:59.999999' GROUP BY `book`.`id`

• F表达式：动态获取某个字段上的值，不会真正到数据库中查询数据，只起一个标识的作用；

  def index6(requset):
      # 给每本书售价增加10元；update;
      Book.objects.update(price=F('price')+10)
      print(connection.queries[-1])
      # 'UPDATE `book` SET `price` = (`book`.`price` + 10)';
  
      # Author中name与email相同的内容；
      authors = Author.objects.filter(name=F('emile'))
      for author in authors:
          print("%s:%s" % (author.name,author.email))
      return HttpResponse('index6')

• Q表达式：包裹查询条件，可在条件间进行多种操作：与 & 、或 | 、非 ~  等查询操作；

  def index7(requset):
      # 1、获取价格大于100，评分大于4.5的图书；
      # books = Book.objects.filter(price__gte=100,rating=4.5)
      books = Book.objects.filter(Q(price__gte=100)&Q(rating__gte=4.5))
      for book in books:
          print("%s:%s:%s" % (book.name,book.price,book.rating))
          
      ---
  
      # 2、获取价格低于100，或者评分低于4.5分的图书；
      books = Book.objects.filter(Q(price__lt=100)|Q(rating__lt=4.5))
      for book in books:
          print("%s:%s:%s" % (book.name,book.price,book.rating))
         
      ---
   
      # 3、获取价格大于100，并且图书名字不包含“传”字的图书；
      books = Book.objects.filter(Q(price__gte=100)&~Q(name__icontains='传'))
      for book in books:
          print("%s:%s:%s" % (book.name,book.price,book.rating))
      return HttpResponse('index7')