Pandas & NumPy Academy · Lección

pivot_table: tablas de contingencia

Cree tablas dinámicas al estilo de Excel con pd.pivot_table, estableciendo index, columns, values y aggfunc.

Lección 1 de 413 pasos

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  700

Elecció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 NaN

Adició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   1700

Varios 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  700

Aplanamiento 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  150

Ordenació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.

Gratis para empezar

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

  1. pivot_table: tablas de contingencia
  2. melt: de formato ancho a formato largo
  3. stack y unstack con MultiIndex
  4. crosstab para tablas de frecuencias
← Volver a Pandas & NumPy Academy