Explorar guías rápidas · Python

Tecnología: PythonCategoría: Análisis de datosNivel: IntermedioActualizado

GroupBy y agregaciones en pandas

Agrupa datos de pandas por claves de negocio, calcula agregaciones fiables, conserva el contexto de cada fila con transform y evita los errores comunes con nulos, duplicados y lógicas de agregación mezcladas.

En esta página
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Sumar valores por una columna
  5. 2. Agrupar por varias columnas
  6. 3. Calcular varias agregaciones a la vez
  7. 4. Contar las filas de cada grupo
  8. 5. Contar los valores no nulos de una columna concreta
  9. 6. Contar entidades de negocio únicas
  10. 7. Conservar de forma intencional las claves de agrupación nulas
  11. 8. Agrupar columnas categóricas sin expandir combinaciones no observadas
  12. 9. Calcular porcentajes dentro de un grupo
  13. 10. Agregar totales de grupo sin reducir filas
  14. 11. Filtrar según métricas a nivel de grupo
  15. 12. Agregar por fecha
  16. 13. Agregar por mes
  17. 14. Obtener la primera o la última fila de cada grupo después de ordenar
  18. 15. Obtener la fila con el valor máximo de cada grupo
  19. 16. Agregar con una función personalizada
  20. 17. Agregar con varias medidas de negocio
  21. 18. Ordenar la salida agregada de forma intencional
  22. 19. Evitar el doble conteo accidental antes de agregar
  23. 20. Comparar el número de filas antes y después de agregar
  24. Qué significa el resultado
  25. Qué revisar
  26. Los totales agregados son demasiado altos
  27. Desaparecieron algunos grupos esperados
  28. La salida contiene demasiados grupos
  29. Los conteos difieren de los totales esperados
  30. El promedio parece incorrecto
  31. La lógica de la fila más reciente devuelve valores mezclados
  32. Notas de producción
  33. GroupBy puede consumir mucha memoria
  34. Prefiere las agregaciones integradas
  35. Sé explícito con la granularidad de negocio
  36. La agrupación de nulos debe ser intencional
  37. La agregación puede ocultar problemas de calidad de datos en etapas anteriores
  38. Evita groupby().apply() como opción predeterminada
  39. La agrupación temporal requiere un manejo explícito de las zonas horarias
  40. Errores comunes
  41. 1. Usar count() cuando te refieres al número de filas
  42. 2. Usar size() cuando necesitas entidades distintas
  43. 3. Olvidar las claves de grupo nulas
  44. 4. Agregar después de un join de uno a muchos sin comprobar la granularidad
  45. 5. Promediar promedios
  46. 6. Usar max() para obtener la fila más reciente
  47. 7. Usar .apply() para agregaciones sencillas
  48. 8. Suponer que el orden de los grupos tiene significado
  49. Siguiente paso
  50. Para profundizar

Problema

Necesitas resumir datos a nivel de fila en métricas de negocio como:

  • ingresos por cliente
  • pedidos por país
  • duración media por estado
  • totales diarios por producto
  • transacción máxima por cuenta
  • usuarios únicos por canal
  • porcentajes dentro de un grupo
  • valores a nivel de grupo conservando la granularidad original de las filas

El reto no consiste solo en llamar a groupby().

Necesitas asegurarte de que:

  • las claves de agrupación son correctas
  • las claves de grupo nulas se tratan de forma intencional
  • los duplicados no distorsionan los totales
  • las agregaciones coinciden con la granularidad de negocio
  • las columnas de salida siguen siendo comprensibles
  • las métricas a nivel de grupo se vuelven a unir a las filas de forma segura cuando hace falta

Respuesta rápida

Para una sola métrica:

summary = (
    df.groupby("customer_id", as_index=False)
    .agg(total_revenue=("revenue", "sum"))
)

Para varias métricas:

summary = (
    df.groupby(["country", "channel"], as_index=False)
    .agg(
        orders=("order_id", "nunique"),
        customers=("customer_id", "nunique"),
        revenue=("revenue", "sum"),
        avg_order_value=("revenue", "mean"),
    )
)

Para una métrica a nivel de grupo que debe permanecer en cada fila original:

df["customer_total_revenue"] = (
    df.groupby("customer_id")["revenue"]
    .transform("sum")
)

Usa agg() cuando quieras menos filas.

Usa transform() cuando quieras conservar el número original de filas.

Código / comandos

1. Sumar valores por una columna

summary = (
    df.groupby("customer_id", as_index=False)
    .agg(total_revenue=("revenue", "sum"))
)

Esto produce una fila por cada customer_id.

Usa agregaciones con nombre para que la columna de salida tenga un nombre significativo.


2. Agrupar por varias columnas

summary = (
    df.groupby(
        ["country", "channel"],
        as_index=False,
    )
    .agg(
        revenue=("revenue", "sum"),
        orders=("order_id", "nunique"),
    )
)

Ahora la granularidad de salida es:

country + channel

Asegúrate de que esa granularidad responde a la pregunta de negocio.


3. Calcular varias agregaciones a la vez

summary = (
    df.groupby("customer_id", as_index=False)
    .agg(
        total_revenue=("revenue", "sum"),
        avg_revenue=("revenue", "mean"),
        max_revenue=("revenue", "max"),
        order_count=("order_id", "nunique"),
        first_order=("order_date", "min"),
        last_order=("order_date", "max"),
    )
)

Las agregaciones con nombre suelen ser más claras que los patrones antiguos que crean columnas MultiIndex.


4. Contar las filas de cada grupo

Usa .size() cuando quieras el número de filas.

counts = (
    df.groupby("status", dropna=False)
    .size()
    .reset_index(name="row_count")
)

Esto cuenta las filas independientemente de los nulos en otras columnas.


5. Contar los valores no nulos de una columna concreta

Usa .count() cuando quieras los valores no nulos de una columna.

counts = (
    df.groupby("status", as_index=False)
    .agg(non_null_email_count=("email", "count"))
)

Importante:

size()  -> cuenta filas
count() -> cuenta valores no nulos

No los uses de forma intercambiable.


6. Contar entidades de negocio únicas

summary = (
    df.groupby("country", as_index=False)
    .agg(
        unique_customers=("customer_id", "nunique"),
        unique_orders=("order_id", "nunique"),
    )
)

Usa nunique() cuando las filas repetidas de una misma entidad deban contar una sola vez.


7. Conservar de forma intencional las claves de agrupación nulas

De forma predeterminada, pandas descarta las claves de grupo NA.

Para conservarlas:

summary = (
    df.groupby(
        "country",
        dropna=False,
        as_index=False,
    )
    .agg(revenue=("revenue", "sum"))
)

Esto es importante cuando los valores de dimensión faltantes tienen significado operativo.


8. Agrupar columnas categóricas sin expandir combinaciones no observadas

Al agrupar columnas categóricas, indica explícitamente si solo quieres las combinaciones observadas.

summary = (
    df.groupby(
        ["country", "channel"],
        observed=True,
        as_index=False,
    )
    .agg(revenue=("revenue", "sum"))
)

observed=True es útil cuando las columnas categóricas definen muchas combinaciones teóricamente posibles, pero solo algunas aparecen en los datos.


9. Calcular porcentajes dentro de un grupo

Ejemplo: la participación de cada producto en los ingresos de su categoría.

category_total = (
    df.groupby("category")["revenue"]
    .transform("sum")
)

df["category_revenue_pct"] = (
    df["revenue"] / category_total
)

Usa transform() porque el resultado debe alinearse fila a fila con el DataFrame original.


10. Agregar totales de grupo sin reducir filas

df["customer_total_revenue"] = (
    df.groupby("customer_id")["revenue"]
    .transform("sum")
)

df["customer_order_count"] = (
    df.groupby("customer_id")["order_id"]
    .transform("nunique")
)

Esto es útil para filtrar filas individuales o compararlas con los totales de su grupo.


11. Filtrar según métricas a nivel de grupo

Conservar los clientes cuyos ingresos totales superan 10.000:

customer_total = (
    df.groupby("customer_id")["revenue"]
    .transform("sum")
)

filtered = df.loc[
    customer_total > 10_000
]

Esto conserva las filas de detalle de los clientes que cumplen la condición.


12. Agregar por fecha

Asegúrate primero de que la columna de fecha esté convertida:

df["event_time"] = pd.to_datetime(
    df["event_time"],
    errors="coerce",
)

Después agrupa por fecha:

daily = (
    df.groupby(
        df["event_time"].dt.date,
        as_index=False,
    )
    .agg(revenue=("revenue", "sum"))
)

Para trabajar con series temporales, pd.Grouper suele ser más limpio:

daily = (
    df.groupby(
        pd.Grouper(
            key="event_time",
            freq="D",
        )
    )
    .agg(revenue=("revenue", "sum"))
    .reset_index()
)

13. Agregar por mes

monthly = (
    df.groupby(
        pd.Grouper(
            key="event_time",
            freq="MS",
        )
    )
    .agg(
        revenue=("revenue", "sum"),
        orders=("order_id", "nunique"),
    )
    .reset_index()
)

freq="MS" agrupa según los límites de inicio de mes.

Así se conserva una columna datetime real en lugar de convertirla en cadenas.


14. Obtener la primera o la última fila de cada grupo después de ordenar

Supongamos que quieres el registro más reciente de cada cliente.

latest = (
    df.sort_values(
        ["customer_id", "event_time"]
    )
    .groupby(
        "customer_id",
        as_index=False,
    )
    .tail(1)
)

Esto conserva la fila completa.

No uses:

groupby().agg("max")

con el sentido de «la fila más reciente» en varias columnas.

Eso puede combinar valores de filas distintas.


15. Obtener la fila con el valor máximo de cada grupo

idx = (
    df.groupby("customer_id")["revenue"]
    .idxmax()
)

highest_orders = df.loc[idx]

Esto conserva la fila real asociada al valor máximo.

Ten cuidado si la columna objetivo puede ser completamente nula dentro de un grupo.


16. Agregar con una función personalizada

def revenue_range(s: pd.Series) -> float:
    return s.max() - s.min()

summary = (
    df.groupby("customer_id", as_index=False)
    .agg(
        revenue_range=("revenue", revenue_range)
    )
)

Usa funciones de Python personalizadas solo cuando las agregaciones integradas no puedan expresar la lógica.

Las funciones integradas suelen ser más rápidas y más fáciles de mantener.


17. Agregar con varias medidas de negocio

summary = (
    df.groupby(
        ["merchant_id", "event_date"],
        as_index=False,
    )
    .agg(
        transactions=("transaction_id", "nunique"),
        customers=("customer_id", "nunique"),
        gross_amount=("amount", "sum"),
        avg_amount=("amount", "mean"),
        max_amount=("amount", "max"),
    )
)

Este patrón es habitual en cargas de trabajo de reporting e ingeniería de datos.

Define la granularidad de salida antes de escribir el código.


18. Ordenar la salida agregada de forma intencional

summary = (
    df.groupby("country", as_index=False)
    .agg(revenue=("revenue", "sum"))
    .sort_values(
        "revenue",
        ascending=False,
    )
)

No supongas que el orden de los grupos tiene significado de negocio.

Ordena explícitamente cuando la salida vaya a revisarse o publicarse.


19. Evitar el doble conteo accidental antes de agregar

Supongamos que la entrada contiene filas de pedido duplicadas por un join anterior.

Valida primero:

duplicate_orders = df.duplicated(
    subset=["order_id"],
    keep=False,
)

print(df.loc[duplicate_orders].head(20))

Si la granularidad prevista es una fila por pedido, agrega solo después de corregir la duplicación o de tratarla de forma intencional.

GroupBy no puede corregir automáticamente una granularidad de entrada incorrecta.


20. Comparar el número de filas antes y después de agregar

print("Input rows:", len(df))
print("Output rows:", len(summary))

Valida el número esperado de grupos:

expected_groups = (
    df[["country", "channel"]]
    .drop_duplicates()
    .shape[0]
)

print("Expected groups:", expected_groups)
print("Actual groups:", len(summary))

Si intervienen dropna=False o una agrupación categórica, asegúrate de que la lógica de validación use la misma semántica.

Qué significa el resultado

Patrón Significado
groupby("customer_id") Define un grupo por cada clave de cliente.
as_index=False Mantiene las claves de agrupación como columnas de salida normales.
agg() Reduce cada grupo a uno o varios valores de resumen.
transform() Devuelve valores derivados del grupo alineados con el número original de filas.
size() Cuenta las filas de cada grupo.
count() Cuenta los valores no nulos.
nunique() Cuenta de forma predeterminada los valores distintos no nulos.
dropna=False Mantiene las claves de agrupación NA como un grupo propio.
observed=True Con agrupadores categóricos, devuelve las combinaciones de categorías observadas en lugar de todas las posibles.
pd.Grouper() Agrupa datos de tipo datetime en intervalos de tiempo.

Qué revisar

Los totales agregados son demasiado altos

Causas comunes:

  • filas duplicadas
  • joins de uno a muchos en etapas anteriores
  • granularidad de negocio incorrecta
  • eventos repetidos
  • usar count() cuando se necesitaba nunique()

Valida la entrada antes de cambiar la agregación.

Desaparecieron algunos grupos esperados

Comprueba si las claves de agrupación contienen nulos.

De forma predeterminada, las claves de grupo nulas pueden quedar excluidas, a menos que uses:

dropna=False

La salida contiene demasiados grupos

Revisa:

  • diferencias de espacios en blanco
  • diferencias de mayúsculas y minúsculas
  • códigos incoherentes
  • precisión de las marcas de tiempo
  • columnas de agrupación de más

Ejemplo:

"US"
"us"
"US "

son claves de grupo distintas a menos que se normalicen.

Los conteos difieren de los totales esperados

Pregúntate qué estás contando:

  • ¿filas?
  • ¿valores no nulos?
  • ¿pedidos distintos?
  • ¿clientes distintos?

Elige size, count o nunique de forma deliberada.

El promedio parece incorrecto

Posibles causas:

  • filas duplicadas
  • nulos
  • diferencias de ponderación
  • granularidad incorrecta
  • promediar promedios ya agregados

Nunca promedies promedios de subgrupos, a menos que la ponderación sea matemáticamente correcta.

La lógica de la fila más reciente devuelve valores mezclados

Usar max() en varias columnas no reconstruye la fila más reciente.

En su lugar, ordena y selecciona la fila real.

Notas de producción

GroupBy puede consumir mucha memoria

Una cardinalidad de grupos elevada puede consumir una cantidad considerable de memoria.

El riesgo aumenta con:

  • muchas columnas de agrupación
  • claves de alta cardinalidad
  • muchas agregaciones
  • columnas con muchos objetos/cadenas
  • DataFrames intermedios grandes

Selecciona solo las columnas necesarias antes de agrupar.

Prefiere las agregaciones integradas

Estas suelen ser más rápidas:

"sum"
"mean"
"min"
"max"
"count"
"nunique"

que las funciones de Python arbitrarias.

Usa .apply() solo cuando la lógica del grupo realmente requiera un comportamiento personalizado.

Sé explícito con la granularidad de negocio

Antes de agrupar, escribe conceptualmente la granularidad de salida prevista:

una fila por cliente y por día

Así, tus claves de agrupación deberían representar exactamente esa granularidad.

La agrupación de nulos debe ser intencional

Descartar en silencio los valores de dimensión nulos puede distorsionar los totales.

Usa:

dropna=False

cuando las claves faltantes deban seguir visibles.

La agregación puede ocultar problemas de calidad de datos en etapas anteriores

Un total final puede parecer razonable incluso cuando existen filas duplicadas o claves sucias.

Valida:

  • el número de filas
  • la unicidad de las claves
  • las claves de negocio duplicadas
  • las claves nulas

antes de confiar en el resultado.

Evita groupby().apply() como opción predeterminada

apply() es potente, pero suele ser más lento y más difícil de razonar.

Prefiere:

  • agg()
  • transform()
  • filter()
  • operaciones vectorizadas

cuando puedan expresar la misma lógica.

La agrupación temporal requiere un manejo explícito de las zonas horarias

Si las marcas de tiempo provienen de varias zonas, normalízalas antes de agrupar por día o por mes.

De lo contrario, los registros cercanos a la medianoche pueden caer en el periodo de reporting equivocado.

Errores comunes

1. Usar count() cuando te refieres al número de filas

count() ignora los nulos.

Usa:

groupby(...).size()

para obtener el número real de filas.

2. Usar size() cuando necesitas entidades distintas

Usa nunique() cuando la métrica sea de clientes, pedidos, sesiones u otras entidades de negocio únicas.

3. Olvidar las claves de grupo nulas

El comportamiento predeterminado puede excluirlas.

Usa dropna=False cuando esas filas deban seguir visibles.

4. Agregar después de un join de uno a muchos sin comprobar la granularidad

Es una fuente habitual de totales inflados.

Valida primero los duplicados y la cardinalidad del join.

5. Promediar promedios

Ejemplo:

promedio(promedios por región)

no suele ser igual al promedio general.

Usa cálculos ponderados cuando los tamaños de los subgrupos difieran.

6. Usar max() para obtener la fila más reciente

max() trabaja columna por columna.

No conserva las relaciones dentro de cada fila.

Ordena y toma la fila real.

7. Usar .apply() para agregaciones sencillas

Suele ser más lento y menos claro que las operaciones integradas.

8. Suponer que el orden de los grupos tiene significado

Ordena explícitamente si el orden importa.

Siguiente paso

Usa el resultado de la agregación para decidir qué hacer después.

  • Necesitas volver a unir los totales de grupo a las filas → usa transform().
  • Los totales parecen inflados → inspecciona los duplicados y los joins anteriores.
  • Faltan grupos esperados → inspecciona las claves de agrupación nulas y la normalización.
  • Necesitas métricas de otro DataFrame → haz el merge después de definir la granularidad objetivo.
  • Necesitas resúmenes temporales → usa fechas convertidas a datetime y pd.Grouper.
  • Necesitas la fila más reciente o con el valor más alto por grupo → ordena/selecciona filas reales en lugar de agregar cada columna.
  • GroupBy es lento o consume mucha memoria → reduce columnas, baja la cardinalidad, filtra antes o lleva la carga de trabajo a un motor distribuido.
  • La salida es crítica para el negocio → agrega comprobaciones de conciliación que comparen los totales agrupados con los totales de origen.

← Todas las guías rápidas