Explorar guías rápidas · Python
Ordenar, clasificar y deduplicar datos
Ordena, clasifica y deduplica datos de pandas de forma segura definiendo un orden determinista, claves de negocio, el tratamiento de los empates y la fila exacta que debe conservarse.
En esta página
- Problema
- Respuesta rápida
- Código / comandos
- 1. Ordenar por una columna
- 2. Ordenar por varias columnas
- 3. Hacer explícito el desempate
- 4. Conservar el orden original cuando importa cómo se ordenan los empates
- 5. Colocar los nulos al principio o al final
- 6. Ordenar con una transformación mediante key=
- 7. Encontrar filas duplicadas
- 8. Encontrar claves de negocio duplicadas
- 9. Contar la frecuencia de las claves duplicadas
- 10. Conservar el primer duplicado según el orden actual de las filas
- 11. Conservar el último duplicado según el orden actual de las filas
- 12. Eliminar todas las claves duplicadas
- 13. Conservar la fila más reciente por clave de negocio
- 14. Conservar la fila de mayor prioridad por clave
- 15. Conservar la fila con el valor máximo de cada grupo
- 16. Conservar las N primeras filas de cada grupo
- 17. Clasificar de forma global
- 18. Clasificar dentro de un grupo
- 19. Entender los métodos de ranking
- 20. Clasificar con un desempate determinista
- 21. Reproducir ROW_NUMBER() de SQL en pandas
- 22. Reproducir el comportamiento de RANK() de SQL
- 23. Reproducir el comportamiento de DENSE_RANK() de SQL
- 24. Conservar todas las filas empatadas en el primer puesto
- 25. Deduplicar después de un merge solo si se entiende la relación
- 26. Comparar el número de filas antes y después de deduplicar
- 27. Conservar la evidencia de los duplicados antes de eliminar filas
- 28. Validar la unicidad después de deduplicar
- 29. Comprobar si la deduplicación cambia un total importante
- 30. Usar nlargest() cuando solo necesitas las filas superiores
- Qué significa el resultado
- Qué revisar
- Sobreviven filas distintas entre ejecuciones o archivos de origen
- drop_duplicates() elimina más filas de las esperadas
- El número de duplicados aumenta después de un join
- Los resultados del ranking tienen huecos
- Demasiadas filas tienen la posición 1
- La fila «más reciente» es incorrecta
- Notas de producción
- La deduplicación es una regla de negocio
- No confíes en el orden de las filas de origen
- El desempate debe ser determinista
- Ordenar DataFrames grandes puede ser costoso
- La deduplicación puede ocultar defectos de calidad de datos
- Los nulos en las claves requieren una semántica explícita
- Las categorías ordenadas son útiles para la prioridad de negocio
- Errores comunes
- 1. Llamar a drop_duplicates() sin un subconjunto
- 2. Conservar first sin ordenar
- 3. Usar solo la marca de tiempo como criterio de desempate
- 4. Deduplicar después de un join incorrecto
- 5. Usar rank() cuando se necesitan números de fila únicos
- 6. Suponer que max() devuelve la fila completa más reciente o con el valor más alto
- 7. Ignorar cómo se ordenan los nulos
- 8. Eliminar duplicados sin medir el impacto
- Siguiente paso
- Para profundizar
Problema
Necesitas ordenar registros, clasificar valores dentro de grupos o conservar una sola fila de un conjunto de duplicados.
Ejemplos típicos:
- conservar el registro más reciente por cliente
- clasificar productos por ingresos dentro de cada categoría
- conservar el evento de mayor prioridad por clave de negocio
- eliminar filas de origen duplicadas
- identificar claves duplicadas antes de cargar un destino
- crear una lógica determinista de «top 1 por grupo»
El riesgo no está en la sintaxis.
El riesgo es conservar en silencio la fila equivocada porque:
- el orden de clasificación está incompleto
- los empates no se tratan de forma intencional
- las claves duplicadas se malinterpretan
- el orden de las filas se trata como significativo cuando no lo es
- la deduplicación ocurre antes de definir la granularidad de negocio
Respuesta rápida
Para la fila más reciente por cliente:
latest = (
df.sort_values(
["customer_id", "event_time"],
ascending=[True, False],
)
.drop_duplicates(
subset=["customer_id"],
keep="first",
)
)
Para un ranking top-N dentro de un grupo:
df["revenue_rank"] = (
df.groupby("category")["revenue"]
.rank(
method="dense",
ascending=False,
)
)
Para investigar duplicados:
duplicates = df.loc[
df.duplicated(
subset=["customer_id", "event_time"],
keep=False,
)
]
La regla clave es:
Define la clave de negocio y el orden de desempate antes de llamar a
drop_duplicates().
Código / comandos
1. Ordenar por una columna
sorted_df = df.sort_values(
"revenue",
ascending=False,
)
Usa esto cuando un solo campo determina por completo el orden deseado.
2. Ordenar por varias columnas
sorted_df = df.sort_values(
["customer_id", "event_time"],
ascending=[True, False],
)
Esto significa:
- cliente en orden ascendente
- evento más reciente primero dentro de cada cliente
Usa varias columnas cuando el orden de negocio depende de más de un atributo.
3. Hacer explícito el desempate
Supón que dos eventos pueden tener la misma marca de tiempo.
Agrega otra clave determinista:
sorted_df = df.sort_values(
[
"customer_id",
"event_time",
"event_id",
],
ascending=[
True,
False,
False,
],
)
Después, deduplica:
latest = sorted_df.drop_duplicates(
subset=["customer_id"],
keep="first",
)
Sin un criterio de desempate, «el más reciente» puede seguir siendo ambiguo.
4. Conservar el orden original cuando importa cómo se ordenan los empates
pandas admite un algoritmo de ordenación estable.
sorted_df = df.sort_values(
"priority",
kind="stable",
)
Usa una ordenación estable cuando las claves de ordenación iguales deban conservar su orden anterior.
En ordenaciones por varias columnas, apóyate en la clave de ordenación completa en lugar de usar la estabilidad como sustituto de reglas de desempate explícitas.
5. Colocar los nulos al principio o al final
De forma predeterminada, los nulos se colocan al final.
sorted_df = df.sort_values(
"event_time",
na_position="last",
)
Para colocarlos al principio:
sorted_df = df.sort_values(
"event_time",
na_position="first",
)
Elige según la regla de negocio.
No dejes que la posición predeterminada de los nulos decida qué fila duplicada sobrevive.
6. Ordenar con una transformación mediante key=
Ordenación sin distinguir mayúsculas y minúsculas:
sorted_df = df.sort_values(
"customer_name",
key=lambda s: s.str.casefold(),
)
Esto cambia el comportamiento de la ordenación sin modificar de forma permanente la columna original.
7. Encontrar filas duplicadas
duplicate_rows = df.loc[
df.duplicated(
keep=False,
)
]
Esto encuentra filas completamente duplicadas en todas las columnas.
Úsalo solo cuando la duplicación de filas completas tenga sentido.
8. Encontrar claves de negocio duplicadas
key_cols = [
"customer_id",
"order_id",
]
duplicates = df.loc[
df.duplicated(
subset=key_cols,
keep=False,
)
].sort_values(key_cols)
Esto suele ser más útil que detectar duplicados de filas completas.
La clave debe coincidir con la granularidad de negocio prevista.
9. Contar la frecuencia de las claves duplicadas
duplicate_counts = (
df.groupby(
["customer_id", "order_id"],
dropna=False,
)
.size()
.reset_index(name="row_count")
.loc[lambda x: x["row_count"] > 1]
.sort_values(
"row_count",
ascending=False,
)
)
Úsalo para ver si la duplicación es aislada o sistemática.
10. Conservar el primer duplicado según el orden actual de las filas
deduped = df.drop_duplicates(
subset=["customer_id"],
keep="first",
)
Esto solo es seguro si el orden actual de las filas ya se ha vuelto significativo.
No lo uses sobre un orden de ingesta arbitrario.
11. Conservar el último duplicado según el orden actual de las filas
deduped = df.drop_duplicates(
subset=["customer_id"],
keep="last",
)
De nuevo, esto depende por completo del orden existente de las filas.
Normalmente, ordena primero.
12. Eliminar todas las claves duplicadas
unique_only = df.loc[
~df.duplicated(
subset=["customer_id"],
keep=False,
)
]
Esto conserva solo las claves que aparecen exactamente una vez.
Úsalo para aislar excepciones o para controles de calidad estrictos.
No es lo mismo que «conservar una fila por clave».
13. Conservar la fila más reciente por clave de negocio
latest = (
df.sort_values(
["customer_id", "event_time"],
ascending=[True, False],
)
.drop_duplicates(
subset=["customer_id"],
keep="first",
)
)
Es uno de los patrones de deduplicación más comunes en producción.
Agrega un criterio de desempate determinista si las marcas de tiempo pueden repetirse.
14. Conservar la fila de mayor prioridad por clave
Supón que la prioridad es:
critical > high > medium > low
Define una categoría ordenada:
from pandas.api.types import CategoricalDtype
priority_type = CategoricalDtype(
categories=[
"low",
"medium",
"high",
"critical",
],
ordered=True,
)
df["priority"] = (
df["priority"]
.astype(priority_type)
)
Después, ordena y deduplica:
best = (
df.sort_values(
["customer_id", "priority"],
ascending=[True, False],
)
.drop_duplicates(
subset=["customer_id"],
keep="first",
)
)
Esto es más seguro que una ordenación alfabética.
15. Conservar la fila con el valor máximo de cada grupo
idx = (
df.groupby("customer_id")["revenue"]
.idxmax()
)
top_rows = df.loc[idx]
Esto conserva la fila real que contiene el valor máximo.
Úsalo cuando un único campo numérico decide la fila ganadora.
Ten cuidado cuando un grupo solo tenga valores nulos en la columna objetivo.
16. Conservar las N primeras filas de cada grupo
Ordena primero:
top_3 = (
df.sort_values(
["category", "revenue"],
ascending=[True, False],
)
.groupby(
"category",
group_keys=False,
)
.head(3)
)
Esto devuelve hasta tres filas por categoría.
Si hay que conservar todos los empates, suele ser mejor usar un ranking.
17. Clasificar de forma global
df["revenue_rank"] = (
df["revenue"]
.rank(
method="dense",
ascending=False,
)
)
Los ingresos más altos obtienen el número de posición más bajo.
18. Clasificar dentro de un grupo
df["category_rank"] = (
df.groupby("category")["revenue"]
.rank(
method="dense",
ascending=False,
)
)
Úsalo para:
- la posición de los productos por categoría
- la posición de los comercios por región
- la posición de los clientes por segmento
19. Entender los métodos de ranking
Valores de ejemplo:
100
100
90
80
method="min":
1
1
3
4
method="dense":
1
1
2
3
method="first":
1
2
3
4
method="average":
1.5
1.5
3
4
Elige según el significado de negocio de los empates.
20. Clasificar con un desempate determinista
Si los empates no deben compartir posición, ordena primero de forma explícita.
ranked = df.sort_values(
[
"category",
"revenue",
"product_id",
],
ascending=[
True,
False,
True,
],
).copy()
ranked["row_number"] = (
ranked.groupby("category")
.cumcount()
.add(1)
)
Esto se comporta más como ROW_NUMBER() de SQL que como rank().
Úsalo cuando cada fila necesite un número de secuencia único.
21. Reproducir ROW_NUMBER() de SQL en pandas
ranked = df.sort_values(
[
"customer_id",
"event_time",
"event_id",
],
ascending=[
True,
False,
False,
],
).copy()
ranked["row_number"] = (
ranked.groupby("customer_id")
.cumcount()
.add(1)
)
Después:
latest = ranked.loc[
ranked["row_number"] == 1
]
Esto hace explícita y fácil de depurar la lógica de la fila ganadora.
22. Reproducir el comportamiento de RANK() de SQL
df["rank"] = (
df.groupby("category")["revenue"]
.rank(
method="min",
ascending=False,
)
)
Los empates reciben la misma posición y generan huecos a continuación.
23. Reproducir el comportamiento de DENSE_RANK() de SQL
df["dense_rank"] = (
df.groupby("category")["revenue"]
.rank(
method="dense",
ascending=False,
)
)
Los empates comparten posición, pero no hay huecos en el ranking.
24. Conservar todas las filas empatadas en el primer puesto
df["rank"] = (
df.groupby("category")["revenue"]
.rank(
method="min",
ascending=False,
)
)
leaders = df.loc[
df["rank"] == 1
]
Úsalo cuando los empates sean legítimos y deban conservarse todos los ganadores.
25. Deduplicar después de un merge solo si se entiende la relación
Patrón incorrecto:
result = (
left.merge(
right,
on="customer_id",
how="left",
)
.drop_duplicates()
)
Esto puede ocultar un join de uno a muchos incorrecto.
En su lugar, valida la relación antes de hacer el merge:
result = left.merge(
right,
on="customer_id",
how="left",
validate="many_to_one",
)
Corrige el problema del join en lugar de deduplicar el síntoma.
26. Comparar el número de filas antes y después de deduplicar
before = len(df)
deduped = df.drop_duplicates(
subset=["customer_id", "order_id"],
)
after = len(deduped)
print("Rows before:", before)
print("Rows after:", after)
print("Rows removed:", before - after)
Ten siempre claro cuántas filas eliminó tu regla.
27. Conservar la evidencia de los duplicados antes de eliminar filas
key_cols = [
"customer_id",
"order_id",
]
duplicates = df.loc[
df.duplicated(
subset=key_cols,
keep=False,
)
].copy()
Después, deduplica por separado:
deduped = (
df.sort_values(
key_cols + ["event_time"],
ascending=[True, True, False],
)
.drop_duplicates(
subset=key_cols,
keep="first",
)
)
Así la evidencia queda disponible para el diagnóstico.
28. Validar la unicidad después de deduplicar
key_cols = [
"customer_id",
"order_id",
]
assert not deduped.duplicated(
subset=key_cols
).any()
En código de producción, puede ser preferible una validación estructurada en lugar de assert, sobre todo si importan los ajustes de optimización de Python o el manejo de errores del pipeline.
29. Comprobar si la deduplicación cambia un total importante
before_total = df["amount"].sum()
deduped = df.drop_duplicates(
subset=["order_id"],
keep="first",
)
after_total = deduped["amount"].sum()
print("Before:", before_total)
print("After:", after_total)
Un total modificado puede ser esperable.
Lo importante es entender por qué.
30. Usar nlargest() cuando solo necesitas las filas superiores
top_10 = df.nlargest(
10,
"revenue",
)
Para los más pequeños:
bottom_10 = df.nsmallest(
10,
"revenue",
)
Suelen ser más claros que ordenar todo el DataFrame cuando solo se necesita un pequeño subconjunto de valores superiores o inferiores.
Qué significa el resultado
| Operación | Significado |
|---|---|
sort_values() |
Ordena las filas por una o varias columnas. |
drop_duplicates() |
Elimina filas repetidas o combinaciones de claves repetidas según el orden actual. |
duplicated() |
Marca filas/claves repetidas sin eliminarlas. |
rank() |
Genera valores numéricos de posición con un tratamiento de empates configurable. |
cumcount() |
Genera una secuencia que empieza en cero dentro de cada grupo. |
idxmax() |
Devuelve la etiqueta de índice del valor máximo por grupo/Series. |
head(n) después de una ordenación por grupos |
Conserva las N primeras filas ordenadas de cada grupo. |
nlargest() |
Selecciona los valores superiores sin requerir un patrón explícito de ordenación completa. |
La distinción clave es:
posición != número de fila
Con empates:
rank()puede asignar la misma posición a varias filascumcount()después de una ordenación determinista da a cada fila una posición única
Qué revisar
Sobreviven filas distintas entre ejecuciones o archivos de origen
Probablemente tu orden de deduplicación está incompleto.
Agrega columnas de desempate deterministas.
drop_duplicates() elimina más filas de las esperadas
Comprueba si el subconjunto representa la clave de negocio real.
Quizá estés deduplicando con una granularidad demasiado amplia.
El número de duplicados aumenta después de un join
El join puede haber introducido una multiplicación de uno a muchos o de muchos a muchos.
No lo corrijas con drop_duplicates() hasta entender la relación.
Los resultados del ranking tienen huecos
Es lo esperado con métodos de ranking como:
method="min"
Usa dense si necesitas posiciones sin huecos.
Demasiadas filas tienen la posición 1
Hay empates.
Decide si vas a:
- conservar todos los empates
- usar un criterio de desempate
- usar la semántica de número de fila
La fila «más reciente» es incorrecta
Revisa:
- el dtype de la marca de tiempo
- el manejo de las zonas horarias
- la posición de los nulos
- los empates de marcas de tiempo
- la dirección de la ordenación
Notas de producción
La deduplicación es una regla de negocio
No existe una definición universal de duplicado.
Entre las granularidades posibles están:
una fila por pedido
una fila por cliente y por día
una fila por ID de evento
una fila por comercio + sitio + fecha
Define primero la granularidad.
No confíes en el orden de las filas de origen
El orden de un CSV, de la respuesta de una API, del resultado de una base de datos o de la ingesta puede cambiar.
Si importa qué fila sobrevive, ordena de forma explícita.
El desempate debe ser determinista
Si dos filas tienen la misma marca de tiempo principal o la misma puntuación, usa otro campo de negocio estable, como:
- número de secuencia
- ID de evento
- versión
- marca de tiempo de ingesta
- prioridad de la fuente
Evita resolver los empates de forma arbitraria.
Ordenar DataFrames grandes puede ser costoso
Una ordenación completa suele ser más costosa que un filtrado simple.
Con datos grandes:
- filtra primero
- selecciona solo las columnas necesarias
- evita ordenaciones repetidas
- usa
nlargest()/nsmallest()cuando corresponda - lleva el ranking/la deduplicación a SQL/Spark cuando los datos superen unos límites de memoria razonables
La deduplicación puede ocultar defectos de calidad de datos
No trates la deduplicación como una limpieza predeterminada.
Determina primero si los duplicados son:
- eventos repetidos válidos
- reintentos de la fuente
- archivos reprocesados
- joins incorrectos
- defectos del sistema de origen
- filas versionadas intencionalmente
Los nulos en las claves requieren una semántica explícita
pandas puede considerar duplicadas dos filas con componentes de clave nulos, según los valores del subconjunto.
Decide si las filas con claves faltantes son siquiera candidatas a la deduplicación.
Las categorías ordenadas son útiles para la prioridad de negocio
La ordenación alfabética rara vez representa la prioridad real.
Define el orden de las categorías de forma explícita cuando el negocio tiene etiquetas jerarquizadas.
Errores comunes
1. Llamar a drop_duplicates() sin un subconjunto
Esto deduplica filas completas, lo que puede no coincidir con la clave de negocio.
2. Conservar first sin ordenar
first significa la primera según el orden actual de las filas, no la más antigua ni la más reciente en el tiempo.
3. Usar solo la marca de tiempo como criterio de desempate
Las marcas de tiempo pueden repetirse.
Agrega otra columna determinista.
4. Deduplicar después de un join incorrecto
Esto puede ocultar el verdadero problema de cardinalidad y descartar filas válidas.
Corrige primero la relación del merge.
5. Usar rank() cuando se necesitan números de fila únicos
Los empates pueden compartir la misma posición.
Usa groupby().cumcount() + 1 tras ordenar para obtener un comportamiento de número de fila.
6. Suponer que max() devuelve la fila completa más reciente o con el valor más alto
Agregar cada columna de forma independiente puede combinar valores de filas distintas.
Selecciona la fila ganadora real.
7. Ignorar cómo se ordenan los nulos
Los nulos pueden acabar inesperadamente como la fila conservada o descartada si el orden de clasificación no es intencional.
8. Eliminar duplicados sin medir el impacto
Informa siempre de las filas eliminadas y valida los totales o conteos importantes.
¿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.