Django 中的aggregate() 与 annotate()

Question

Django 的QuerySet 有两个方法，annotate 和aggregate。文档说：

与aggregate()不同，annotate()不是终止子句。 annotate() 子句的输出是一个查询集。 https： //docs.djangoproject.com/en/4.1/topics/db/aggregation/#generate-aggregates-for-each-item-in-a-queryset

它们之间还有其他区别吗？如果不是，那为什么会有aggregate存在呢？

Answer 1

我会关注示例查询而不是文档中的引用。 Aggregate 计算整个查询集的值。 Annotate 计算查询集中每个项目的汇总值。

聚合

>>> Book.objects.aggregate(average_price=Avg('price'))
{'average_price': 34.35}

返回一个字典，其中包含查询集中所有图书的平均价格。

注释

>>> q = Book.objects.annotate(num_authors=Count('authors'))
>>> q[0].num_authors
2
>>> q[1].num_authors
1

q是书籍的查询集，但每本书都标注了作者数量。

Answer 2

聚合
聚合整个查询集的生成结果（摘要）值。
对行集进行聚合操作以从行集中获取单个值。（例如行集中所有价格的总和）。聚合应用于整个查询集，并在整个查询集中生成结果（摘要）值。

在模型中：

class Books(models.Model):
    name = models.CharField(max_length=100)
    pages = models.IntegerField()
    price = models.DecimalField(max_digits=5, decimal_places=3)

在 Shell 中：

>>> Books.objects.all().aggregate(Avg('price'))
# Above code will give the Average of the price Column 
>>> {'price__avg': 34.35}

注释
Annotate 为 QuerySet 中的每个对象生成独立的摘要。（我们可以说它迭代 QuerySet 中的每个对象并应用操作）

在模型中：

class Video(models.Model):
    name = models.CharField(max_length=52, verbose_name='Name')
    video = models.FileField(upload_to=document_path, verbose_name='Upload 
               video')
    created_by = models.ForeignKey(User, verbose_name='Created by', 
                       related_name="create_%(class)s")
    user_likes = models.ManyToManyField(UserProfile, null=True, 
                  blank=True, help_text='User can like once', 
                         verbose_name='Like by')

在视图中：

videos = Video.objects.values('id', 'name','video').annotate(Count('user_likes',distinct=True)

在视图中它将计算每个视频的点赞数

Answer 3

这是主要的区别，但聚合的工作范围也比注释更大。注释本质上与查询集中的各个项目相关。如果您在多对多字段之类的字段上运行 Count 注释，您将为查询集的每个成员获得单独的计数（作为添加的属性）。但是，如果您要对聚合执行相同的操作，它将尝试对查询集的每个成员（甚至重复项）上的每个关系进行计数，并将其仅作为一个值返回。

Answer 4

• 聚合() 可以计算当前模型列的所有值。 *返回字典。

• annotate() 可以计算通过外键访问子模型的列。 *返回一个QuerySet。

*Avg()，Count(), Max()，Min(), Sum() 等可以与 aggregate 一起使用() 和 annotate()。

例如，下面有 Category 和 Product 模型：

# "models.py"

from django.db import models

class Category(models.Model):
    name = models.CharField(max_length=20)

class Product(models.Model):
    category = models.ForeignKey(Category, on_delete=models.CASCADE)
    name = models.CharField(max_length=50)
    price = models.DecimalField(decimal_places=2, max_digits=5)

并且，下面有 Category 和 Product 管理员：

# "admin.py"

from django.contrib import admin
from .models import Category, Product 

@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
    list_display = ('id', 'name')
    ordering = ('id',)

@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
    list_display = ('id', 'category_id', 'category', 'name', 'price')
    ordering = ('id',)

并且，有以下 2 个类别：

并且，有以下 5 种产品：

并且，下面有 test 视图：

# "views.py"

from .models import Category, Product
from django.http import HttpResponse
from django.db.models import Avg
from django.db.models import Count
from django.db.models import Max
from django.db.models import Min
from django.db.models import Sum

def test(request):
    return HttpResponse("Test")

首先，我解释一下 聚合()。

aggregate()：

现在，我运行 test 视图，其中包含列 id、category 和 price 在 Avg() 中，Count(), Max(), Min() 和 Sum() in aggregate() 如下所示：

# "views.py"

# ...

def test(request):

    print(Product.objects.aggregate(Avg('id')))
    print(Product.objects.aggregate(Count('id')))
    print(Product.objects.aggregate(Max('id')))
    print(Product.objects.aggregate(Min('id')))
    print(Product.objects.aggregate(Sum('id')))
    print()
    print(Product.objects.aggregate(Avg('category')))
    print(Product.objects.aggregate(Count('category')))
    print(Product.objects.aggregate(Max('category')))
    print(Product.objects.aggregate(Min('category')))
    print(Product.objects.aggregate(Sum('category')))
    print()
    print(Product.objects.aggregate(Avg('price')))
    print(Product.objects.aggregate(Count('price')))
    print(Product.objects.aggregate(Max('price')))
    print(Product.objects.aggregate(Min('price')))
    print(Product.objects.aggregate(Sum('price')))
    
    return HttpResponse("Test")

然后，这些字典下面是在控制台上输出：

{'id__avg': 3.0}
{'id__count': 5}
{'id__max': 5}
{'id__min': 1}
{'id__sum': 15}

{'category__avg': 1.4}
{'category__count': 5}
{'category__max': 2}
{'category__min': 1}
{'category__sum': 7}

{'price__avg': Decimal('30.0000000000000000')}
{'price__count': 5}
{'price__max': Decimal('50.00')}
{'price__min': Decimal('10.00')}
{'price__sum': Decimal('150.00')}

并且，aggregate() 可以接受任意顺序的多种列和函数、多个相同类型的列和函数以及没有列和函数，如下所示。 *将多个相同类型的列和函数合并为一个，并且没有列和函数得到空字典：

# "views.py"

# ...

def test(request):
    # Multiple kinds of columns and functions in any order
    print(
        Product.objects.aggregate(
            Max('price'), Max('category'), Sum('id'), Min('id')
        )
    )

    # The multiple same kind of columns and functions
    print(
        Product.objects.aggregate(
            Sum('price'), Sum('price'), Sum('price')
        )
    )

    # No columns and functions
    print(Product.objects.aggregate())
        
    return HttpResponse("Test")

然后，在控制台上输出以下这些字典：

{'price__max': Decimal('50.00'), 'category__max': 2, 'id__sum': 15, 'id__min': 1}
{'price__sum': Decimal('150.00')}
{}

And、Max() 和 Min下面的 () 可以接受非数字类型：

# "views.py"

# ...

def test(request):

    print(Product.objects.aggregate(Count('name')))
    print(Product.objects.aggregate(Max('name')))
    print(Product.objects.aggregate(Min('name')))
        
    return HttpResponse("Test")

然后，下面这些字典将在控制台上输出：

{'name__count': 5}
{'name__max': 'Tea'}
{'name__min': 'Apple'}

But、Avg() 和 Sum() 以下不能接受非数字类型：

# "views.py"

# ...

def test(request):

    print(Product.objects.aggregate(Avg('name')))
    print(Product.objects.aggregate(Sum('name')))
        
    return HttpResponse("Test")

因此，会出现以下错误：

django.db.utils.ProgrammingError：函数 avg（字符变化）不存在

django.db.utils.ProgrammingError：函数 sum（字符变化）不存在

并且，您可以更改默认键名称，如下所示：

# "views.py"

# ...

def test(request):

    print(Product.objects.aggregate(priceAve=Avg('price')))
    print(Product.objects.aggregate(priceCount=Count('price')))
    print(Product.objects.aggregate(priceMax=Max('price')))
    print(Product.objects.aggregate(priceMin=Min('price')))
    print(Product.objects.aggregate(priceSum=Sum('price')))
        
    return HttpResponse("Test")

然后，默认键名称更改如下：

{'priceAve': Decimal('30.0000000000000000')}
{'priceCount': 5}
{'priceMax': Decimal('50.00')}
{'priceMin': Decimal('10.00')}
{'priceSum': Decimal('150.00')}

接下来，我解释一下 注释（）。

annotate()：

现在，我运行 test 视图，其中包含列 product__id、product__category 和 product__price 在 Avg()、Count()、Max()、Min() 和 <代码>Sum() 中annotate() 如下所示。 *您需要将 __avg、__count、__max、__min 和 __sum 放入product__id、product__category 和 product__price 用于 Avg()、Count()、<代码>最大(),分别是 Min() 和 Sum()：

# "views.py"

# ...

def test(request):

    qs = Category.objects.annotate(
        Avg('product__id'), 
        Count('product__id'), 
        Max('product__id'), 
        Min('product__id'), 
        Sum('product__id')
    ).order_by('pk')

    for obj in qs:
        print(
            obj.id, 
            obj.name, 
            obj.product__id__avg, 
            obj.product__id__count, 
            obj.product__id__max, 
            obj.product__id__min, 
            obj.product__id__sum
        )

    print()

    qs = Category.objects.annotate(
        Avg('product__category'), 
        Count('product__category'), 
        Max('product__category'), 
        Min('product__category'), 
        Sum('product__category')
    ).order_by('pk')

    for obj in qs:
        print(
            obj.id, 
            obj.name, 
            obj.product__category__avg, 
            obj.product__category__count, 
            obj.product__category__max, 
            obj.product__category__min, 
            obj.product__category__sum
        )

    print()

    qs = Category.objects.annotate(
        Avg('product__price'), 
        Count('product__price'), 
        Max('product__price'), 
        Min('product__price'), 
        Sum('product__price')
    ).order_by('pk')

    for obj in qs:
        print(
            obj.id, 
            obj.name, 
            obj.product__price__avg, 
            obj.product__price__count, 
            obj.product__price__max, 
            obj.product__price__min, 
            obj.product__price__sum
        )
    
    return HttpResponse("Test")

然后，在控制台上输出以下内容：

1 Food 2.0 3 3 1 6
2 Drink 4.5 2 5 4 9

1 Food 1.0 3 1 1 3
2 Drink 2.0 2 2 2 4

1 Food 20.0000000000000000 3 30.00 10.00 60.00
2 Drink 45.0000000000000000 2 50.00 40.00 90.00

并且，不带 order_by('pk') 下面使订单后代：

# "views.py"

# ...

def test(request):

    qs = Category.objects.annotate(
        Avg('product__price'), 
        Count('product__price'), 
        Max('product__price'), 
        Min('product__price'), 
        Sum('product__price')
    ) # Without ".order_by('pk')"

    for obj in qs:
        print(
            obj.id, 
            obj.name, 
            obj.product__price__avg, 
            obj.product__price__count, 
            obj.product__price__max, 
            obj.product__price__min, 
            obj.product__price__sum
        )
    
    return HttpResponse("Test")

然后，顺序是后代如下所示：

2 Drink 4.5 2 5 4 9
1 Food 2.0 3 3 1 6

并且，下面的空annotate()有id和name属性：

# "views.py"

# ...

def test(request): 
                         # Empty "annotate()"
    qs = Category.objects.annotate().order_by('pk')

    for obj in qs:
        print(obj.id, obj.name)
        
    return HttpResponse("Test")

然后，下面这些控制台输出：

1 Food
2 Drink

但是，下面的空annotate()没有__avg、__count、__max, __min和 __sum 属性如下所示：

# "views.py"

# ...

def test(request): 
                         # Empty "annotate()"
    qs = Category.objects.annotate().order_by('pk')
    
    for obj in qs:
        print(
            obj.product__price__avg,
            obj.product__price__count,
            obj.product__price__max,
            obj.product__price__min,
            obj.product__price__sum,
        )
        
    return HttpResponse("Test")

因此，出现以下错误：

属性错误：“类别”对象没有属性“product__price__avg”

属性错误：“类别”对象没有属性“product__price__count”

属性错误：“类别”对象没有属性“product__price__max”

属性错误：“类别”对象没有属性“product__price__min”

属性错误：“类别”对象没有属性“product__price__sum”

并且下面的 Max() 和 Min() 可以接受非数字类型：

# "views.py"

# ...

def test(request):

    qs = Category.objects.annotate(
        Count('product__name'), 
        Max('product__name'), 
        Min('product__name'), 
    ).order_by('pk')

    for obj in qs:
        print( 
            obj.product__name__count, 
            obj.product__name__max, 
            obj.product__name__min, 
        )

    return HttpResponse("Test")

然后，在控制台上输出以下内容：

3 Orange Apple
2 Tea Milk

但是，下面的 Avg() 和 Sum() 不能接受非数字类型：

# "views.py"

# ...

def test(request):

    qs = Category.objects.annotate(
        Avg('product__name'),
        Sum('product__name')
    ).order_by('pk')

    for obj in qs:
        print( 
            obj.product__name__avg, 
            obj.product__name__sum
        )
        
    return HttpResponse("Test")

因此，出现以下错误：

django.db.utils.ProgrammingError：函数 avg（字符变化）不存在

django.db.utils.ProgrammingError：函数 sum（字符变化）不存在

并且，您可以更改默认属性名称，如下所示：

# "views.py"

# ...

def test(request):

    qs = Category.objects.annotate(
        productPriceAvg=Avg('product__price'), 
        productPriceCount=Count('product__price'), 
        productPriceMax=Max('product__price'), 
        productPriceMin=Min('product__price'), 
        productPriceSum=Sum('product__price')
    ).order_by('pk')

    for obj in qs:
        print(
            obj.id, 
            obj.name, 
            obj.productPriceAvg, 
            obj.productPriceCount, 
            obj.productPriceMax, 
            obj.productPriceMin, 
            obj.productPriceSum
        )
    
    return HttpResponse("Test")

然后，以下内容将在控制台上输出：

1 Food 20.0000000000000000 3 30.00 10.00 60.00
2 Drink 45.0000000000000000 2 50.00 40.00 90.00