1. uso de pivote
En pandas, el código fuente de pivote se explica así
Return reshaped DataFrame organized by given index / column values.
Reshape data (produce a "pivot" table) based on column values. Uses
unique values from specified `index` / `columns` to form axes of the
resulting DataFrame. This function does not support data
aggregation, multiple values will result in a MultiIndex in the
columns. See the :ref:`User Guide <reshaping>` for more on reshaping.
Parameters
----------%s
index : str or object, optional
Column to use to make new frame's index. If None, uses
existing index.
columns : str or object
Column to use to make new frame's columns.
values : str, object or a list of the previous, optional
Column(s) to use for populating new frame's values. If not
specified, all remaining columns will be used and the result will
have hierarchically indexed columns.
.. versionchanged:: 0.23.0
Also accept list of column names.
Returns
-------
DataFrame
Returns reshaped DataFrame.
Los comentarios anteriores describen bastante bien el propósito del método de pivote:
devolver un DataFrame remodelado organizado por los valores de índice/columna dados.
Si no entiendes esta frase por el momento, no importa, seguiremos analizándola más adelante.
Vea un ejemplo de pivote.
def t2():
data = {
"a": [1, 2, 3, 1, 2],
"b": [10, 20, 30, 40, 50],
"c": ['x', 'y', 'z', 'm', 'n']
}
data = pd.DataFrame(data)
result = data.pivot(index='a', columns='b', values='c')
print(result, "\n")
result = result.fillna('un')
print(result)
La salida del código es:
b 10 20 30 40 50
a
1 x NaN NaN m NaN
2 NaN y NaN NaN n
3 NaN NaN z NaN NaN
b 10 20 30 40 50
a
1 x un un m un
2 un y un un n
3 un un z un un
2.tabla_pivote
La diferencia entre pivot_table y pivot es que pivot solo remodela los datos y no puede agregarlos. Al mismo tiempo, en el método pivote, si hay duplicados en los datos compuestos por el índice y las columnas especificados, el código informará un error.
Pivot_table puede remodelar los datos. La ventaja de remodelar los datos es que hace que los datos sean más intuitivos y fáciles de analizar. Se conoce comúnmente como pivote de datos. Los estudiantes que usan Excel con frecuencia están familiarizados con las tablas dinámicas. Al mismo tiempo, pivot_table puede agregar más datos, veamos un ejemplo a continuación.
def t3():
data = {
"a": [1, 1, 2, 2, 3, 1, 2, 3],
"b": [1, 1, 1, 1, 1, 2, 2, 2],
"c": [1, 2, 3, 4, 5, 6, 7, 8]
}
df = pd.DataFrame(data)
# <class 'pandas.core.frame.DataFrame'>
result = pd.pivot_table(df, index=['a'], columns=['b'], values=['c'], aggfunc=np.sum)
print(result, "\n")
La salida del código es
c
b 1 2
a
1 3 6
2 7 7
3 5 8
3.groupby
El pivote mencionado anteriormente puede agrupar y agregar matrices De hecho, generalmente usamos groupby para agrupar y agregar datos diariamente. Por ejemplo, podemos usar groupby para lograr los resultados en la segunda parte
def t4():
data = {
"a": [1, 1, 2, 2, 3, 1, 2, 3],
"b": [1, 1, 1, 1, 1, 2, 2, 2],
"c": [1, 2, 3, 4, 5, 6, 7, 8]
}
# <class 'pandas.core.series.Series'>
df = pd.DataFrame(data).groupby(['a', 'b']).c.sum()
for ele in df.items():
print(ele[0], ele[1])
(1, 1) 3
(1, 2) 6
(2, 1) 7
(2, 2) 7
(3, 1) 5
(3, 2) 8
Como puede ver, la salida es exactamente la misma que pivot_table.
Entonces, ¿cuál es la diferencia entre pivot_table y groupby?
Si lo explica en una oración: tanto pivot_table como groupby se usan para agregar datos, la diferencia está solo en la forma del resultado. Pivot/pivot_table es para hacer que el reordenamiento y la combinación de datos sean más intuitivos, lo que comúnmente se conoce como pivoteo de datos; y el método groupby es principalmente para agrupar y agregar datos, por lo que generalmente usamos el método groupby directamente cuando realizamos la agregación de datos.
4. tabulación cruzada
Crosstab es una tabla dinámica especial que se usa para contar la frecuencia de agrupación, que es un caso especial de tabla_pivote.
"""
Compute a simple cross tabulation of two (or more) factors. By default
computes a frequency table of the factors unless an array of values and an
aggregation function are passed.
Parameters
----------
index : array-like, Series, or list of arrays/Series
Values to group by in the rows.
columns : array-like, Series, or list of arrays/Series
Values to group by in the columns.
values : array-like, optional
Array of values to aggregate according to the factors.
Requires `aggfunc` be specified.
rownames : sequence, default None
If passed, must match number of row arrays passed.
colnames : sequence, default None
If passed, must match number of column arrays passed.
aggfunc : function, optional
If specified, requires `values` be specified as well.
margins : bool, default False
Add row/column margins (subtotals).
margins_name : str, default 'All'
Name of the row/column that will contain the totals
when margins is True.
.. versionadded:: 0.21.0
dropna : bool, default True
Do not include columns whose entries are all NaN.
normalize : bool, {'all', 'index', 'columns'}, or {0,1}, default False
Normalize by dividing all values by the sum of values.
- If passed 'all' or `True`, will normalize over all values.
- If passed 'index' will normalize over each row.
- If passed 'columns' will normalize over each column.
- If margins is `True`, will also normalize margin values.
Returns
-------
DataFrame
Cross tabulation of the data.
See Also
--------
DataFrame.pivot : Reshape data based on column values.
pivot_table : Create a pivot table as a DataFrame.
Veamos un ejemplo también.
def t5():
data = {
"a": [1, 1, 2, 2, 3, 1, 2, 3],
"b": [1, 1, 1, 1, 1, 2, 2, 2],
"c": [1, 2, 3, 4, 5, 6, 7, 8]
}
data = pd.DataFrame(data)
# <class 'pandas.core.frame.DataFrame'>
df = pd.crosstab(index=data.a, columns=data.b)
print(df, "\n")
df2 = data.groupby(['a', 'b']).agg({'c': 'count'})
print(df2, "\n")
df3 = pd.crosstab(index=data['a'], columns=data['b']).cumsum(axis=0)
print(df3)
La salida del código es:
b 1 2
a
1 2 1
2 2 1
3 1 1
c
a b
1 1 2
2 1
2 1 2
2 1
3 1 1
2 1
b 1 2
a
1 2 1
2 4 2
3 5 3