python - multiple - pandas groupby count

Aplicar funciones múltiples a varias columnas groupby

Question

Los docs muestran cómo aplicar múltiples funciones en un grupo por objeto a la vez usando un dict con los nombres de las columnas de salida como las claves:

In [563]: grouped[''D''].agg({''result1'' : np.sum,
   .....:                   ''result2'' : np.mean})
   .....:
Out[563]: 
      result2   result1
A                      
bar -0.579846 -1.739537
foo -0.280588 -1.402938

Sin embargo, esto solo funciona en un objeto agrupado por grupo. Y cuando un dict se pasa de manera similar a un grupo por DataFrame, espera que las claves sean los nombres de columna a los que se aplicará la función.

Lo que quiero hacer es aplicar múltiples funciones a varias columnas (pero ciertas columnas serán operadas varias veces). Además, algunas funciones dependerán de otras columnas en el grupo por objeto (como funciones de suma). Mi solución actual es ir columna por columna y hacer algo como el código anterior, usando lambdas para funciones que dependen de otras filas. Pero esto está tomando mucho tiempo, (creo que lleva mucho tiempo iterar a través de un grupo por objeto). Tendré que cambiarlo para que recorra todo el grupo por objeto en una sola ejecución, pero me pregunto si hay una forma integrada en pandas para hacerlo de una manera un tanto limpia.

Por ejemplo, he intentado algo como

grouped.agg({''C_sum'' : lambda x: x[''C''].sum(),
             ''C_std'': lambda x: x[''C''].std(),
             ''D_sum'' : lambda x: x[''D''].sum()},
             ''D_sumifC3'': lambda x: x[''D''][x[''C''] == 3].sum(), ...)

pero como esperaba recibo un KeyError (ya que las claves tienen que ser una columna si se llama a agg desde un DataFrame).

¿Existe alguna forma de hacer lo que me gustaría hacer, o la posibilidad de que se agregue esta funcionalidad, o solo tendré que repetir el grupo manualmente?

Gracias

Answer 1

La segunda mitad de la respuesta actualmente aceptada está desactualizada y tiene dos inconvenientes. Primero y más importante, ya no puede pasar un diccionario de diccionarios al método agg groupby. Segundo, nunca uses .ix .

Si desea trabajar con dos columnas separadas al mismo tiempo, le sugiero que utilice el método de apply , cuya implicidad pasa un DataFrame a la función aplicada. Usemos un marco de datos similar al de arriba

df = pd.DataFrame(np.random.rand(4,4), columns=list(''abcd''))
df[''group''] = [0, 0, 1, 1]
df

          a         b         c         d  group
0  0.418500  0.030955  0.874869  0.145641      0
1  0.446069  0.901153  0.095052  0.487040      0
2  0.843026  0.936169  0.926090  0.041722      1
3  0.635846  0.439175  0.828787  0.714123      1

Un diccionario asignado de nombres de columna a funciones de agregación sigue siendo una forma perfectamente buena de realizar una agregación.

df.groupby(''group'').agg({''a'':[''sum'', ''max''], 
                         ''b'':''mean'', 
                         ''c'':''sum'', 
                         ''d'': lambda x: x.max() - x.min()})

              a                   b         c         d
            sum       max      mean       sum  <lambda>
group                                                  
0      0.560541  0.507058  0.418546  1.707651  0.129667
1      0.187757  0.157958  0.887315  0.533531  0.652427

Si no le gusta el nombre feo de la columna lambda, puede usar una función normal y proporcionar un nombre personalizado al atributo especial __name__ como este:

def max_min(x):
    return x.max() - x.min()

max_min.__name__ = ''Max minus Min''

df.groupby(''group'').agg({''a'':[''sum'', ''max''], 
                         ''b'':''mean'', 
                         ''c'':''sum'', 
                         ''d'': max_min})

              a                   b         c             d
            sum       max      mean       sum Max minus Min
group                                                      
0      0.560541  0.507058  0.418546  1.707651      0.129667
1      0.187757  0.157958  0.887315  0.533531      0.652427

Usar apply y devolver una serie

Ahora, si tenía varias columnas que necesitaban interactuar juntas, entonces no puede usar agg , que implícitamente pasa una serie a la función de agregación. Al usar, apply el grupo completo como un DataFrame pasa a la función.

Recomiendo hacer una única función personalizada que devuelva una serie de todas las agregaciones. Use el índice de la serie como etiquetas para las nuevas columnas:

def f(x):
    d = {}
    d[''a_sum''] = x[''a''].sum()
    d[''a_max''] = x[''a''].max()
    d[''b_mean''] = x[''b''].mean()
    d[''c_d_prodsum''] = (x[''c''] * x[''d'']).sum()
    return pd.Series(d, index=[''a_sum'', ''a_max'', ''b_mean'', ''c_d_prodsum''])

df.groupby(''group'').apply(f)
          a_sum     a_max    b_mean  c_d_prodsum
group                                           
0      0.560541  0.507058  0.418546     0.118106
1      0.187757  0.157958  0.887315     0.276808

Si está enamorado de MultiIndexes, aún puede devolver una Serie con una como esta:

    def f_mi(x):
        d = []
        d.append(x[''a''].sum())
        d.append(x[''a''].max())
        d.append(x[''b''].mean())
        d.append((x[''c''] * x[''d'']).sum())
        return pd.Series(d, index=[[''a'', ''a'', ''b'', ''c_d''], 
                                   [''sum'', ''max'', ''mean'', ''prodsum'']])

df.groupby(''group'').apply(f_mi)

              a                   b       c_d
            sum       max      mean   prodsum
group                                        
0      0.560541  0.507058  0.418546  0.118106
1      0.187757  0.157958  0.887315  0.276808

Answer 2

Para la primera parte puede pasar un dict de nombres de columna para claves y una lista de funciones para los valores:

In [28]: df
Out[28]:
          A         B         C         D         E  GRP
0  0.395670  0.219560  0.600644  0.613445  0.242893    0
1  0.323911  0.464584  0.107215  0.204072  0.927325    0
2  0.321358  0.076037  0.166946  0.439661  0.914612    1
3  0.133466  0.447946  0.014815  0.130781  0.268290    1

In [26]: f = {''A'':[''sum'',''mean''], ''B'':[''prod'']}

In [27]: df.groupby(''GRP'').agg(f)
Out[27]:
            A                   B
          sum      mean      prod
GRP
0    0.719580  0.359790  0.102004
1    0.454824  0.227412  0.034060

ACTUALIZACIÓN 1:

Debido a que la función de agregado funciona en Series, las referencias a los otros nombres de columna se pierden. Para evitar esto, puede hacer referencia al marco de datos completo e indexarlo usando los índices de grupo dentro de la función lambda.

Aquí hay una solución hacky:

In [67]: f = {''A'':[''sum'',''mean''], ''B'':[''prod''], ''D'': lambda g: df.loc[g.index].E.sum()}

In [69]: df.groupby(''GRP'').agg(f)
Out[69]:
            A                   B         D
          sum      mean      prod  <lambda>
GRP
0    0.719580  0.359790  0.102004  1.170219
1    0.454824  0.227412  0.034060  1.182901

Aquí, la columna resultante ''D'' se compone de los valores ''E'' sumados.

ACTUALIZACIÓN 2:

Este es un método que creo que hará todo lo que pidas. Primero crea una función lambda personalizada. A continuación, g hace referencia al grupo. Cuando se agrega, g será una serie. Al pasar g.index a df.ix[] selecciona el grupo actual de df. Luego pruebo si la columna C es menor que 0.5. La serie booleana devuelta se pasa a g[] que selecciona solo aquellas filas que cumplen los criterios.

In [95]: cust = lambda g: g[df.loc[g.index][''C''] < 0.5].sum()

In [96]: f = {''A'':[''sum'',''mean''], ''B'':[''prod''], ''D'': {''my name'': cust}}

In [97]: df.groupby(''GRP'').agg(f)
Out[97]:
            A                   B         D
          sum      mean      prod   my name
GRP
0    0.719580  0.359790  0.102004  0.204072
1    0.454824  0.227412  0.034060  0.570441