Acabo de empezar a aprender Pandas y me preguntaba si hay alguna diferencia entre groupby y pivot_table funciones ¿Alguien puede ayudarme a entender la diferencia entre ellos?

Ambos pivot_table y groupby se utilizan para agregar su marco de datos. La diferencia es sólo con respecto a la forma del resultado.

Usando pd.pivot_table(df, index=["a"], columns=["b"], values=["c"], aggfunc=np.sum) se crea una tabla donde a está en el eje de la fila, b está en el eje de la columna, y los valores son la suma de c.

Ejemplo:

df = pd.DataFrame({"a": [1,2,3,1,2,3], "b":[1,1,1,2,2,2], "c":np.random.rand(6)})
pd.pivot_table(df, index=["a"], columns=["b"], values=["c"], aggfunc=np.sum)

b         1         2
a                    
1  0.528470  0.484766
2  0.187277  0.144326
3  0.866832  0.650100

Usando groupbylas dimensiones proporcionadas se colocan en columnas y se crean filas para cada combinación de esas dimensiones.

En este ejemplo, creamos una serie de la suma de valores cagrupados por todas las combinaciones únicas de a y b.

df.groupby(['a','b'])['c'].sum()

a  b
1  1    0.528470
   2    0.484766
2  1    0.187277
   2    0.144326
3  1    0.866832
   2    0.650100
Name: c, dtype: float64

Un uso similar de groupby es si omitimos el ['c']. En este caso, crea un marco de datos (no una serie) de las sumas de todas las columnas restantes agrupadas por valores únicos de a y b.

print df.groupby(["a","b"]).sum()
            c
a b          
1 1  0.528470
  2  0.484766
2 1  0.187277
  2  0.144326
3 1  0.866832
  2  0.650100

pivot_table = agrupar por + desapilar y groupby = tabla_pivote + pila consideramos verdaderos.

En particular, si columns parámetro de pivot_table() no se usa entonces groupby() y pivot_table() ambos producen el mismo resultado (si se usa la misma función de agregador).

# sample
df = pd.DataFrame({"a": [1,1,1,2,2,2], "b": [1,1,2,2,3,3], "c": [0,0.5,1,1,2,2]})

# example
gb = df.groupby(['a','b'])[['c']].sum()
pt = df.pivot_table(index=['a','b'], values=['c'], aggfunc="sum")

# equality test
gb.equals(pt) #True

En general, si comprobamos la código fuente, pivot_table() llamadas internas __internal_pivot_table(). Esta función crea una sola lista plana a partir de índices, columnas y llamadas groupby() con esta lista como el mero. Luego, después de la agregación, las llamadas unstack() en la lista de columnas.

Si las columnas nunca se pasan, no hay nada que desapilar, por lo que groupby y pivot_table producir trivialmente la misma salida.

Una demostración de esta función es:

gb = (
    df
    .groupby(['a','b'])[['c']].sum()
    .unstack(['b'])
)
pt = df.pivot_table(index=['a'], columns=['b'], values=['c'], aggfunc="sum")

gb.equals(pt) # True

Como stack() es la operación inversa de unstack()lo siguiente también es verdadero:

(
    df
    .pivot_table(index=['a'], columns=['b'], values=['c'], aggfunc="sum")
    .stack(['b'])
    .equals(
        df.groupby(['a','b'])[['c']].sum()
    )
) # True

En conclusión, dependiendo del caso de uso, uno es más conveniente que el otro, pero ambos pueden usarse en lugar del otro y después de aplicar correctamente stack()/unstack()ambos darán como resultado el mismo resultado.

Sin embargo, hay una diferencia de rendimiento entre los dos métodos. En breve, pivot_table() es más lento que groupby().agg().unstack(). Puedes leer más sobre esto en esta respuesta.

Es más apropiado usar .pivot_table() en lugar de .groupby() cuando necesite mostrar agregados con etiquetas de filas y columnas.

.pivot_table() facilita la creación de etiquetas de fila y columna al mismo tiempo y es preferible, aunque puede obtener resultados similares utilizando .groupby() con unos pocos pasos adicionales.

Diferencia entre pivot_table y groupby

tabla dinámica

agrupar por