Python

GroupBy y agregaciones en pandas

Construye resúmenes fiables con pandas definiendo la granularidad, las reglas de ingresos, el tratamiento de nulos y los joins antes de agrupar datos reales de pedidos.

Por JaviPublicado 12 min de lecturaIntermedio

Filas de datos agrupadas en categorías y resumidas como barras agregadas

Una agregación solo es tan fiable como las filas que entran en ella. Antes de sumar ingresos, define qué estados cuentan, cómo se tratan los duplicados, qué significan los precios faltantes y si el enriquecimiento con productos conservó la granularidad de los pedidos.

Problema

Necesitas los ingresos mensuales de pedidos completados por categoría de producto, además del número de pedidos, las unidades y el valor medio por pedido. El archivo de pedidos contiene duplicados, campos numéricos faltantes y una referencia a un producto que no existe en el catálogo.

Datasets utilizados

Descarga el Orders Dataset y el Products Dataset:

Los pedidos aportan las transacciones; los productos, la categoría. Mantenerlos separados refleja un flujo habitual de hechos y dimensiones.

Código: prepara una entrada validada

Python
from pathlib import Path

import pandas as pd

data = Path("data")
orders = pd.read_csv(data / "orders.csv", parse_dates=["order_date"])
products = pd.read_csv(data / "products.csv")

orders["quantity"] = pd.to_numeric(orders["quantity"], errors="coerce")
orders["unit_price"] = pd.to_numeric(orders["unit_price"], errors="coerce")

clean_orders = orders.drop_duplicates().copy()
completed = clean_orders.loc[clean_orders["status"].eq("Completed")].copy()
completed["revenue"] = completed["quantity"] * completed["unit_price"]
completed["order_month"] = completed["order_date"].dt.to_period("M").astype(str)
Python15 líneasCelda de ejemplo de solo lectura. Nada en esta página ejecuta código.

Este ejemplo elimina las filas duplicadas exactas porque son duplicados didácticos conocidos. No elimina duplicados usando solo order_id sin examinar los conflictos. Además, deja como faltantes los ingresos desconocidos en lugar de reemplazarlos por cero.

Código: enriquece, valida y agrega

Python
enriched = completed.merge(
    products[["product_id", "category"]],
    on="product_id",
    how="left",
    validate="many_to_one",
    indicator=True,
)

unmatched = enriched.loc[enriched["_merge"].eq("left_only")]
print("Unmatched completed product rows:", len(unmatched))

summary = (
    enriched.loc[enriched["_merge"].eq("both")]
    .groupby(["order_month", "category"], as_index=False, dropna=False)
    .agg(
        order_count=("order_id", "nunique"),
        units=("quantity", "sum"),
        revenue=("revenue", "sum"),
        average_order_value=("revenue", "mean"),
    )
    .sort_values(["order_month", "revenue"], ascending=[True, False])
)

summary[["revenue", "average_order_value"]] = summary[
    ["revenue", "average_order_value"]
].round(2)
print(summary.head(10))
Python27 líneasCelda de ejemplo de solo lectura. Nada en esta página ejecuta código.

validate="many_to_one" garantiza que cada clave de producto aparezca como máximo una vez en el lado de productos. Sin esa validación, un producto duplicado por accidente podría multiplicar los pedidos e inflar los ingresos. El indicador del merge evita que las transacciones sin correspondencia desaparezcan sin que nadie lo note. Cómo combinar DataFrames con merge y join en pandas explica este patrón en detalle.

Resultado

La salida tiene una fila por mes y categoría:

order_month category order_count units revenue average_order_value
2025-01 Electronics … … … …
2025-01 Office … … … …
2025-01 Accessories … … … …

Los puntos suspensivos son intencionales: ejecuta el código con los archivos deterministas para obtener los valores completos. Un tutorial debe mostrar la forma y el significado del resultado sin copiar cientos de filas.

Explicación: granularidad y comportamiento de los nulos

La agregación con nombre hace explícitos los nombres de salida y las operaciones de origen. nunique cuenta identificadores de pedido, mientras que size contaría filas. Ambos difieren cuando hay duplicados o pedidos con varias líneas. Este dataset tiene una fila por registro de pedido, pero los sistemas de pedidos en producción suelen tener una granularidad de cabecera y otra de línea de pedido.

La mayoría de las funciones de agregación omiten los valores numéricos faltantes. Ese comportamiento puede ser cómodo y peligroso a la vez. Una suma de ingresos puede parecer plausible aunque a algunos pedidos completados les falte el precio o la cantidad. Mide la completitud junto con el resultado:

Python
quality = completed.agg(
    rows=("order_id", "size"),
    missing_quantity=("quantity", lambda values: values.isna().sum()),
    missing_price=("unit_price", lambda values: values.isna().sum()),
    missing_revenue=("revenue", lambda values: values.isna().sum()),
)
print(quality)
Python7 líneasCelda de ejemplo de solo lectura. Nada en esta página ejecuta código.

Con agrupadores categóricos, decide si deben aparecer las categorías no observadas. El comportamiento y los valores predeterminados de pandas pueden cambiar entre versiones, así que configura de forma deliberada las opciones pertinentes cuando importe que la forma de la salida sea estable.

Errores comunes

  • Sumar antes de eliminar los registros de entrada duplicados conocidos.
  • Agrupar precios de transacciones sin calcular antes cantidad por precio.
  • Usar el recuento de filas cuando la métrica requiere pedidos distintos.
  • Permitir que un join de muchos a muchos multiplique las medidas.
  • Descartar claves sin correspondencia mediante un inner join sin informar de ellas.
  • Tratar los nulos omitidos como si todos los valores de origen estuvieran completos.
  • Redondear las entradas antes de agregar en lugar de redondear después los valores de presentación.

Pruébalo tú mismo

Construye un resumen por estado que contenga el número de filas, los clientes distintos, las unidades, los ingresos y los ingresos faltantes. Después, calcula los ingresos por categoría de todos los pedidos no cancelados y compáralos con los ingresos de los pedidos completados. Explica por qué las transacciones devueltas y pendientes cambian la interpretación.

Por último, concilia el total general de la salida agrupada con las mismas filas filtradas antes de agrupar. Si los totales no coinciden, investiga el join, el tratamiento de los nulos y la granularidad en lugar de forzar que los números cuadren.

Notas para producción

Publica las definiciones de las agregaciones junto con la salida. “Ingresos” necesita una regla de estados, una suposición de moneda, un tratamiento de impuestos, una política de devoluciones y una fecha efectiva. Dos expresiones de groupby técnicamente correctas pueden responder a preguntas de negocio distintas. Los nombres de las métricas deben hacer visibles las distinciones importantes en lugar de depender de un contexto del notebook que luego desaparece.

La conciliación es más sólida cuando comprueba varias dimensiones: filas de origen, pedidos distintos, suma de cantidades, suma de ingresos, claves sin correspondencia y medidas faltantes. Guarda esos controles con la ejecución. Si la transformación se vuelve a ejecutar, las mismas entradas y el mismo código deben producir los mismos controles.

El uso de memoria puede crecer durante la agrupación porque pandas construye claves y resultados intermedios. Reduce las columnas antes de la operación, usa tipos categóricos adecuados para las dimensiones repetidas y prueba con una cardinalidad representativa. Es posible procesar por bloques (chunks) los agregados aditivos, pero los promedios requieren conservar el numerador y el denominador, y los recuentos de valores distintos son más difíciles de combinar con exactitud. Cuando los datos ya no caben con holgura o necesitan ejecución distribuida, conserva el contrato de la métrica y traslada el cálculo a un motor más adecuado.

Antes de publicar el resumen, verifica tanto su esquema como sus totales. El orden de las columnas, los tipos numéricos, la precisión y la ortografía de las categorías forman parte del contrato con el consumidor. Escribe una pequeña prueba con un subconjunto conocido cuyo resultado pueda calcularse a mano. Ese caso de prueba detecta cambios en el filtrado y en el tratamiento de los nulos con más claridad que una gran instantánea cuyos números los revisores no pueden explicar por sí mismos.

Etiquetas

  • Python
  • pandas
  • DataFrames
  • CSV
  • Conjunto de datos