Explorar guías rápidas · Python

Tecnología: PythonCategoría: Limpieza de datosNivel: IntermedioActualizado

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
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Ordenar por una columna
  5. 2. Ordenar por varias columnas
  6. 3. Hacer explícito el desempate
  7. 4. Conservar el orden original cuando importa cómo se ordenan los empates
  8. 5. Colocar los nulos al principio o al final
  9. 6. Ordenar con una transformación mediante key=
  10. 7. Encontrar filas duplicadas
  11. 8. Encontrar claves de negocio duplicadas
  12. 9. Contar la frecuencia de las claves duplicadas
  13. 10. Conservar el primer duplicado según el orden actual de las filas
  14. 11. Conservar el último duplicado según el orden actual de las filas
  15. 12. Eliminar todas las claves duplicadas
  16. 13. Conservar la fila más reciente por clave de negocio
  17. 14. Conservar la fila de mayor prioridad por clave
  18. 15. Conservar la fila con el valor máximo de cada grupo
  19. 16. Conservar las N primeras filas de cada grupo
  20. 17. Clasificar de forma global
  21. 18. Clasificar dentro de un grupo
  22. 19. Entender los métodos de ranking
  23. 20. Clasificar con un desempate determinista
  24. 21. Reproducir ROW_NUMBER() de SQL en pandas
  25. 22. Reproducir el comportamiento de RANK() de SQL
  26. 23. Reproducir el comportamiento de DENSE_RANK() de SQL
  27. 24. Conservar todas las filas empatadas en el primer puesto
  28. 25. Deduplicar después de un merge solo si se entiende la relación
  29. 26. Comparar el número de filas antes y después de deduplicar
  30. 27. Conservar la evidencia de los duplicados antes de eliminar filas
  31. 28. Validar la unicidad después de deduplicar
  32. 29. Comprobar si la deduplicación cambia un total importante
  33. 30. Usar nlargest() cuando solo necesitas las filas superiores
  34. Qué significa el resultado
  35. Qué revisar
  36. Sobreviven filas distintas entre ejecuciones o archivos de origen
  37. drop_duplicates() elimina más filas de las esperadas
  38. El número de duplicados aumenta después de un join
  39. Los resultados del ranking tienen huecos
  40. Demasiadas filas tienen la posición 1
  41. La fila «más reciente» es incorrecta
  42. Notas de producción
  43. La deduplicación es una regla de negocio
  44. No confíes en el orden de las filas de origen
  45. El desempate debe ser determinista
  46. Ordenar DataFrames grandes puede ser costoso
  47. La deduplicación puede ocultar defectos de calidad de datos
  48. Los nulos en las claves requieren una semántica explícita
  49. Las categorías ordenadas son útiles para la prioridad de negocio
  50. Errores comunes
  51. 1. Llamar a drop_duplicates() sin un subconjunto
  52. 2. Conservar first sin ordenar
  53. 3. Usar solo la marca de tiempo como criterio de desempate
  54. 4. Deduplicar después de un join incorrecto
  55. 5. Usar rank() cuando se necesitan números de fila únicos
  56. 6. Suponer que max() devuelve la fila completa más reciente o con el valor más alto
  57. 7. Ignorar cómo se ordenan los nulos
  58. 8. Eliminar duplicados sin medir el impacto
  59. Siguiente paso
  60. 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 filas
  • cumcount() 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.

Siguiente paso

Usa el patrón para decidir qué hacer después.

  • Necesitas la fila más reciente por clave → ordena por clave + marca de tiempo + criterio de desempate y conserva la primera fila.
  • Necesitas el top-N por grupo → ordena y usa head() por grupo, o un ranking si los empates importan.
  • Necesitas el comportamiento de ROW_NUMBER() de SQL → ordena de forma determinista y usa cumcount() + 1.
  • Necesitas el comportamiento de RANK() / DENSE_RANK() de SQL → usa rank(method="min") o rank(method="dense").
  • Aparecieron duplicados inesperados después de un merge → inspecciona la cardinalidad del join en lugar de deduplicar.
  • Eliminar duplicados cambia los totales → concilia las filas eliminadas antes de continuar.
  • El tratamiento de los empates es ambiguo → define un criterio de desempate de negocio determinista.
  • Ordenar consume demasiada memoria → reduce el conjunto de datos antes o lleva la operación a un motor de ejecución más potente.

← Todas las guías rápidas