pivot_table: tablas de contingencia
Cree tablas dinámicas al estilo de Excel con pd.pivot_table, estableciendo index, columns, values y aggfunc.
pivot_table: tablas de contingencia es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Pandas & NumPy Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.
¿Qué es una tabla dinámica?
Una tabla dinámica es una tabulación cruzada que resume los datos según dos dimensiones categóricas: una forma las filas y otra forma las columnas, con un valor agregado en cada celda. Si alguna vez ha creado una tabla dinámica en Excel, reconocerá el concepto de inmediato. Pandas proporciona pd.pivot_table() (así como su versión como método de DataFrame) para crear estos resúmenes completamente en Python.
Llamada básica a pivot_table
Los cuatro parámetros principales de pd.pivot_table() son: values (la columna que se agregará), index (la columna que se convertirá en filas), columns (la columna que se convertirá en columnas) y aggfunc (la función de agregación, cuyo valor predeterminado es 'mean'). El resultado es un DataFrame en el que cada celda contiene el valor agregado para esa combinación de fila y columna.
import pandas as pd
df = pd.DataFrame({
'region': ['East', 'West', 'East', 'West', 'East', 'West'],
'product': ['A', 'A', 'B', 'B', 'A', 'B'],
'revenue': [200, 340, 150, 290, 310, 410]
})
table = pd.pivot_table(df,
values='revenue',
index='region',
columns='product',
aggfunc='sum')
print(table)
# product A B
# region
# East 510 150
# West 340 700Elección de aggfunc
El parámetro aggfunc acepta cualquier nombre de cadena de una función de agregación de NumPy/Pandas, una función invocable o una lista de funciones invocables. Algunas opciones habituales son: 'sum' para los totales, 'mean' para los promedios, 'count' para las frecuencias y 'min'/'max' para los extremos. Cuando pasa una lista, cada agregación obtiene su propio nivel en el MultiIndex de columnas.
# Using mean (default)
table_mean = pd.pivot_table(df, values='revenue',
index='region', columns='product',
aggfunc='mean')
print(table_mean.round(1))
# product A B
# region
# East 255.0 150.0
# West 340.0 350.0
# Using count
table_count = pd.pivot_table(df, values='revenue',
index='region', columns='product',
aggfunc='count')
print(table_count)Gestión de celdas vacías con fill_value
Cuando una combinación de etiquetas de fila y columna no contiene datos, la celda contiene NaN de forma predeterminada. Pase fill_value para sustituir esas celdas vacías por un valor predeterminado significativo, como 0 para recuentos o ingresos. Esto facilita la lectura de la tabla y evita que las operaciones aritméticas posteriores produzcan resultados NaN silenciosamente.
df2 = pd.DataFrame({
'region': ['East', 'West', 'East'],
'product': ['A', 'A', 'B'],
'revenue': [200, 340, 150]
})
# West-B combination has no data -> NaN by default
table = pd.pivot_table(df2, values='revenue', index='region',
columns='product', aggfunc='sum', fill_value=0)
print(table)
# product A B
# region
# East 200 150
# West 340 0 <- filled with 0 instead of NaNAdición de subtotales con margins
Pase margins=True para añadir los totales de filas y columnas a la tabla dinámica. Pandas agrega una fila 'All' en la parte inferior y una columna 'All' a la derecha, que contienen los valores agregados de todas las categorías. Puede cambiar el nombre de la etiqueta de margen con margins_name. Esto equivale a la fila «Total general» de las tablas dinámicas de Excel.
table = pd.pivot_table(df, values='revenue', index='region',
columns='product', aggfunc='sum',
fill_value=0, margins=True, margins_name='Total')
print(table)
# product A B Total
# region
# East 510 150 660
# West 340 700 1040
# Total 850 850 1700Varios valores en pivot_table
El parámetro values puede ser una lista de nombres de columnas para agregar varias métricas a la vez. El resultado tiene un MultiIndex de columnas cuyo nivel externo es la columna de valores y cuyo nivel interno es la categoría. Esto permite crear una tabla resumen completa en una sola llamada, en lugar de crear y combinar varias tablas dinámicas independientes.
df['units'] = [10, 15, 8, 12, 14, 18]
table = pd.pivot_table(df,
values=['revenue', 'units'],
index='region',
columns='product',
aggfunc='sum')
print(table)
# Columns: (revenue, A), (revenue, B), (units, A), (units, B)
print(table.columns.tolist())Índice y columnas jerárquicos
Cuando pasa una lista a index o columns, la tabla dinámica tiene un MultiIndex en el eje correspondiente. Esto permite crear resúmenes más detallados; por ejemplo, desglosar los ingresos por región y trimestre en las filas y por producto en las columnas. Acceda a los subniveles con .loc y las tuplas de índices como de costumbre.
df['quarter'] = ['Q1', 'Q1', 'Q2', 'Q2', 'Q1', 'Q2']
table = pd.pivot_table(df, values='revenue',
index=['region', 'quarter'],
columns='product',
aggfunc='sum', fill_value=0)
print(table)
# product A B
# region quarter
# East Q1 510 0
# Q2 0 150
# West Q1 340 0
# Q2 0 700Aplanamiento del resultado
Después de crear una tabla dinámica, el índice corresponde a la columna de agrupación y el MultiIndex de columnas (cuando se utilizan varios valores) puede resultar difícil de manejar. Un patrón habitual de limpieza consiste en llamar a reset_index() para aplanar el índice de filas y, después, reducir el MultiIndex de columnas a un solo nivel uniendo los niveles con un guion bajo mediante una comprensión de listas.
table = pd.pivot_table(df, values=['revenue', 'units'],
index='region', columns='product', aggfunc='sum')
# Flatten MultiIndex columns
table.columns = ['_'.join(str(c) for c in col) for col in table.columns]
table = table.reset_index()
print(table.columns.tolist())
# ['region', 'revenue_A', 'revenue_B', 'units_A', 'units_B']pivot_table frente a groupby().agg()
Tanto pivot_table como groupby().agg() generan estadísticas resumidas. La diferencia está en la forma del resultado: groupby().agg() devuelve un DataFrame en formato largo, con una fila por cada combinación de grupos, mientras que pivot_table devuelve una tabla en formato ancho, en la que una dimensión se convierte en columnas. Para paneles y reportes, el formato ancho de las tablas dinámicas suele ser más legible; para posteriores análisis estadísticos o de aprendizaje automático, se prefiere el formato largo.
# Long format (groupby)
long = df.groupby(['region', 'product'])['revenue'].sum().reset_index()
print(long)
# region product revenue
# East A 510
# East B 150
# Wide format (pivot_table)
wide = pd.pivot_table(df, 'revenue', 'region', 'product', 'sum', fill_value=0)
print(wide)
# product A B
# region
# East 510 150Ordenación y estilo de la tabla dinámica
Una tabla dinámica es un DataFrame normal, por lo que puede ordenarla, calcular columnas derivadas y darle formato exactamente como a cualquier otro DataFrame de Pandas. Por ejemplo, puede ordenar en orden descendente por una columna de producto específica para clasificar las regiones según el rendimiento de ese producto, o añadir una columna de porcentajes dividiendo cada celda por el total de su fila.
table = pd.pivot_table(df, 'revenue', 'region', 'product', 'sum', fill_value=0)
# Sort by product A revenue descending
table_sorted = table.sort_values('A', ascending=False)
print(table_sorted)
# Add percentage of row total
table['A_pct'] = (table['A'] / table.sum(axis=1) * 100).round(1)
print(table)Uso práctico: tabla para un panel de ventas
Las tablas dinámicas son una herramienta fundamental para crear reportes de gestión y paneles. Un flujo de trabajo habitual consiste en cargar datos de transacciones sin procesar, crear una tabla dinámica con los meses como columnas y las categorías de productos como filas, añadir los totales de margen y, después, exportarla a Excel. Todo el proceso, desde los datos sin procesar hasta una tabla lista para presentar a la dirección, requiere solo unas pocas llamadas a Pandas.
# Simulated monthly product revenue pivot
result = pd.pivot_table(
df,
values='revenue',
index='product',
columns='region',
aggfunc='sum',
fill_value=0,
margins=True,
margins_name='Grand Total'
)
print(result)
# Export to Excel
# result.to_excel('sales_pivot.xlsx')Comprobación rápida
Compruebe cuánto ha entendido de pd.pivot_table en esta lección.
Resumen de la lección
En esta lección ha aprendido lo siguiente: pd.pivot_table() crea resúmenes mediante tabulación cruzada, con una dimensión como filas y otra como columnas; fill_value gestiona las celdas vacías y margins=True añade los totales; puede agregar varios valores a la vez; y las tablas dinámicas generan resultados en formato ancho, ideales para reportes. A continuación, exploraremos la operación inversa: melt(), que convierte datos en formato ancho de nuevo a formato largo.
Aprende Python con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 30
- Lecciones
- 120
Preguntas frecuentes
¿La lección «pivot_table: tablas de contingencia» es gratis?
Sí — el texto completo de «pivot_table: tablas de contingencia» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Pandas & NumPy Academy, actualiza a CoddyKit PRO. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.
¿Qué aprenderé en «pivot_table: tablas de contingencia»?
Cree tablas dinámicas al estilo de Excel con pd.pivot_table, estableciendo index, columns, values y aggfunc. Practicas Pandas & NumPy Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Pandas & NumPy Academy?
No se requiere experiencia previa. Pandas & NumPy Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «pivot_table: tablas de contingencia»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Pandas & NumPy Academy?
Sí. Cada lección de Pandas & NumPy Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- pivot_table: tablas de contingencia
- melt: de formato ancho a formato largo
- stack y unstack con MultiIndex
- crosstab para tablas de frecuencias