python - help - pandas group by multiple columns

Agregación en pandas

Question

1. ¿Cómo realizar la agregación con pandas?
2. Sin DataFrame después de la agregación! ¿Que pasó?
3. ¿Cómo agregar principalmente columnas de cadenas (para list s, tuple s, strings with separator )?
4. ¿Cómo agregar cuentas?
5. ¿Cómo crear una nueva columna rellenada por valores agregados?

He visto estas preguntas recurrentes sobre varias caras de la funcionalidad agregada de los pandas. La mayor parte de la información relacionada con la agregación y sus diversos casos de uso hoy en día está fragmentada en docenas de publicaciones mal redactadas y sin búsquedas. El objetivo aquí es recopilar algunos de los puntos más importantes para la posteridad.

Esta Q / A está destinada a ser la próxima entrega de una serie de guías de usuario útiles:

• Cómo hacer pivotar un marco de datos ,
• Pandas concat
• ¿Cómo opero un DataFrame con una serie para cada columna?
• Pandas fusionando 101

Tenga en cuenta que esta publicación no pretende ser un sustituto de la documentación sobre agregación y sobre groupby , ¡así que lea esto también!

Answer 1

Pregunta 1

¿Cómo realizar la agregación con pandas?

Documentación de agregación ampliada.

Las funciones de agregación son las que reducen la dimensión de los objetos devueltos. Significa que las Series / DataFrame de salida tienen menos o las mismas filas que las originales. Algunas funciones comunes de agregación se tabulan a continuación:

Function Description mean() Compute mean of groups sum() Compute sum of group values size() Compute group sizes count() Compute count of group std() Standard deviation of groups var() Compute variance of groups sem() Standard error of the mean of groups describe() Generates descriptive statistics first() Compute first of group values last() Compute last of group values nth() Take nth value, or a subset if n is a list min() Compute min of group values max() Compute max of group values

np.random.seed(123)
df = pd.DataFrame({''A'' : [''foo'', ''foo'', ''bar'', ''foo'', ''bar'', ''foo''],
''B'' : [''one'', ''two'', ''three'',''two'', ''two'', ''one''],
''C'' : np.random.randint(5, size=6),
''D'' : np.random.randint(5, size=6),
''E'' : np.random.randint(5, size=6)})
print (df)
A B C D E
0 foo one 2 3 0
1 foo two 4 1 0
2 bar three 2 1 1
3 foo two 1 0 3
4 bar two 3 1 4
5 foo one 2 1 0

Agregación por columnas filtradas y funciones implementadas por cython :

df1 = df.groupby([''A'', ''B''], as_index=False)[''C''].sum()
print (df1)
A B C
0 bar three 2
1 bar two 3
2 foo one 4
3 foo two 5

La función de agregación se usa para todas las columnas sin especificar en la función groupby , aquí columnas A, B :

df2 = df.groupby([''A'', ''B''], as_index=False).sum()
print (df2)
A B C D E
0 bar three 2 1 1
1 bar two 3 1 4
2 foo one 4 4 0
3 foo two 5 1 3

También puede especificar solo algunas columnas utilizadas para la agregación en la lista después de la función groupby :

df3 = df.groupby([''A'', ''B''], as_index=False)[''C'',''D''].sum()
print (df3)
A B C D
0 bar three 2 1
1 bar two 3 1
2 foo one 4 4
3 foo two 5 1

Los mismos resultados utilizando la función DataFrameGroupBy.agg :

df1 = df.groupby([''A'', ''B''], as_index=False)[''C''].agg(''sum'')
print (df1)
A B C
0 bar three 2
1 bar two 3
2 foo one 4
3 foo two 5
df2 = df.groupby([''A'', ''B''], as_index=False).agg(''sum'')
print (df2)
A B C D E
0 bar three 2 1 1
1 bar two 3 1 4
2 foo one 4 4 0
3 foo two 5 1 3

Para las funciones multiplicadas aplicadas para una columna, use la lista de tuple s - nombres de nuevas columnas y funciones agregadas:

df4 = (df.groupby([''A'', ''B''])[''C'']
.agg([(''average'',''mean''),(''total'',''sum'')])
.reset_index())
print (df4)
A B average total
0 bar three 2.0 2
1 bar two 3.0 3
2 foo one 2.0 4
3 foo two 2.5 5

Si desea pasar múltiples funciones es posible pasar la list de tuple s:

df5 = (df.groupby([''A'', ''B''])
.agg([(''average'',''mean''),(''total'',''sum'')]))
print (df5)
C D E
average total average total average total
A B
bar three 2.0 2 1.0 1 1.0 1
two 3.0 3 1.0 1 4.0 4
foo one 2.0 4 2.0 4 0.0 0
two 2.5 5 0.5 1 1.5 3

A continuación, obtenga MultiIndex en columnas:

print (df5.columns)
MultiIndex(levels=[[''C'', ''D'', ''E''], [''average'', ''total'']],
labels=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]])

Y para convertir a columnas, aplanar MultiIndex use map con join :

df5.columns = df5.columns.map(''_''.join)
df5 = df5.reset_index()
print (df5)
A B C_average C_total D_average D_total E_average E_total
0 bar three 2.0 2 1.0 1 1.0 1
1 bar two 3.0 3 1.0 1 4.0 4
2 foo one 2.0 4 2.0 4 0.0 0
3 foo two 2.5 5 0.5 1 1.5 3

Otra solución es pasar la lista de funciones agregadas, luego aplanar MultiIndex y para otros nombres de columnas use str.replace :

df5 = df.groupby([''A'', ''B'']).agg([''mean'',''sum''])
df5.columns = (df5.columns.map(''_''.join)
.str.replace(''sum'',''total'')
.str.replace(''mean'',''average''))
df5 = df5.reset_index()
print (df5)
A B C_average C_total D_average D_total E_average E_total
0 bar three 2.0 2 1.0 1 1.0 1
1 bar two 3.0 3 1.0 1 4.0 4
2 foo one 2.0 4 2.0 4 0.0 0
3 foo two 2.5 5 0.5 1 1.5 3

Si desea especificar cada columna con función agregada, pase el dictionary separado:

df6 = (df.groupby([''A'', ''B''], as_index=False)
.agg({''C'':''sum'',''D'':''mean''})
.rename(columns={''C'':''C_total'', ''D'':''D_average''}))
print (df6)
A B C_total D_average
0 bar three 2 1.0
1 bar two 3 1.0
2 foo one 4 2.0
3 foo two 5 0.5

También puede pasar la función personalizada:

def func(x):
return x.iat[0] + x.iat[-1]
df7 = (df.groupby([''A'', ''B''], as_index=False)
.agg({''C'':''sum'',''D'': func})
.rename(columns={''C'':''C_total'', ''D'':''D_sum_first_and_last''}))
print (df7)
A B C_total D_sum_first_and_last
0 bar three 2 2
1 bar two 3 2
2 foo one 4 4
3 foo two 5 1

Pregunta 2

Sin DataFrame después de la agregación! ¿Que pasó?

Agregación por 2 o más columnas:

df1 = df.groupby([''A'', ''B''])[''C''].sum()
print (df1)
A B
bar three 2
two 3
foo one 4
two 5
Name: C, dtype: int32

Primero verifique el Index y el type de objeto pandas:

print (df1.index)
MultiIndex(levels=[[''bar'', ''foo''], [''one'', ''three'', ''two'']],
labels=[[0, 0, 1, 1], [1, 2, 0, 2]],
names=[''A'', ''B''])
print (type(df1))
<class ''pandas.core.series.Series''>

Hay 2 soluciones para obtener la MultiIndex Series en columnas:

• agregar parámetro as_index=False

df1 = df.groupby([''A'', ''B''], as_index=False)[''C''].sum()
print (df1)
A B C
0 bar three 2
1 bar two 3
2 foo one 4
3 foo two 5

• utilizar Series.reset_index :

df1 = df.groupby([''A'', ''B''])[''C''].sum().reset_index()
print (df1)
A B C
0 bar three 2
1 bar two 3
2 foo one 4
3 foo two 5

Si se agrupan por una columna:

df2 = df.groupby(''A'')[''C''].sum()
print (df2)
A
bar 5
foo 9
Name: C, dtype: int32

... obtener Series con Index :

print (df2.index)
Index([''bar'', ''foo''], dtype=''object'', name=''A'')
print (type(df2))
<class ''pandas.core.series.Series''>

Y la solución es la misma que en la MultiIndex Series :

df2 = df.groupby(''A'', as_index=False)[''C''].sum()
print (df2)
A C
0 bar 5
1 foo 9
df2 = df.groupby(''A'')[''C''].sum().reset_index()
print (df2)
A C
0 bar 5
1 foo 9

Pregunta 3

¿Cómo agregar principalmente columnas de cadenas (para list s, tuple s, strings with separator )?

df = pd.DataFrame({''A'' : [''a'', ''c'', ''b'', ''b'', ''a'', ''c'', ''b''],
''B'' : [''one'', ''two'', ''three'',''two'', ''two'', ''one'', ''three''],
''C'' : [''three'', ''one'', ''two'', ''two'', ''three'',''two'', ''one''],
''D'' : [1,2,3,2,3,1,2]})
print (df)
A B C D
0 a one three 1
1 c two one 2
2 b three two 3
3 b two two 2
4 a two three 3
5 c one two 1
6 b three one 2

En lugar de la función agregada es posible la list pases, tuple , set para convertir la columna:

df1 = df.groupby(''A'')[''B''].agg(list).reset_index()
print (df1)
A B
0 a [one, two]
1 b [three, two, three]
2 c [two, one]

La alternativa es utilizar GroupBy.apply :

df1 = df.groupby(''A'')[''B''].apply(list).reset_index()
print (df1)
A B
0 a [one, two]
1 b [three, two, three]
2 c [two, one]

Para convertir a cadenas con separador use .join solo si columna de cadena:

df2 = df.groupby(''A'')[''B''].agg('',''.join).reset_index()
print (df2)
A B
0 a one,two
1 b three,two,three
2 c two,one

Si la columna numérica usa la función lambda con astype para convertir a la string s:

df3 = (df.groupby(''A'')[''D'']
.agg(lambda x: '',''.join(x.astype(str)))
.reset_index())
print (df3)
A D
0 a 1,3
1 b 3,2,2
2 c 2,1

Otra solución es convertir a cadenas antes de groupby :

df3 = (df.assign(D = df[''D''].astype(str))
.groupby(''A'')[''D'']
.agg('',''.join).reset_index())
print (df3)
A D
0 a 1,3
1 b 3,2,2
2 c 2,1

Para convertir todas las columnas, no pase ninguna lista de columnas después de groupby . No hay una columna D porque la exclusión automática de las columnas ''molestas'' significa que todas las columnas numéricas están excluidas.

df4 = df.groupby(''A'').agg('',''.join).reset_index()
print (df4)
A B C
0 a one,two three,three
1 b three,two,three two,two,one
2 c two,one one,two

Por lo tanto, es necesario convertir todas las columnas en cadenas y luego obtener todas las columnas:

df5 = (df.groupby(''A'')
.agg(lambda x: '',''.join(x.astype(str)))
.reset_index())
print (df5)
A B C D
0 a one,two three,three 1,3
1 b three,two,three two,two,one 3,2,2
2 c two,one one,two 2,1

Pregunta 4

¿Cómo agregar cuentas?

df = pd.DataFrame({''A'' : [''a'', ''c'', ''b'', ''b'', ''a'', ''c'', ''b''],
''B'' : [''one'', ''two'', ''three'',''two'', ''two'', ''one'', ''three''],
''C'' : [''three'', np.nan, np.nan, ''two'', ''three'',''two'', ''one''],
''D'' : [np.nan,2,3,2,3,np.nan,2]})
print (df)
A B C D
0 a one three NaN
1 c two NaN 2.0
2 b three NaN 3.0
3 b two two 2.0
4 a two three 3.0
5 c one two NaN
6 b three one 2.0

Función GroupBy.size para el size de cada grupo:

df1 = df.groupby(''A'').size().reset_index(name=''COUNT'')
print (df1)
A COUNT
0 a 2
1 b 3
2 c 2

Función GroupBy.count excluye valores perdidos:

df2 = df.groupby(''A'')[''C''].count().reset_index(name=''COUNT'')
print (df2)
A COUNT
0 a 2
1 b 2
2 c 1

La función se debe utilizar para varias columnas para contar valores no perdidos:

df3 = df.groupby(''A'').count().add_suffix(''_COUNT'').reset_index()
print (df3)
A B_COUNT C_COUNT D_COUNT
0 a 2 2 1
1 b 3 2 3
2 c 2 1 1

La función relacionada Series.value_counts devuelve el tamaño del objeto que contiene recuentos de valores únicos en orden descendente, de modo que el primer elemento es el elemento que ocurre con mayor frecuencia. Excluye los valores de NaN por defecto.

df4 = (df[''A''].value_counts()
.rename_axis(''A'')
.reset_index(name=''COUNT''))
print (df4)
A COUNT
0 b 3
1 a 2
2 c 2

Si desea la misma salida, como usar la función groupby + size agregue Series.sort_index :

df5 = (df[''A''].value_counts()
.sort_index()
.rename_axis(''A'')
.reset_index(name=''COUNT''))
print (df5)
A COUNT
0 a 2
1 b 3
2 c 2

Pregunta 5

¿Cómo crear una nueva columna rellenada por valores agregados?

El método GroupBy.transform devuelve un objeto indexado del mismo tamaño (el mismo tamaño) que el que se está agrupando.

documentation pandas para más información.

np.random.seed(123)
df = pd.DataFrame({''A'' : [''foo'', ''foo'', ''bar'', ''foo'', ''bar'', ''foo''],
''B'' : [''one'', ''two'', ''three'',''two'', ''two'', ''one''],
''C'' : np.random.randint(5, size=6),
''D'' : np.random.randint(5, size=6)})
print (df)
A B C D
0 foo one 2 3
1 foo two 4 1
2 bar three 2 1
3 foo two 1 0
4 bar two 3 1
5 foo one 2 1
df[''C1''] = df.groupby(''A'')[''C''].transform(''sum'')
df[''C2''] = df.groupby([''A'',''B''])[''C''].transform(''sum'')
df[[''C3'',''D3'']] = df.groupby(''A'')[''C'',''D''].transform(''sum'')
df[[''C4'',''D4'']] = df.groupby([''A'',''B''])[''C'',''D''].transform(''sum'')
print (df)
A B C D C1 C2 C3 D3 C4 D4
0 foo one 2 3 9 4 9 5 4 4
1 foo two 4 1 9 5 9 5 5 1
2 bar three 2 1 5 2 5 2 2 1
3 foo two 1 0 9 5 9 5 5 1
4 bar two 3 1 5 3 5 2 3 1
5 foo one 2 1 9 4 9 5 4 4