标签: aggregate

我有一张包含以下列的表：ClientID、OrderID、ProductID、Quantity，每个 ProductID 在每个 OrderID 中仅出现一次，并且每个 OrderID 仅对应一个 ClientID。

样本数据：

ClientID  OrderID  ProductID  Quantity
1         100      25         10
1         100      30         20
1         101      27         10
1         101      30         10
1         102      27         30
2         103      27         10
2         104      15         10

我需要执行以下操作：在按 ClientID 和 ProductID 分组时，我需要对其他列应用聚合函数，以便结果集包含每个 ClientID 的最低 OrderID 以及每个 ClientID 的每个 ProductID 的数量列的总和。结果集的行数等于每个 ClientID 的不同 ProductID 的数量，并且每行的 OrderID = 每个 ClientID 的最低 OrderID，无论 ProductID 是多少。

期望的结果：

ClientID  OrderID  ProductID  Quantity
1         100      25         10
1         100      30         30
1 …

我阅读了 Elasticsearch 文档，了解 Elasticsearch 的 API 和查询 DSL。我还可以找到有关如何从 Elasticsearch 获取查询结果的文档，但如何在内部对任何查询有效计算聚合呢？

我有一些 4 列（c1、c2、c3 和 c4）的数据，并通过一些 scala 代码将其放入 RDD 中。

我想按 c1 进行分组/分组，并找到每个 c1 组中 c2 的平均值和 c3 以及 c4 的平均值。

我正在查看 RDD:reduceByKey，但我还没有设法准确理解它的使用方式。有一个更好的方法吗？我如何通过 Scala API 执行此操作？

假设我有以下 R data.table（尽管我也很高兴使用基础 R、data.frame）

library(data.table)

dt = data.table(Category=c("First","First","First","Second","Third", "Third", "Second"), Frequency=c(10,15,5,2,14,20,3), times = c(0, 0, 0, 3, 3, 1))

> dt
   Category Frequency times
1:    First        10     0
2:    First        15     0
3:    First         5     0
4:   Second         2     3
5:    Third        14     3
6:    Third        20     1
7:   Second         3     0

如果我想按类别汇总频率，我将使用以下内容：

data[, sum(Frequency), by = Category]

但是，假设我想求和Frequency当Category且仅当times非零且不等于NA？

如何根据单独列的值使该总和成为条件？

编辑：对这个明显的问题表示歉意。快速补充：如果某一列的元素是字符串怎么办？

例如

> dt
   Category Frequency times
1:    First        ten    0 …

我的聚合是这样的。

这些是结果..

我想得到最低的结果。

如何汇总这个结果？

我刚刚过滤了一些数据，现在我有一个 .csv 文件，但我注意到我只需要选择具有最低价格的行：

例子：

ORIGIN   | DESTINA. | PRICE
____________________________
BOG      | MAD      |  1500
BOG      | MAD      |  750
BOG      | MAD      |  1250
BOG      | MAD      |  1350
BOG      | MIA      |   450

所以在这个例子中，我想得到的只是第三行和第六行：

ORIGIN   | DESTINA. | PRICE
____________________________
BOG      | MAD      | 750
BOG      | MIA      | 450

使用 python，我怎样才能得到这个决赛桌？

多少个聚合应该有一个有界上下文？

我之所以问这个问题，是因为书籍和其他资源中的信息过于广泛/抽象。

我想，这取决于某些域模型及其结构。有多少个有界上下文有一个域模型？每个有界上下文中有多少实体。我想，所有这些问题都依赖于这个事实，即在单个有界上下文中应该有多少聚合。

此外，如果回忆一下 SOLID 原则和拥有松散耦合的小代码段的共同想法。我想，每个有界上下文最多可以有 3-4 个聚合。如果单个有界上下文中有更多聚合，则软件设计可能存在一些问题。

我现在正在阅读 Vernon 的关于 DDD 的书，但是很难理解如何设计这些东西。

我有一个检测事件数据框，其中的列提供个人的标签 ID (Tag)、检测开始时间 (StartDateTime_UTC)、检测结束时间 (EndDateTime_UTC) 和位置。

我想为每个标签汇总和总结这个数据框，每次位置发生变化时。对于每个标签和每个更改，我想采用 min(StartDateTime_UTC) 和 max(EndDateTime_UTC)。不幸的是，每个更改都没有固定数量的记录，因此简单的滚动摘要不起作用。

如果这会有所不同，则有 3 个可能的位置“IN”、“OUT”、“OVERLAP”

如果可能，我更喜欢使用包 dplyr 的解决方案。

对于下面提供的数据，输出将如下所示：

      Tag   StartDateTime_UTC     EndDateTime_UTC location
1 5004.24 2014-10-15 15:26:16 2014-10-17 07:12:19       IN
2 5004.24 2014-10-17 07:15:43 2014-10-21 02:12:29      OUT

示例数据：

structure(list(Tag = structure(c(1L, 1L, 1L, 1L, 1L, 1L, 1L, 
1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 
1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 
1L, 1L, 1L, …

我已经看到了许多其他相关的 SO 问题，例如this和this，但它们似乎并不是我想要的。假设我有一个这样的数据框：

import pandas as pd
df = pd.DataFrame(columns=['patient', 'parent csn', 'child csn', 'days'])
df.loc[0] = [0, 0, 10, 5]
df.loc[1] = [0, 0, 11, 3]
df.loc[2] = [0, 1, 12, 6]
df.loc[3] = [0, 1, 13, 4]
df.loc[4] = [1, 2, 20, 4]
df
Out[9]: 
  patient parent csn child csn days
0       0          0        10    5
1       0          0        11    3
2       0          1        12    6
3       0          1        13    4
4       1          2 …

这里我们使用聚合计算

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

但是为什么我们不在上面使用下面的概念。

a = Books.objects.all()
Avg = sum([x.price for x in a])/len(a)
34.35

我想知道使用聚合而不是第二个过程。