标签: aggregate

我正在使用聚合初始化程序为单元测试设置一个静态数据块.

我想使用数组大小​​作为预期的元素数量,但如果提供的初始化程序太少,则可能会失败:

my_struct_type expected[14] =
{
    { 1.234, 0, 'c' },
    { 3.141, 1, 'z' },
    { 2.718, 0, 'a' }
};

这在Visual Studio 2008中没有给出编译器错误.

我希望能够这样使用它:

const unsigned expected_size = sizeof(expected) / sizeof(my_struct_type);

BOOST_CHECK_EQUAL(points.size(), expected_size);

for( int i = 0; i < expected_size; i++ )
{
    BOOST_CHECK_EQUAL(points[i].value, expected[i].value);
    BOOST_CHECK_EQUAL(points[i].count, expected[i].count);
    BOOST_CHECK_EQUAL(points[i].sym,   expected[i].sym);
}

但是因为我没有14点的编译时保证,所以它在所提供值的数组末尾和默认初始值之间运行.

我可以在编译时以某种方式强制执行聚合数组初始值设定项的数量吗？

我正在尝试编写一个查询,该查询获取与另一个字段(或多个字段)的最大值相关联的一个字段的值.假设我有以下数据表:

OrderID CustomerID  OrderDate   LocationID          
1       4           1/1/2001    1001
2       4           1/2/2001    1003
3       4           1/3/2001    1001
4       5           1/4/2001    1001
5       5           1/5/2001    1001
6       5           1/6/2001    1003
7       5           1/7/2001    1002
8       5           1/8/2001    1003
9       5           1/8/2001    1002

分组依据CustomerID,我希望获得最大值OrderDate,然后与最大值LocationID相关联OrderDate.如果有共享的最大订单日期几条记录,然后采取LocationID与相关的最大OrderID距离与最大日期的记录中.

最终的数据集应如下所示:

CustomerID  OrderDate   LocationID      
4           1/3/2001    1001
5           1/8/2001    1002

我一直在尝试编写一个包含大量嵌套子查询和丑陋连接的查询,但我并没有真正得到任何结论.我需要写什么SQL来帮助我获得这个结果.

我有一个employee表,带有employee_id,name和working_division,其中employee_id是主键.我有一个包含这些列的Excel源代码,以及员工输入工作时间的更多信息,以及他们所做的工作类型,公司的划分等等.

因此,对于任何一天,一个员工我可以有多行显示他们的工作类型,他们工作的部门,以及他们对该部门的收费时间.

如何将其插入到employee_id主键中的OLE DB中？

我试图使用聚合转换来分组employee_id,但是employee_id并且working_divisions不是一对一的.因此,对这两列的操作组将尝试将相同的内容employee_id插入employee表中(这employee_id是主键!)如果我不包括working_division聚合转换,那么我将丢失数据.

如何通过分组我的数据employee_id,并保留该行的所有其他列？

感谢您的帮助!

可以说我有一个像这样的小整数数组:

{10,20,30}

现在对于该数组的项目,我想应用以下公式:

10^(arrayLenght-1) + 20^{arrayLenght-2) + 30^{arrayLenght-3}

有没有办法通过使用linq聚合方法来实现这一点,虽然你需要某种迭代器,当我看到这个时,聚合没有实现？

我使用聚合函数来按组计数.如果count> 0,则聚合函数仅返回组的计数.这就是我所拥有的

dt <- data.frame(
n  = c(1,2,3,4,5,6),
id = c('A','A','A','B','B','B'),
group = c("x","x","y","x","x","x")) 

应用聚合函数

my.count <- aggregate(n ~ id+group, dt, length)

现在看到结果

my.count[order(my.count$id),]

我得到了关注

id group   n
1  A     x 2
3  A     y 1
2  B     x 3

我需要以下内容(最后一行为零,我需要)

id group   n
1  A     x 2
3  A     y 1
2  B     x 3
4  B     y 0

谢谢你提前帮忙

我正在使用Pandas来构建和处理数据。这是我的DataFrame：

我按分钟将许多日期时间分组，然后进行汇总，以便按分钟获得“比特率”分数的总和。这是我拥有此数据框的代码：

def aggregate_data(data):

    def delete_seconds(time):

        return (datetime.datetime.strptime(time, '%Y-%m-%d %H:%M:%S')).replace(second=0)


    data['new_time'] = data['beginning_time'].apply(delete_seconds)
    df = (data[['new_time', 'bitrate']].groupby(['new_time'])).aggregate(np.sum)

    return df

现在，我想用5分钟作为存储桶来执行类似的操作。我想将我的约会时间按5分钟进行分组，然后做一个平均数。..这样的事情：

df.groupby([df.index.map(lambda t: t.5minute)]).aggregate(np.mean)

想法？谢谢 ！

嗨,我将展示我试图通过示例做的事情:我从这样的数据框开始:

> pd.DataFrame({'A':['a','a','a','c'],'B':[1,1,2,3], 'count':[5,6,1,7]})
    A   B   count
0   a   1   5
1   a   1   6
2   a   2   1
3   c   3   7

我需要找到一种方法来获得A列和B列之间的所有独特组合,并合并它们.count列应该在合并列之间添加,结果应如下所示:

    A   B   count
0   a   1   11
1   a   2   1
2   c   3   7

有任何帮助.

使用数据框和熊猫,我试图找出每个值占"分组依据"类别的总计百分比的百分比

所以,使用提示数据库,我想看到,对于每个性别/吸烟者,总账单占女性吸烟者/所有女性和女性非吸烟者/所有女性(男性同样的事情)的比例是多少

例如,

如果完整的数据集是:

Sex, Smoker, Day, Time, Size, Total Bill
Female,No,Sun,Dinner,2, 20
Female,No,Mon,Dinner,2, 40
Female,No,Wed,Dinner,1, 10
Female,Yes,Wed,Dinner,1, 15

第一行的值将是(20 + 40 + 10)/(20 + 40 + 10 + 15),因为那些是非吸烟女性的其他3个值

所以输出应该是这样的

Female No 0.823529412
Female Yes 0.176470588

但是,我似乎遇到了一些麻烦

当我这样做时,

import pandas as pd
df=pd.read_csv("https://raw.githubusercontent.com/wesm/pydata-   book/master/ch08/tips.csv", sep=',')
df.groupby(['sex', 'smoker'])[['total_bill']].apply(lambda x: x / x.sum()).head()

我得到以下内容:

    total_bill
0   0.017378
1   0.005386
2   0.010944
3   0.012335
4   0.025151

它似乎忽略了组,只是为每个项目计算它

我正在寻找更像的东西

df.groupby(['sex', 'smoker'])[['total_bill']].sum()

哪个会回归

        total_bill
sex smoker  
Female  No  977.68
        Yes 593.27
Male    No  1919.75 …

有这个结构:

struct A {
    struct B {
        int a = 21;
        int b;
        int c = 22;
        int d;
        int e = 23;
    };
    B b1  = { 11, 12 };
    B b2  = { 11, 12, 13 };
    int x;
};

并声明:

A a = { { 1, 2, 3, 4 }, { 1 }, 5 };

根据Clang(3.8.0)和GCC(5.4.0),这些是8种可能组合的值(a.b1.e和a.b2.a是重复的情况),关于初始值的位置从(或不),:

a.b1.a = 1   // 111
a.b1.b = 2   // 110
a.b1.c = 3   // 101
a.b1.d = 4   // 100
a.b2.b …

我正在按多列对数据帧进行分组并聚合以获取多个统计信息.如何获得一个完全平坦的结构,每个可能的组密钥组合枚举为行,每个统计数据作为列存在？

import numpy as np
import pandas as pd

cities = ['Berlin', 'Oslo']
days = ['Monday', 'Friday']

data = pd.DataFrame({
        'city': np.random.choice(cities, 12),
        'day': np.random.choice(days, 12),
        'people': np.random.normal(loc=10, size=12),
        'cats': np.random.normal(loc=6, size=12)})
grouped = data.groupby(['city', 'day']).agg([np.mean, np.std])

这样我就得到了:

                   cats               people          
                   mean       std       mean       std
city   day                                            
Berlin Friday  6.146924  0.721263  10.445606  0.730992
       Monday  5.239267       NaN   9.022811       NaN
Oslo   Friday  6.322276  0.866899  11.579813  0.114341
       Monday  5.028919  0.815674  10.458439  1.182689

我需要弄平:

city   day     cats_mean cats_std  people_mean people_std                                       
Berlin Friday  6.146924  0.721263  10.445606 …