Explorar guías rápidas · PySpark

Tecnología: PySparkCategoría: Transformación de datosNivel: IntermedioActualizado

Funciones de ventana en PySpark

Usa las funciones de ventana de PySpark de forma segura para clasificar, seleccionar la fila más reciente, calcular totales acumulados, analizar con lag/lead y hacer cálculos por partición sin reducir la granularidad del DataFrame.

En esta página
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Importar Window y las funciones de Spark
  5. 2. Asignar un número de fila dentro de cada grupo
  6. 3. Reproducir ROW_NUMBER() de SQL
  7. 4. Conservar la fila más reciente por clave de negocio
  8. 5. Conservar las N primeras filas por grupo
  9. 6. Usar rank() cuando los empates comparten el mismo rango
  10. 7. Usar dense_rank() cuando los empates no deben crear huecos
  11. 8. Comparar row_number, rank y dense_rank
  12. 9. Obtener el valor de la fila anterior con lag()
  13. 10. Obtener el valor de la fila siguiente con lead()
  14. 11. Calcular el tiempo transcurrido desde el evento anterior
  15. 12. Detectar cambios de valor
  16. 13. Construir un total acumulado
  17. 14. Construir un recuento acumulado
  18. 15. Construir un máximo acumulado
  19. 16. Usar una ventana móvil basada en número de filas
  20. 17. Usar rangeBetween() para marcos basados en valores
  21. 18. Entender rowsBetween() frente a rangeBetween()
  22. 19. Calcular el total de la partición sin reducir filas
  23. 20. Calcular el porcentaje del total del grupo
  24. 21. Calcular la media de la partición
  25. 22. Comparar el valor de la fila con la media del grupo
  26. 23. Usar first_value() con una ventana ordenada
  27. 24. Usar last_value() con un marco explícito de toda la partición
  28. 25. Obtener el primer valor no nulo
  29. 26. Usar nth_value() cuando esté disponible y sea adecuado
  30. 27. Usar cume_dist() para la distribución acumulada
  31. 28. Usar percent_rank() para una clasificación relativa
  32. 29. Usar ntile() para asignar grupos
  33. 30. Construir rangos de fechas de vigencia con lead()
  34. 31. Crear límites de sesión a partir de los intervalos entre eventos
  35. 32. Asignar IDs de sesión con una suma acumulada
  36. 33. Deduplicar con row_number() antes de un MERGE
  37. 34. Evitar las ventanas globales salvo que sean realmente necesarias
  38. 35. Alinear las particiones con la entidad de negocio
  39. 36. Comprobar el skew de las particiones antes de ventanas grandes
  40. 37. No reemplazar a la ligera las claves de partición nulas por un único valor centinela global
  41. 38. Reutilizar la misma especificación de ventana
  42. 39. Inspeccionar el plan físico
  43. 40. Filtrar antes de una ventana grande cuando sea seguro
  44. Qué significa el resultado
  45. Qué revisar
  46. La fila más reciente cambia entre ejecuciones
  47. last_value() coincide inesperadamente con la fila actual
  48. El total acumulado da saltos inesperados
  49. La etapa de ventana tiene una tarea muy lenta
  50. La ventana provoca un ordenamiento/shuffle masivo
  51. La métrica móvil «de 7 días» es incorrecta
  52. Notas de producción
  53. Las funciones de ventana suelen requerir ordenamientos costosos
  54. El ordenamiento determinista importa
  55. Las particiones de ventana pueden consumir mucha memoria
  56. Filtrar antes de una ventana puede cambiar la semántica
  57. rangeBetween() requiere una semántica de ordenamiento cuidadosa
  58. Usa las funciones de ventana integradas antes que lógica personalizada en Python
  59. Errores comunes
  60. 1. Usar row_number() sin un ordenamiento completo
  61. 2. Usar rank() cuando se requieren exactamente N filas
  62. 3. Usar row_number() cuando deben conservarse todos los empates
  63. 4. Suponer que first() / last() tienen en cuenta el tiempo automáticamente
  64. 5. Confundir rowsBetween() con rangos de tiempo
  65. 6. Usar innecesariamente una ventana ordenada global
  66. 7. Ignorar el skew de las particiones
  67. 8. Eliminar historial por filtrado antes de calcular una ventana de toda la vida
  68. 9. Reemplazar todas las claves nulas por un único valor centinela
  69. 10. Usar ventanas cuando basta con groupBy()
  70. Siguiente paso
  71. Para profundizar

Problema

Necesitas calcular valores sobre filas relacionadas sin reducir el DataFrame a una fila por grupo.

Entre los casos de uso habituales en producción están:

  • conservar la fila más reciente por clave de negocio
  • clasificar productos dentro de cada categoría
  • calcular totales acumulados
  • comparar cada fila con el evento anterior o siguiente
  • calcular el tiempo transcurrido entre eventos
  • detectar cambios de estado
  • calcular métricas móviles
  • asignar números de fila deterministas
  • seleccionar las N primeras filas por grupo

Los principales riesgos son:

  • un ordenamiento incompleto
  • empates ambiguos
  • particiones de ventana enormes
  • ordenamientos globales innecesarios
  • usar una semántica de marco (frame) incorrecta
  • depender de first() / last() sin entender el ordenamiento
  • mezclar de forma incorrecta marcos basados en filas y en rangos de valores

El objetivo es hacer explícitos la partición, el ordenamiento y el marco.

Respuesta rápida

Para la fila más reciente por cliente:

from pyspark.sql import Window
from pyspark.sql import functions as F

w = (
    Window
    .partitionBy("customer_id")
    .orderBy(
        F.col("event_time").desc(),
        F.col("event_id").desc(),
    )
)

latest = (
    df
    .withColumn(
        "_row_number",
        F.row_number().over(w),
    )
    .filter(
        F.col("_row_number") == 1
    )
    .drop("_row_number")
)

Para un total acumulado:

w = (
    Window
    .partitionBy("customer_id")
    .orderBy("event_time")
    .rowsBetween(
        Window.unboundedPreceding,
        Window.currentRow,
    )
)

df = df.withColumn(
    "running_amount",
    F.sum("amount").over(w),
)

La regla clave es:

PARTITION BY
→ qué filas van juntas

ORDER BY
→ qué fila va primero

FRAME
→ qué filas ordenadas participan en el cálculo

Código / comandos

1. Importar Window y las funciones de Spark

from pyspark.sql import Window
from pyspark.sql import functions as F

Usa Window para definir la partición, el ordenamiento y los marcos.


2. Asignar un número de fila dentro de cada grupo

w = (
    Window
    .partitionBy("customer_id")
    .orderBy(
        F.col("event_time").asc()
    )
)

df = df.withColumn(
    "row_number",
    F.row_number().over(w),
)

Esto asigna a cada fila un número de secuencia único dentro de su partición.

Úsalo cuando los empates deban recibir igualmente números de fila distintos.


3. Reproducir ROW_NUMBER() de SQL

w = (
    Window
    .partitionBy("merchant_id")
    .orderBy(
        F.col("revenue").desc(),
        F.col("product_id").asc(),
    )
)

ranked = df.withColumn(
    "row_number",
    F.row_number().over(w),
)

La segunda columna de ordenamiento permite desempatar de forma determinista.

No dependas de un orden físico arbitrario de las filas.


4. Conservar la fila más reciente por clave de negocio

w = (
    Window
    .partitionBy("customer_id")
    .orderBy(
        F.col("updated_at").desc(),
        F.col("source_sequence").desc(),
    )
)

latest = (
    df
    .withColumn(
        "_rn",
        F.row_number().over(w),
    )
    .filter(F.col("_rn") == 1)
    .drop("_rn")
)

Este es el patrón preferido cuando importa qué fila se conserva.


5. Conservar las N primeras filas por grupo

w = (
    Window
    .partitionBy("category")
    .orderBy(
        F.col("revenue").desc(),
        F.col("product_id").asc(),
    )
)

top_3 = (
    df
    .withColumn(
        "_rn",
        F.row_number().over(w),
    )
    .filter(
        F.col("_rn") <= 3
    )
    .drop("_rn")
)

Esto conserva exactamente hasta N filas por partición.

Si todos los empates deben conservarse, usa rank() o dense_rank() en su lugar.


6. Usar rank() cuando los empates comparten el mismo rango

w = (
    Window
    .partitionBy("category")
    .orderBy(
        F.col("revenue").desc()
    )
)

df = df.withColumn(
    "rank",
    F.rank().over(w),
)

Valores de ejemplo:

100
100
90
80

producen los rangos:

1
1
3
4

7. Usar dense_rank() cuando los empates no deben crear huecos

df = df.withColumn(
    "dense_rank",
    F.dense_rank().over(w),
)

Para los mismos valores:

100
100
90
80

los rangos densos son:

1
1
2
3

Usa el método de clasificación que coincida con la definición de negocio.


8. Comparar row_number, rank y dense_rank

Usa:

row_number
→ cada fila recibe un número de secuencia único

rank
→ los empates comparten rango; quedan huecos

dense_rank
→ los empates comparten rango; sin huecos

No sustituyas una por otra sin comprobar la semántica de los empates.


9. Obtener el valor de la fila anterior con lag()

w = (
    Window
    .partitionBy("customer_id")
    .orderBy("event_time")
)

df = df.withColumn(
    "previous_status",
    F.lag(
        "status",
        1,
    ).over(w),
)

Úsala para:

  • transiciones de estado
  • el importe anterior
  • la marca de tiempo anterior
  • la detección de cambios

10. Obtener el valor de la fila siguiente con lead()

df = df.withColumn(
    "next_status",
    F.lead(
        "status",
        1,
    ).over(w),
)

Úsala para:

  • el análisis del evento siguiente
  • rangos de fechas de vigencia
  • comparaciones con el estado futuro

11. Calcular el tiempo transcurrido desde el evento anterior

w = (
    Window
    .partitionBy("customer_id")
    .orderBy("event_time")
)

df = (
    df
    .withColumn(
        "previous_event_time",
        F.lag("event_time").over(w),
    )
    .withColumn(
        "seconds_since_previous",
        F.col("event_time").cast("long")
        - F.col("previous_event_time").cast("long"),
    )
)

Esto es útil para:

  • la sesionización
  • el análisis de solicitudes repetidas
  • la latencia
  • la detección de intervalos entre eventos

Asegúrate de que el ordenamiento por marca de tiempo sea semánticamente correcto.


12. Detectar cambios de valor

w = (
    Window
    .partitionBy("customer_id")
    .orderBy("event_time")
)

df = (
    df
    .withColumn(
        "previous_status",
        F.lag("status").over(w),
    )
    .withColumn(
        "status_changed",
        F.when(
            F.col("previous_status").isNull(),
            F.lit(False),
        ).otherwise(
            ~F.col("status").eqNullSafe(
                F.col("previous_status")
            )
        ),
    )
)

Usa eqNullSafe() cuando importe la semántica de igualdad de los nulos.


13. Construir un total acumulado

w = (
    Window
    .partitionBy("customer_id")
    .orderBy("event_time")
    .rowsBetween(
        Window.unboundedPreceding,
        Window.currentRow,
    )
)

df = df.withColumn(
    "running_amount",
    F.sum("amount").over(w),
)

Esto incluye todas las filas anteriores de la partición hasta la fila actual.


14. Construir un recuento acumulado

df = df.withColumn(
    "running_count",
    F.count("*").over(w),
)

Útil para:

  • la secuencia de eventos
  • la actividad acumulada
  • contadores progresivos

15. Construir un máximo acumulado

df = df.withColumn(
    "running_max_amount",
    F.max("amount").over(w),
)

Esto da el mayor valor observado hasta el momento dentro de la partición ordenada.


16. Usar una ventana móvil basada en número de filas

La fila actual más las seis filas anteriores:

w = (
    Window
    .partitionBy("customer_id")
    .orderBy("event_time")
    .rowsBetween(
        -6,
        0,
    )
)

df = df.withColumn(
    "rolling_7_row_avg",
    F.avg("amount").over(w),
)

Esto significa:

7 filas

no:

7 días

No confundas las ventanas basadas en filas con las ventanas basadas en tiempo.


17. Usar rangeBetween() para marcos basados en valores

Supón que la columna de ordenamiento está en segundos epoch:

df = df.withColumn(
    "event_epoch",
    F.col("event_time").cast("long"),
)

Una ventana móvil de los últimos 7 días:

seconds_7_days = 7 * 24 * 60 * 60

w = (
    Window
    .partitionBy("customer_id")
    .orderBy("event_epoch")
    .rangeBetween(
        -seconds_7_days,
        0,
    )
)

df = df.withColumn(
    "rolling_7_day_amount",
    F.sum("amount").over(w),
)

Este marco se basa en el valor numérico de la columna de ordenamiento, no en el número de filas.

Úsalo con cuidado y documenta la unidad.


18. Entender rowsBetween() frente a rangeBetween()

Usa:

rowsBetween()
→ posiciones físicas relativas de las filas

rangeBetween()
→ valores relativos de la expresión ORDER BY

Ejemplo:

rowsBetween(-6, 0)

significa siete filas.

Ejemplo:

rangeBetween(-604800, 0)

sobre segundos epoch significa los siete días anteriores.

No son intercambiables.


19. Calcular el total de la partición sin reducir filas

w = (
    Window
    .partitionBy("merchant_id")
)

df = df.withColumn(
    "merchant_total",
    F.sum("amount").over(w),
)

A diferencia de groupBy(), esto mantiene la granularidad original de las filas.

Úsalo cuando cada fila necesite tanto:

  • el detalle a nivel de fila
  • una métrica a nivel de grupo

20. Calcular el porcentaje del total del grupo

w = (
    Window
    .partitionBy("merchant_id")
)

df = (
    df
    .withColumn(
        "merchant_total",
        F.sum("amount").over(w),
    )
    .withColumn(
        "pct_of_merchant",
        F.when(
            F.col("merchant_total") != 0,
            F.col("amount")
            / F.col("merchant_total"),
        ),
    )
)

Esto conserva cada fila de origen y añade su proporción del total de la partición.


21. Calcular la media de la partición

w = (
    Window
    .partitionBy("merchant_id")
)

df = df.withColumn(
    "merchant_avg_amount",
    F.avg("amount").over(w),
)

De nuevo, la granularidad original de las filas se mantiene intacta.


22. Comparar el valor de la fila con la media del grupo

df = (
    df
    .withColumn(
        "merchant_avg_amount",
        F.avg("amount").over(w),
    )
    .withColumn(
        "above_merchant_avg",
        F.col("amount")
        > F.col("merchant_avg_amount"),
    )
)

Esto es útil para comparaciones dentro del grupo sin una agregación y un join por separado.


23. Usar first_value() con una ventana ordenada

w = (
    Window
    .partitionBy("customer_id")
    .orderBy("event_time")
    .rowsBetween(
        Window.unboundedPreceding,
        Window.unboundedFollowing,
    )
)

df = df.withColumn(
    "first_status",
    F.first_value("status").over(w),
)

Usa un marco explícito cuando quieras el valor de toda la partición.


24. Usar last_value() con un marco explícito de toda la partición

df = df.withColumn(
    "last_status",
    F.last_value("status").over(w),
)

Sin un marco adecuado, last_value() puede devolver el valor de la fila actual en lugar del último valor de la partición.

Este es uno de los errores más comunes con las funciones de ventana.


25. Obtener el primer valor no nulo

df = df.withColumn(
    "first_non_null_status",
    F.first(
        "status",
        ignorenulls=True,
    ).over(w),
)

Indica explícitamente si deben ignorarse los nulos.


26. Usar nth_value() cuando esté disponible y sea adecuado

Ejemplo:

df = df.withColumn(
    "second_status",
    F.nth_value(
        "status",
        2,
    ).over(w),
)

Úsala cuando una posición fija en el orden tenga significado de negocio.

Si necesitas seleccionar filas, row_number() suele ser más claro.


27. Usar cume_dist() para la distribución acumulada

w = (
    Window
    .partitionBy("category")
    .orderBy(
        F.col("revenue").asc()
    )
)

df = df.withColumn(
    "cume_dist",
    F.cume_dist().over(w),
)

Esto muestra la posición relativa de cada fila dentro de la partición ordenada.

Útil para el análisis de distribución.


28. Usar percent_rank() para una clasificación relativa

df = df.withColumn(
    "percent_rank",
    F.percent_rank().over(w),
)

Esto devuelve un valor de 0 a 1 basado en la posición en la clasificación.

No lo confundas con un valor de percentil estadístico.


29. Usar ntile() para asignar grupos

w = (
    Window
    .partitionBy("region")
    .orderBy(
        F.col("revenue").desc()
    )
)

df = df.withColumn(
    "quartile",
    F.ntile(4).over(w),
)

Esto divide las filas ordenadas en grupos de tamaño aproximadamente igual.

No lo uses como sustituto de límites de percentil exactos cuando importen los umbrales basados en valores.


30. Construir rangos de fechas de vigencia con lead()

w = (
    Window
    .partitionBy("customer_id")
    .orderBy("effective_from")
)

history = df.withColumn(
    "effective_to",
    F.lead(
        "effective_from"
    ).over(w),
)

Esto es útil para registros versionados.

Decide si effective_to es:

exclusiva

o:

inclusiva

y mantén esa convención de forma coherente.


31. Crear límites de sesión a partir de los intervalos entre eventos

w = (
    Window
    .partitionBy("customer_id")
    .orderBy("event_time")
)

events = (
    df
    .withColumn(
        "previous_event_time",
        F.lag("event_time").over(w),
    )
    .withColumn(
        "gap_seconds",
        F.col("event_time").cast("long")
        - F.col("previous_event_time").cast("long"),
    )
)

Marca una nueva sesión:

events = events.withColumn(
    "new_session",
    F.when(
        F.col("previous_event_time").isNull()
        | (F.col("gap_seconds") > 1800),
        1,
    ).otherwise(0),
)

El umbral de 1.800 segundos es un ejemplo.

Usa un umbral definido por la regla real de negocio o de sesión.


32. Asignar IDs de sesión con una suma acumulada

session_window = (
    Window
    .partitionBy("customer_id")
    .orderBy("event_time")
    .rowsBetween(
        Window.unboundedPreceding,
        Window.currentRow,
    )
)

events = events.withColumn(
    "session_number",
    F.sum("new_session").over(
        session_window
    ),
)

Esto convierte los límites detectados en grupos de sesión secuenciales.


33. Deduplicar con row_number() antes de un MERGE

w = (
    Window
    .partitionBy("sale_id")
    .orderBy(
        F.col("updated_at").desc(),
        F.col("source_sequence").desc(),
    )
)

source_deduped = (
    source
    .withColumn(
        "_rn",
        F.row_number().over(w),
    )
    .filter(
        F.col("_rn") == 1
    )
    .drop("_rn")
)

Este es un patrón sólido para preparar entradas deterministas para un MERGE de Delta.


34. Evitar las ventanas globales salvo que sean realmente necesarias

Esto:

w = Window.orderBy("event_time")

no tiene clave de partición.

Todas las filas pertenecen a una única ventana lógica.

En DataFrames grandes, esto puede forzar un ordenamiento global muy costoso.

Usa ventanas globales solo cuando la pregunta de negocio sea realmente global.


35. Alinear las particiones con la entidad de negocio

Bien:

Window.partitionBy("customer_id")

para el historial de eventos por cliente.

Potencialmente costoso:

Window.partitionBy("country")

si un país contiene cientos de millones de filas y la lógica podría usar una clave de entidad más específica.

Elige una partición que coincida tanto con el significado de negocio como con la distribución real de los datos.


36. Comprobar el skew de las particiones antes de ventanas grandes

(
    df
    .groupBy("customer_id")
    .count()
    .orderBy(
        F.desc("count")
    )
    .show(
        50,
        truncate=False,
    )
)

Unas pocas particiones enormes pueden provocar tareas de ventana de larga duración.

Busca:

  • un cliente/tenant dominante
  • claves nulas o centinela
  • claves mal formadas
  • usuarios intensivos legítimos

37. No reemplazar a la ligera las claves de partición nulas por un único valor centinela global

Arriesgado:

df = df.fillna(
    {
        "customer_id": "UNKNOWN"
    }
)

Así, todas las filas con clave nula pueden acabar en una única partición de ventana enorme.

Trata por separado las claves no válidas o faltantes cuando sea posible.


38. Reutilizar la misma especificación de ventana

En lugar de reconstruir ventanas idénticas:

w = (
    Window
    .partitionBy("customer_id")
    .orderBy("event_time")
)

después:

df = (
    df
    .withColumn(
        "previous_amount",
        F.lag("amount").over(w),
    )
    .withColumn(
        "next_amount",
        F.lead("amount").over(w),
    )
)

Esto hace que el código sea más fácil de revisar.

Spark también puede combinar operaciones de ventana compatibles en el plan físico.


39. Inspeccionar el plan físico

result.explain("formatted")

Busca:

  • Window
  • Exchange
  • Sort

Las operaciones de ventana suelen requerir reparticionar por las claves de partición y ordenar por las claves de ordenamiento.

No supongas que una ventana es barata solo porque añade una columna.


40. Filtrar antes de una ventana grande cuando sea seguro

Prefiere:

recent = (
    df
    .filter(
        F.col("event_date") >= "2026-10-01"
    )
    .select(
        "customer_id",
        "event_time",
        "event_id",
        "amount",
    )
)

y después aplica la ventana.

Esto puede reducir el volumen de shuffle y de ordenamiento.

Pero no elimines por filtrado filas anteriores si la lógica de la ventana necesita el contexto histórico.

Por ejemplo, un total acumulado de toda la vida requiere el historial anterior.

Qué significa el resultado

Función Significado
row_number() Número secuencial único dentro de cada partición ordenada
rank() Los empates comparten rango; quedan huecos
dense_rank() Los empates comparten rango; sin huecos
lag() Valor de una fila anterior
lead() Valor de una fila siguiente
sum().over() Suma acumulada/por partición sin reducir la granularidad
avg().over() Media por partición/ventana sin reducir la granularidad
first_value() Primer valor del marco ordenado definido
last_value() Último valor del marco ordenado definido
ntile(n) Grupos de filas de tamaño aproximadamente igual
cume_dist() Posición en la distribución acumulada
percent_rank() Rango relativo de 0 a 1
rowsBetween() Marco basado en posiciones de fila
rangeBetween() Marco basado en un rango de valores del ORDER BY

La distinción fundamental es:

groupBy()
→ reduce las filas

función de ventana
→ conserva las filas y añade cálculos relativos al grupo

Qué revisar

La fila más reciente cambia entre ejecuciones

Probablemente tu ordenamiento está incompleto.

Añade columnas deterministas para desempatar, como:

  • el ID del evento
  • la secuencia de origen
  • la marca de tiempo de ingesta

last_value() coincide inesperadamente con la fila actual

Probablemente tu marco de ventana termina en la fila actual.

Usa un marco explícito de toda la partición cuando necesites el último valor de la partición.

El total acumulado da saltos inesperados

Comprueba:

  • filas de origen duplicadas
  • el ordenamiento
  • los nulos
  • si los empates crean una secuencia ambigua

La etapa de ventana tiene una tarea muy lenta

Inspecciona el skew de las claves de partición.

Un único cliente/tenant enorme puede dominar la ejecución.

La ventana provoca un ordenamiento/shuffle masivo

Comprueba:

  • la cardinalidad de la clave de partición
  • si el filtrado puede hacerse antes
  • si todas las columnas son necesarias
  • si la ventana puede acotarse

La métrica móvil «de 7 días» es incorrecta

Comprueba si usaste:

7 filas

en lugar de:

7 días

Usa el tipo de marco correcto.

Notas de producción

Las funciones de ventana suelen requerir ordenamientos costosos

La mayoría de las ventanas ordenadas obligan a Spark a:

particionar
→ hacer shuffle
→ ordenar
→ evaluar la ventana

Pueden ser costosas en conjuntos de datos grandes.

El ordenamiento determinista importa

Si los valores de orderBy() empatan y no existe una clave secundaria, las funciones a nivel de fila como row_number(), lag() y lead() pueden no tener un significado de negocio estable.

Añade una regla de desempate real.

Las particiones de ventana pueden consumir mucha memoria

Las particiones grandes requieren un manejo considerable de ordenamiento y estado.

Evita particionar millones de filas no relacionadas bajo una única clave nula o centinela.

Filtrar antes de una ventana puede cambiar la semántica

Por ejemplo:

total acumulado de toda la vida

requiere el historial completo.

Si primero filtras al último mes, calculas:

total acumulado del mes en curso

no el total de toda la vida.

Reduce la entrada solo cuando la definición de negocio lo permita.

rangeBetween() requiere una semántica de ordenamiento cuidadosa

El marco se basa en el valor de la expresión de ordenamiento.

Cuando uses valores epoch numéricos, documenta la unidad de forma explícita.

Usa las funciones de ventana integradas antes que lógica personalizada en Python

Las funciones integradas se ejecutan en el motor de ejecución optimizado de Spark.

No recopiles grupos ordenados en Python para calcular rangos, lag o totales acumulados.

Errores comunes

1. Usar row_number() sin un ordenamiento completo

Las filas empatadas pueden producir ganadores ambiguos.

2. Usar rank() cuando se requieren exactamente N filas

Los empates pueden hacer que califiquen más de N filas.

Usa row_number() para obtener exactamente N filas.

3. Usar row_number() cuando deben conservarse todos los empates

Usa rank() o dense_rank() en su lugar.

4. Suponer que first() / last() tienen en cuenta el tiempo automáticamente

La semántica del ordenamiento y del marco debe ser explícita.

5. Confundir rowsBetween() con rangos de tiempo

Un marco de filas cuenta filas, no tiempo transcurrido.

6. Usar innecesariamente una ventana ordenada global

Esto puede forzar un ordenamiento global muy costoso.

7. Ignorar el skew de las particiones

Una sola clave caliente puede dominar toda la etapa de ventana.

8. Eliminar historial por filtrado antes de calcular una ventana de toda la vida

Esto cambia silenciosamente la definición de la métrica.

9. Reemplazar todas las claves nulas por un único valor centinela

Esto puede crear una partición de ventana enorme.

10. Usar ventanas cuando basta con groupBy()

Si solo necesitas una fila por grupo, la agregación puede ser más sencilla y barata.

Siguiente paso

Usa el requisito para elegir la siguiente acción.

  • Necesitas la fila más reciente por clave → usa row_number() con un ordenamiento descendente determinista.
  • Necesitas exactamente las N primeras → usa row_number().
  • Necesitas todos los empates → usa rank() o dense_rank().
  • Necesitas el evento anterior/siguiente → usa lag() / lead().
  • Necesitas un total acumulado → usa un marco acumulativo ordenado.
  • Necesitas una ventana temporal móvil → usa un marco basado en rangos con unidades de tiempo explícitas.
  • Necesitas una única fila escalar por grupo → usa groupBy() en lugar de una ventana.
  • La ventana es lenta → inspecciona el skew de las particiones, el ordenamiento/shuffle y el tamaño de la entrada.
  • La lógica de la fila más reciente alimenta un MERGE de Delta → deduplica de forma determinista antes de escribir.
  • La ventana sigue siendo costosa tras reducir los datos → pasa a Referencia rápida de rendimiento de PySpark e inspecciona el plan y las etapas de Spark.

← Todas las guías rápidas