标签: aggregate

我有一个指向内容的URL,我需要获得其中一列中包含的最高值.是否有任何聚合函数可以实现,或者我必须手动执行此操作？

假设我有一节课:

class Aggregate {

public:

    int x;
    int y;

};

我知道如何使用花括号初始化对象:

Aggregate a1 = { 1500, 2900 };

但我找不到合适的语法来创建临时对象并将其作为参数传递给某个方法,例如:

void frobnicate(const Aggregate& arg) { 
    // do something
}

//...

frobnicate(Aggregate {1500, 2900}); // what should this line look like?

最简单的方法是将构造函数添加到Aggregate类,但我们假设我没有访问Aggregate头的权限.另一个想法是写一些工厂方法,即

Aggregate makeAggregate(int x, int y).

我也可以创建一个对象,然后将其作为参数传递等.等.

有很多解决方案,但我只是好奇是否可以使用花括号初始化来实现这个目标.

可以创建一个通过构造函数参数初始化的匿名对象,例如在下面的return语句中.

struct S {
  S(int i_, int j_) : i(i_), j(j_) { }
  int i, j;
};

S f()
{
  return S(52, 100);
}

int main()
{
  cout << f().i << endl;
  return 0;
}

但是,是否可以类似地创建一个使用大括号初始化程序初始化的匿名聚合？例如,可以将f()的主体折叠到下面,直到单个return语句而没有"s"吗？

struct S {
  int i, j;
};

S f()
{
  S s = { 52, 100 };
  return s;
}

int main()
{
  cout << f().i << endl;
  return 0;
}

我想做一个很好的函数来聚合数组之间的数据(它是一个numpy记录数组,但它不会改变任何东西)

你有一个数据阵列,你想在一个轴之间聚合:例如一个数组,dtype=[(name, (np.str_,8), (job, (np.str_,8), (income, np.uint32)]你希望每个工作的平均收入

我做了这个功能,在示例中它应该被称为 aggregate(data,'job','income',mean)

def aggregate(data, key, value, func):

    data_per_key = {}

    for k,v in zip(data[key], data[value]):

        if k not in data_per_key.keys():

            data_per_key[k]=[]

        data_per_key[k].append(v)

    return [(k,func(data_per_key[k])) for k in data_per_key.keys()]

问题是我发现它不是很好我想把它放在一行:你有什么想法吗？

谢谢你的回答路易斯

PS:我想在通话中保留功能,这样你也可以要求中位数,最小...

是否可以将GROUP_CONCAT放入MYSQL WHERE子句中？

我有两个表(一个用于成员,一个用于付款信息).例如

会员表

num, memNumber, fullName, coporateName, surname
001, mem0010, Joe Bloggs, NULL, Bloggs
002, mem0015, NULL, BBC
003, mem0017, John Peters, NULL
004, mem0101, Emma Jane, NULL

付款表

num, memberID, subscriptionYear, amount
001, mem0010, 2008, 30
003, mem0010, 2010, 40
004, mem0015, 2010, 40
005, mem0017, 2009, 35
006, mem0101, 2009, 35
007, mem0017, 2010, 40

我有以下查询从两个表中检索信息(我已经简化它以使其更具可读性).

SELECT members.num, members.memNumber , members.fullName , members.corporateName ,
       CONCAT(members.corporateName , members.surname) AS searchSurname ,
       GROUP_CONCAT(payment.subscriptionYear) As subscriptionYear ,
       GROUP_CONCAT(payment.amount) AS amount …

我在使用JOliver的Event Store在单个事务中对多个聚合的更新有疑问.据我所知,每个聚合都应该有自己的事件流.现在,虽然许多命令处理程序只会加载一个聚合并只更新该聚合(即为这些聚合保存事件),但我可以想象会有需要更新多个聚合的命令处理程序.当然,我想以交易方式做到这一点.

但是,我不知道如何使用Event Store做到这一点.通过调用CommitChanges()事件流来完成存储事件.如果我们要更新多个聚合,则会有多个事件流,因此会有多个调用CommitChanges().制作该事务的唯一方法是将其包装在一个TransactionScope,但这没有多大意义,因为底层存储技术可能不支持事务.所以我最终得到了这个代码,这绝对不是我想要的:

        Guid aggregateGuid1 = Guid.NewGuid();
        Guid aggregateGuid2 = Guid.NewGuid();
        Guid commitGuid = Guid.NewGuid();

        var stream = store.OpenStream(aggregateGuid1, 0, int.MaxValue);
        stream.Add(new EventMessage() { Body = new MonitorDisabled { MonitorGuid = aggregateGuid1, User = "A" } });
        stream.CommitChanges(commitGuid);

        stream = store.OpenStream(aggregateGuid2, 0, int.MaxValue);
        stream.Add(new EventMessage() { Body = new MonitorEnabled { MonitorGuid = aggregateGuid2, User = "B" } });
        // Can't commit twice with the same commit id, what if fails …

使用DataFrame（pdandas为pd，numpy为np）：

test = pd.DataFrame({'A' : [10,11,12,13,15,25,43,70],  
                     'B' : [1,2,3,4,5,6,7,8],  
                     'C' : [1,1,1,1,2,2,2,2]})


In [39]: test
Out[39]: 
    A  B  C
0  10  1  1
1  11  2  1
2  12  3  1
3  13  4  1
4  15  5  2
5  25  6  2
6  43  7  2
7  70  8  2

将DF按'C'分组并与np.mean（也包括sum，min，max）进行聚合，从而在各组内生成按列的聚合：

In [40]: test_g = test.groupby('C')

In [41]: test_g.aggregate(np.mean)
Out[41]: 
       A    B
C            
1  11.50  2.5
2  38.25  6.5

但是，看起来使用np.median进行聚合会在组内产生DataFrame明智的聚合：

In [42]: test_g.aggregate(np.median)
Out[42]: 
      A     B
C            
1   7.0 …

我们有两个型号(简化版):

class Contestant(models.Model):
    email = models.EmailField(max_length=255, unique=True)
    # plus some other fields

    @property
    def total_points(self):
        return self.points.aggregate(total=Sum('value'))['total'] or 0

class Points(models.Model):
    contestant = models.ForeignKey(Contestant, related_name='points')
    value = models.PositiveIntegerField()
    # plus some other fields which determine based on what we
    # awarded ``Points.value``

当我们显示参赛者名单及其total_points价值时,会导致对每个结果进行额外查询 - 即执行以下查询:

1. 获取参赛者名单
2. 取得total_points第一名选手的价值
3. 取得total_points第二名选手的价值
4. 等等

我尝试更改查询集以预取数据,如下所示:

Contestant.objects.filter(...).prefetch_related('points')

...,但即使它有效,在列出参赛者时也不会使用预取数据(因此每个结果仍然会尝试total_points 在单独的查询中获取).

是否有可能:

• 以某种方式告诉ORM在为各个模型对象填充数据时使用@property字段的预取值(例如,访问Contestant.total_points@property方法中的预取值)？
• 或者以不同的方式预取它们(与上面的例子相反)？
• 或者使用完全不同的方法来实现相同的结果？

(tastypie如果重要的话,我会列出结果.)

谢谢.

这是我正在尝试做的和我得到的最简单的工作示例:

我有一个查询如下:

/*
with tran_party as -- ALL DUMMY DATA ARE IN THESE CTE FOR YOUR REFERENCE
         (select 1 tran_party_id, 11 transaction_id, 101 team_id_redirect
            from dual
          union all
          select 2, 11, 101 from dual
          union all
          select 3, 11, 102 from dual
          union all
          select 4, 12, 103 from dual
          union all
          select 5, 12, 103 from dual
          union all
          select 6, 12, 104 from dual
          union all
          select 7, 13, 104 from dual
          union all
          select 8, 13, 105 …

情况

考虑以下两个数据帧:

import pandas as pd  # version 0.23.4

df1 = pd.DataFrame({
    'A': [1, 1, 1, 2, 2],
    'B': [100, 100, 200, 100, 100],
    'C': ['apple', 'orange', 'mango', 'mango', 'orange'],
    'D': ['jupiter', 'mercury', 'mars', 'venus', 'venus'],
})

df2 = df1.astype({'D': 'category'})

正如您在数据框中看到的那样,df2该列 D是分类数据类型,但在其他方面df2是相同的df1.

现在考虑以下groupby-aggregation操作:

result_x_df1 = df1.groupby(by='A').first()
result_x_df2 = df2.groupby(by='A').first()
result_y_df1 = df1.groupby(by=['A', 'B']).first()
result_y_df2 = df2.groupby(by=['A', 'B']).first()

结果如下:

In [1]: result_x_df1
Out[1]:
     B      C        D
A
1  100  apple  jupiter …