Explorar guías rápidas · Python
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
- Problema
- Respuesta rápida
- Código / comandos
- 1. Sumar valores por una columna
- 2. Agrupar por varias columnas
- 3. Calcular varias agregaciones a la vez
- 4. Contar las filas de cada grupo
- 5. Contar los valores no nulos de una columna concreta
- 6. Contar entidades de negocio únicas
- 7. Conservar de forma intencional las claves de agrupación nulas
- 8. Agrupar columnas categóricas sin expandir combinaciones no observadas
- 9. Calcular porcentajes dentro de un grupo
- 10. Agregar totales de grupo sin reducir filas
- 11. Filtrar según métricas a nivel de grupo
- 12. Agregar por fecha
- 13. Agregar por mes
- 14. Obtener la primera o la última fila de cada grupo después de ordenar
- 15. Obtener la fila con el valor máximo de cada grupo
- 16. Agregar con una función personalizada
- 17. Agregar con varias medidas de negocio
- 18. Ordenar la salida agregada de forma intencional
- 19. Evitar el doble conteo accidental antes de agregar
- 20. Comparar el número de filas antes y después de agregar
- Qué significa el resultado
- Qué revisar
- Los totales agregados son demasiado altos
- Desaparecieron algunos grupos esperados
- La salida contiene demasiados grupos
- Los conteos difieren de los totales esperados
- El promedio parece incorrecto
- La lógica de la fila más reciente devuelve valores mezclados
- Notas de producción
- GroupBy puede consumir mucha memoria
- Prefiere las agregaciones integradas
- Sé explícito con la granularidad de negocio
- La agrupación de nulos debe ser intencional
- La agregación puede ocultar problemas de calidad de datos en etapas anteriores
- Evita groupby().apply() como opción predeterminada
- La agrupación temporal requiere un manejo explícito de las zonas horarias
- Errores comunes
- 1. Usar count() cuando te refieres al número de filas
- 2. Usar size() cuando necesitas entidades distintas
- 3. Olvidar las claves de grupo nulas
- 4. Agregar después de un join de uno a muchos sin comprobar la granularidad
- 5. Promediar promedios
- 6. Usar max() para obtener la fila más reciente
- 7. Usar .apply() para agregaciones sencillas
- 8. Suponer que el orden de los grupos tiene significado
- Siguiente paso
- 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 necesitabanunique()
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.
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.