Explorar guías rápidas · PySpark

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

Seleccionar y filtrar DataFrames

Selecciona, proyecta, filtra y valida DataFrames de PySpark de forma eficiente evitando columnas ambiguas, errores en la lógica de nulos, lecturas innecesarias y el filtrado en el driver.

En esta página
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Selecciona columnas concretas
  5. 2. Selecciona con alias
  6. 3. Añade o reemplaza una columna con withColumn
  7. 4. Selecciona todas las columnas existentes más una expresión
  8. 5. Elimina columnas de forma explícita
  9. 6. Filtra con una condición
  10. 7. Filtra con varias condiciones
  11. 8. No uses and / or de Python
  12. 9. Filtra los nulos
  13. 10. Entiende la lógica de tres valores de los nulos
  14. 11. Filtra por una lista con isin
  15. 12. Excluye valores
  16. 13. Filtra rangos numéricos
  17. 14. Filtra cadenas con contains
  18. 15. Filtra con startswith y endswith
  19. 16. Filtra con like
  20. 17. Filtra con expresiones regulares
  21. 18. Filtra fechas con límites explícitos
  22. 19. Convierte el tipo antes de comparar fechas cuando el origen es texto
  23. 20. Filtra marcas de tiempo de forma segura
  24. 21. Filtra con sintaxis de expresiones SQL
  25. 22. Construye expresiones de filtro dinámicas de forma segura
  26. 23. Filtra antes de un join
  27. 24. Selecciona solo las columnas necesarias antes de un join
  28. 25. Evita columnas ambiguas después de los joins
  29. 26. Usa una lista de claves de join cuando los nombres coinciden
  30. 27. Usa left semi joins para filtrar por existencia
  31. 28. Usa left anti joins para detectar referencias faltantes
  32. 29. Evita filtrar recopilando claves en Python
  33. 30. Evita el filtrado fila a fila en Python
  34. 31. Da preferencia a las funciones integradas frente a filtros con UDF de Python
  35. 32. Comprueba si los filtros llegaron al plan físico
  36. 33. Inspecciona los filtros de partición de Parquet/Delta en el plan
  37. 34. Evita envolver innecesariamente las columnas de partición
  38. 35. Usa limit() solo para una inspección acotada
  39. 36. Usa sample() para una inspección aproximada
  40. 37. Comprueba el número de filas antes y después de un filtro importante
  41. 38. Agrega los diagnósticos del filtro en una sola pasada
  42. 39. Valida resultados de filtro inesperados
  43. 40. Normaliza una sola vez la lógica de cadenas repetida
  44. Qué significa el resultado
  45. Qué revisar
  46. El join es costoso aunque el resultado sea pequeño
  47. El filtro devuelve inesperadamente pocas filas
  48. El filtro devuelve cero filas después de un cambio de esquema
  49. El plan físico sigue leyendo una gran cantidad de datos
  50. La memoria del driver crece durante el filtrado
  51. La misma limpieza de cadenas aparece en muchos filtros
  52. Notas de producción
  53. Las transformaciones de Spark son lazy
  54. El pushdown depende del origen
  55. La semántica de los nulos es similar a la de SQL
  56. Las listas isin() grandes son una señal de alerta
  57. El ancho de las columnas importa
  58. El orden de los filtros suele gestionarlo el optimizador
  59. Las funciones definidas por el usuario costosas pueden bloquear la optimización
  60. Errores comunes
  61. 1. Usar and / or de Python
  62. 2. Olvidar los paréntesis alrededor de las condiciones
  63. 3. Usar == None
  64. 4. Suponer que != value conserva los nulos
  65. 5. Recopilar claves de referencia en Python
  66. 6. Seleccionar * en todo el pipeline
  67. 7. Filtrar después del join costoso
  68. 8. Usar expresiones regulares para una lógica simple de prefijo o sufijo
  69. 9. Suponer que todos los filtros se empujan hasta el origen
  70. 10. Usar limit() como prueba de que los datos son correctos
  71. Siguiente paso
  72. Para profundizar

Problema

Necesitas reducir un DataFrame de PySpark a las filas y columnas que requiere la siguiente transformación.

La sintaxis es sencilla, pero los errores en producción suelen deberse a:

  • arrastrar columnas innecesarias a través de joins costosos
  • usar la lógica booleana de Python en lugar de expresiones de columna de Spark
  • filtrar los nulos de forma incorrecta
  • comparar cadenas, fechas o marcas de tiempo con la semántica equivocada
  • crear nombres de columna ambiguos después de los joins
  • usar collect() o bucles de Python para filtrar datos distribuidos
  • aplicar funciones costosas antes de reducir el conjunto de datos
  • suponer que un filtro siempre se empuja hasta el origen

El objetivo es que la reducción de filas y columnas sea explícita, eficiente y fácil de razonar.

Respuesta rápida

Selecciona solo las columnas necesarias:

from pyspark.sql import functions as F

sales = (
    spark.table("sales")
    .select(
        "sale_id",
        "merchant_id",
        "sale_date",
        "amount",
    )
)

Filtra con expresiones de Spark:

filtered = sales.filter(
    (F.col("sale_date") >= F.lit("2026-10-01"))
    & (F.col("amount") > 0)
)

Para un filtrado seguro ante nulos:

filtered = sales.filter(
    F.col("merchant_id").isNotNull()
)

En cargas de trabajo de producción, reduce filas y columnas antes de los joins grandes, las agregaciones o las operaciones en Python.

Código / comandos

1. Selecciona columnas concretas

df = df.select(
    "sale_id",
    "merchant_id",
    "amount",
)

Hazlo en lugar de arrastrar todas las columnas del origen por todo el pipeline.

La poda de columnas puede reducir:

  • la E/S
  • la serialización
  • el ancho del shuffle
  • el uso de memoria

2. Selecciona con alias

df = df.select(
    F.col("sale_id"),
    F.col("merchant_id"),
    F.col("amount").alias("sale_amount"),
)

Usa alias para que el significado en las etapas posteriores sea explícito y para evitar colisiones después de los joins.


3. Añade o reemplaza una columna con withColumn

df = df.withColumn(
    "net_amount",
    F.col("amount") - F.col("discount"),
)

Usa withColumn() para derivaciones puntuales.

Si vas a crear muchas columnas, considera un único select() con todas las expresiones para mejorar la legibilidad.


4. Selecciona todas las columnas existentes más una expresión

df = df.select(
    "*",
    (
        F.col("amount")
        - F.col("discount")
    ).alias("net_amount"),
)

Úsalo con moderación.

select("*") es cómodo, pero puede conservar más datos de los que realmente necesita la carga de trabajo posterior.


5. Elimina columnas de forma explícita

df = df.drop(
    "_raw_payload",
    "_debug_column",
)

Usa drop() cuando una columna temporal ya no sea necesaria.

En pipelines de producción con muchas columnas, da preferencia a una selección positiva explícita siempre que sea posible, porque deja más claro el contrato de esquema.


6. Filtra con una condición

filtered = df.filter(
    F.col("amount") > 100
)

Equivalente:

filtered = df.where(
    F.col("amount") > 100
)

filter() y where() son alias.

Usa el que resulte más claro para el equipo.


7. Filtra con varias condiciones

filtered = df.filter(
    (F.col("status") == "active")
    & (F.col("amount") > 100)
)

Usa:

  • & para AND
  • | para OR
  • ~ para NOT

Encierra cada comparación entre paréntesis.


8. No uses and / or de Python

Incorrecto:

df.filter(
    (F.col("amount") > 100)
    and (F.col("status") == "active")
)

Correcto:

df.filter(
    (F.col("amount") > 100)
    & (F.col("status") == "active")
)

Las expresiones de Spark construyen un plan de ejecución distribuido.

and / or de Python no operan elemento a elemento sobre columnas de Spark.


9. Filtra los nulos

missing = df.filter(
    F.col("merchant_id").isNull()
)

No nulos:

valid = df.filter(
    F.col("merchant_id").isNotNull()
)

No escribas:

F.col("merchant_id") == None

Usa las funciones explícitas para nulos.


10. Entiende la lógica de tres valores de los nulos

Este filtro:

df.filter(
    F.col("status") != "closed"
)

no conserva las filas con status nulo, porque las comparaciones con null se evalúan como desconocidas.

Si los nulos también deben conservarse:

df.filter(
    (F.col("status") != "closed")
    | F.col("status").isNull()
)

Haz siempre que la semántica de los nulos sea deliberada.


11. Filtra por una lista con isin

filtered = df.filter(
    F.col("country").isin(
        "US",
        "CA",
        "ES",
    )
)

Para una lista de Python:

allowed = [
    "US",
    "CA",
    "ES",
]

filtered = df.filter(
    F.col("country").isin(allowed)
)

Úsalo con listas de búsqueda pequeñas en memoria.

Para conjuntos de referencia grandes, haz un join con un DataFrame en lugar de crear una expresión isin() enorme.


12. Excluye valores

filtered = df.filter(
    ~F.col("status").isin(
        "cancelled",
        "deleted",
    )
)

Si hay que conservar los nulos, añade esa regla de forma explícita.


13. Filtra rangos numéricos

filtered = df.filter(
    F.col("amount").between(
        100,
        500,
    )
)

between() es inclusivo en ambos extremos.

Equivalente:

filtered = df.filter(
    (F.col("amount") >= 100)
    & (F.col("amount") <= 500)
)

14. Filtra cadenas con contains

filtered = df.filter(
    F.col("description").contains(
        "premium"
    )
)

Distingue entre mayúsculas y minúsculas.

Para una coincidencia sin distinguir mayúsculas y minúsculas:

filtered = df.filter(
    F.lower(
        F.col("description")
    ).contains("premium")
)

Ten cuidado con las llamadas repetidas para pasar a minúsculas y quitar espacios en conjuntos de datos grandes; normaliza una sola vez si se reutiliza la misma lógica.


15. Filtra con startswith y endswith

filtered = df.filter(
    F.col("sku").startswith("PROD-")
)
filtered = df.filter(
    F.col("filename").endswith(".parquet")
)

Suelen ser más claros que una expresión regular para reglas simples de prefijo o sufijo.


16. Filtra con like

filtered = df.filter(
    F.col("email").like("%@example.com")
)

Comodines de SQL LIKE:

%  → cualquier secuencia
_  → un carácter

Usa rlike() solo cuando realmente necesites expresiones regulares.


17. Filtra con expresiones regulares

filtered = df.filter(
    F.col("product_code").rlike(
        r"^[A-Z]{3}-\d{4}$"
    )
)

Las expresiones regulares pueden ser costosas en conjuntos de datos de texto grandes.

Da preferencia a operaciones de cadena más sencillas siempre que sea posible.


18. Filtra fechas con límites explícitos

filtered = df.filter(
    (F.col("sale_date") >= F.lit("2026-10-01"))
    & (F.col("sale_date") < F.lit("2026-11-01"))
)

Usa intervalos semiabiertos:

start <= value < next_boundary

Así evitas problemas de precisión al final del día.


19. Convierte el tipo antes de comparar fechas cuando el origen es texto

df = df.withColumn(
    "sale_date",
    F.to_date(
        F.col("sale_date_raw"),
        "yyyy-MM-dd",
    ),
)

Después filtra:

filtered = df.filter(
    (F.col("sale_date") >= F.to_date(F.lit("2026-10-01")))
    & (F.col("sale_date") < F.to_date(F.lit("2026-11-01")))
)

No supongas que cualquier cadena de fecha se ordena o se compara correctamente.


20. Filtra marcas de tiempo de forma segura

filtered = df.filter(
    (F.col("event_time") >= F.to_timestamp(F.lit("2026-10-01 00:00:00")))
    & (F.col("event_time") < F.to_timestamp(F.lit("2026-11-01 00:00:00")))
)

Mantén una semántica de zona horaria coherente con la forma en que se generó la columna de marca de tiempo.

No mezcles límites de negocio en hora local con marcas de tiempo UTC sin una conversión explícita.


21. Filtra con sintaxis de expresiones SQL

filtered = df.filter(
    """
    status = 'active'
    AND amount > 100
    """
)

Puede ser útil cuando la condición se expresa de forma natural en SQL.

Da preferencia a la API de Column cuando necesites composición programática y un mejor soporte para refactorizar.


22. Construye expresiones de filtro dinámicas de forma segura

conditions = []

if min_amount is not None:
    conditions.append(
        F.col("amount") >= min_amount
    )

if country is not None:
    conditions.append(
        F.col("country") == country
    )

Combínalas:

from functools import reduce
from operator import and_

if conditions:
    predicate = reduce(
        and_,
        conditions,
    )

    df = df.filter(predicate)

No concatenes entradas no confiables directamente en cadenas de expresiones SQL.


23. Filtra antes de un join

Da preferencia a:

sales_small = (
    sales
    .filter(
        F.col("sale_date") >= "2026-10-01"
    )
    .select(
        "merchant_id",
        "amount",
    )
)

joined = sales_small.join(
    merchants.select(
        "merchant_id",
        "region",
    ),
    on="merchant_id",
    how="left",
)

en lugar de hacer primero el join de entradas anchas o sin filtrar.

Reducir ambos lados antes de un join puede disminuir el shuffle y la presión sobre la memoria.


24. Selecciona solo las columnas necesarias antes de un join

sales_small = sales.select(
    "merchant_id",
    "sale_id",
    "amount",
)

merchants_small = merchants.select(
    "merchant_id",
    "merchant_name",
)

Después haz el join.

Así evitas arrastrar columnas grandes de datos sin usar a través del shuffle.


25. Evita columnas ambiguas después de los joins

Asigna un alias a ambos DataFrames:

s = sales.alias("s")
m = merchants.alias("m")

joined = (
    s.join(
        m,
        F.col("s.merchant_id")
        == F.col("m.merchant_id"),
        "left",
    )
    .select(
        F.col("s.sale_id"),
        F.col("s.merchant_id"),
        F.col("m.merchant_name"),
        F.col("s.amount"),
    )
)

Así evitas la ambigüedad cuando ambas entradas contienen los mismos nombres de columna.


26. Usa una lista de claves de join cuando los nombres coinciden

joined = sales.join(
    merchants,
    on=["merchant_id"],
    how="left",
)

Normalmente esto evita columnas de clave de join duplicadas.

Usa una condición explícita cuando:

  • los nombres de las claves difieren
  • se necesitan varias condiciones que no son de igualdad
  • necesitas más control

27. Usa left semi joins para filtrar por existencia

Conserva las filas de sales cuyo merchant_id existe en merchants:

valid_sales = sales.join(
    merchants.select("merchant_id"),
    on="merchant_id",
    how="left_semi",
)

Es más claro, y a menudo más eficiente, que un join completo seguido de la eliminación de columnas.


28. Usa left anti joins para detectar referencias faltantes

Encuentra las ventas sin comercio correspondiente:

orphan_sales = sales.join(
    merchants.select("merchant_id"),
    on="merchant_id",
    how="left_anti",
)

Usa anti joins para:

  • claves foráneas sin correspondencia
  • detección incremental de claves nuevas
  • informes de excepciones

29. Evita filtrar recopilando claves en Python

Patrón incorrecto:

keys = [
    row["merchant_id"]
    for row in merchants.collect()
]

filtered = sales.filter(
    F.col("merchant_id").isin(keys)
)

Esto mueve datos al driver y puede fallar a escala.

Usa un semi join en su lugar.


30. Evita el filtrado fila a fila en Python

Incorrecto:

rows = df.collect()

filtered = [
    row
    for row in rows
    if row["amount"] > 100
]

Correcto:

filtered = df.filter(
    F.col("amount") > 100
)

Mantén el filtrado distribuido en Spark.


31. Da preferencia a las funciones integradas frente a filtros con UDF de Python

Da preferencia a:

filtered = df.filter(
    F.length(
        F.trim(F.col("email"))
    ) > 5
)

en lugar de una UDF de Python que compruebe la longitud de la cadena.

Las funciones integradas de Spark son más fáciles de entender para el optimizador y evitan la sobrecarga de serialización de Python.


32. Comprueba si los filtros llegaron al plan físico

filtered.explain("formatted")

Busca:

  • Filter
  • los filtros empujados (pushed filters), cuando se muestren
  • los filtros de partición
  • lecturas reducidas

No supongas que todos los filtros se empujan hasta el origen.

La forma de la expresión y la compatibilidad del origen de datos importan.


33. Inspecciona los filtros de partición de Parquet/Delta en el plan

En una tabla particionada físicamente, un filtro como:

df.filter(
    F.col("sale_year") == 2026
)

puede permitir el partition pruning.

Usa:

df.filter(
    F.col("sale_year") == 2026
).explain("formatted")

Busca información sobre los filtros de partición en la lectura.

Si el pruning no se produce, revisa:

  • la columna de partición
  • el tipo de la expresión
  • las conversiones de tipo o funciones que envuelven la columna de partición
  • la organización de la tabla

34. Evita envolver innecesariamente las columnas de partición

Menos favorable para el optimizador:

df.filter(
    F.year(
        F.col("sale_date")
    ) == 2026
)

Si ya existe una columna de partición específica:

df.filter(
    F.col("sale_year") == 2026
)

suele ser más claro para el partition pruning.

Diseña las columnas de partición en función de los patrones de acceso reales.


35. Usa limit() solo para una inspección acotada

sample = df.limit(100)

Es útil para:

  • vistas previas
  • inspección local
  • salida de pruebas

No trates limit() como sustituto del filtrado de negocio.

Un resultado limitado no es representativo a menos que la semántica de ordenación o de muestreo esté definida.


36. Usa sample() para una inspección aproximada

sample = df.sample(
    withReplacement=False,
    fraction=0.01,
    seed=42,
)

Usa el muestreo para la exploración.

No lo uses para demostrar:

  • la unicidad
  • la completitud
  • la ausencia de datos incorrectos

Una muestra no puede validar el conjunto de datos completo.


37. Comprueba el número de filas antes y después de un filtro importante

before = df.count()

filtered = df.filter(
    F.col("status") == "active"
)

after = filtered.count()

print("Before:", before)
print("After:", after)
print("Removed:", before - after)

En trabajos de producción grandes, evita lecturas completas repetidas solo para el registro.

Siempre que sea posible, combina las métricas de calidad en una sola agregación.


38. Agrega los diagnósticos del filtro en una sola pasada

metrics = (
    df.agg(
        F.count("*").alias("rows_total"),
        F.sum(
            F.when(
                F.col("status") == "active",
                1,
            ).otherwise(0)
        ).alias("rows_active"),
        F.sum(
            F.when(
                F.col("merchant_id").isNull(),
                1,
            ).otherwise(0)
        ).alias("rows_missing_merchant"),
    )
)

metrics.show()

Normalmente es más eficiente que varios jobs de count() separados.


39. Valida resultados de filtro inesperados

Si un filtro devuelve cero filas:

df.select(
    "status"
).distinct().show(
    100,
    truncate=False,
)

O bien:

(
    df.groupBy("status")
    .count()
    .orderBy(
        F.desc("count")
    )
    .show(
        100,
        truncate=False,
    )
)

Busca:

  • mayúsculas y minúsculas
  • espacios en blanco
  • nulos
  • códigos inesperados
  • cambios en el origen

40. Normaliza una sola vez la lógica de cadenas repetida

En lugar de escribir:

df.filter(
    F.lower(
        F.trim(F.col("status"))
    ) == "active"
)

en muchos sitios, normaliza una sola vez:

df = df.withColumn(
    "status_normalized",
    F.lower(
        F.trim(F.col("status"))
    ),
)

Después:

filtered = df.filter(
    F.col("status_normalized") == "active"
)

Hazlo solo cuando el campo normalizado se reutilice lo suficiente como para justificar conservarlo.

Qué significa el resultado

Operación Significado
select() Proyecta las columnas o expresiones necesarias más adelante
withColumn() Añade o reemplaza una columna
drop() Elimina columnas
filter() / where() Conserva las filas que cumplen un predicado de Spark
isin() Prueba de pertenencia para conjuntos pequeños de valores
isNull() / isNotNull() Filtrado explícito de nulos
left_semi Conserva las filas izquierdas con una clave coincidente a la derecha
left_anti Conserva las filas izquierdas sin una clave coincidente a la derecha
explain() Muestra el plan de ejecución lógico/físico
partition pruning Evita leer particiones físicas irrelevantes
predicate pushdown Acerca el filtrado compatible al origen de datos

El principio de rendimiento importante es:

reducir pronto
→ menos shuffle
→ menos datos arrastrados
→ menos trabajo

Qué revisar

El join es costoso aunque el resultado sea pequeño

Comprueba si ambos lados se filtraron y proyectaron antes del join.

Un resultado estrecho no ayuda si Spark hizo de todos modos el shuffle de entradas anchas.

El filtro devuelve inesperadamente pocas filas

Revisa:

  • el comportamiento de los nulos
  • el formato de las cadenas
  • el dtype
  • los límites de fecha
  • la semántica de zona horaria
  • valores inesperados en el origen

El filtro devuelve cero filas después de un cambio de esquema

Es posible que el origen contenga ahora códigos, tipos o formatos diferentes.

Inspecciona los valores reales antes de cambiar el predicado.

El plan físico sigue leyendo una gran cantidad de datos

Comprueba si:

  • el filtro se puede empujar hasta el origen
  • el partition pruning es posible
  • envolviste las columnas de partición en transformaciones
  • la organización del origen admite el pruning

La memoria del driver crece durante el filtrado

Busca:

  • collect()
  • listas de claves en Python
  • toPandas()
  • procesamiento fila a fila

Normalmente, el filtrado debe seguir siendo distribuido.

La misma limpieza de cadenas aparece en muchos filtros

Normaliza una sola vez en una transformación controlada en lugar de repetir expresiones costosas en todas partes.

Notas de producción

Las transformaciones de Spark son lazy

select() y filter() construyen un plan.

El trabajo real empieza cuando se ejecuta una acción, como:

count()
show()
write...
collect()

No midas solo la construcción del DataFrame.

El pushdown depende del origen

Delta/Parquet a menudo pueden beneficiarse del pushdown de predicados y de columnas.

No todas las expresiones son compatibles con el pushdown.

Usa el plan físico en lugar de suponer que la optimización se produjo.

La semántica de los nulos es similar a la de SQL

Spark usa lógica de tres valores:

verdadero
falso
desconocido

Una comparación con null suele devolver desconocido, lo que no pasa un filtro.

Haz explícito el tratamiento de los nulos.

Las listas isin() grandes son una señal de alerta

Unos pocos valores literales están bien.

Miles o millones de valores normalmente deberían convertirse en un DataFrame con el que hacer un join.

El ancho de las columnas importa

Un DataFrame con:

10 millones de filas × 5 columnas

puede ser muchísimo más barato de mover en un shuffle que:

10 millones de filas × 80 columnas

Selecciona pronto.

El orden de los filtros suele gestionarlo el optimizador

No hagas microoptimizaciones reordenando manualmente predicados deterministas simples, salvo que el plan o el tiempo de ejecución muestren un problema real.

Céntrate más en:

  • el pruning en el origen
  • las UDF costosas
  • los joins
  • la organización de las particiones

Las funciones definidas por el usuario costosas pueden bloquear la optimización

Una UDF de Python dentro de un filtro puede introducir sobrecarga de serialización y reducir las oportunidades de optimización.

Da preferencia a las funciones integradas de Spark SQL.

Errores comunes

1. Usar and / or de Python

Las expresiones de columna de Spark requieren & y |.

2. Olvidar los paréntesis alrededor de las condiciones

La precedencia de operadores puede producir errores o una lógica no deseada.

3. Usar == None

Usa isNull() / isNotNull().

4. Suponer que != value conserva los nulos

No lo hace.

Las comparaciones con null se evalúan como desconocidas.

5. Recopilar claves de referencia en Python

Usa un semi join en su lugar.

6. Seleccionar * en todo el pipeline

Los DataFrames anchos aumentan el costo del shuffle y de la memoria.

7. Filtrar después del join costoso

Reduce las filas antes del shuffle cuando la lógica de negocio lo permita.

8. Usar expresiones regulares para una lógica simple de prefijo o sufijo

Usa startswith(), endswith() o contains() cuando expresen la regla con claridad.

9. Suponer que todos los filtros se empujan hasta el origen

Revisa el plan.

10. Usar limit() como prueba de que los datos son correctos

Una vista previa pequeña no puede validar el conjunto de datos completo.

Siguiente paso

Usa el síntoma para elegir la siguiente acción.

  • Demasiadas filas llegan a un join → adelanta los filtros seguros.
  • Demasiadas columnas llegan a un join → proyecta primero solo las columnas necesarias.
  • El filtro no devuelve filas → inspecciona los valores reales, los nulos y los dtypes.
  • La pertenencia a una referencia usa listas de Python → sustitúyelas por un semi/anti join.
  • El comportamiento de los nulos sorprende → haz explícita la semántica de los nulos.
  • El filtrado por fecha es incorrecto → usa fechas/marcas de tiempo tipadas e intervalos semiabiertos.
  • La lectura sigue siendo grande → inspecciona explain("formatted") en busca de pushdown y partition pruning.
  • El filtrado usa UDF de Python → sustitúyelas por funciones integradas de Spark cuando sea posible.
  • Los datos siguen pareciendo demasiado grandes tras un pruning correcto → pasa a Referencia rápida de rendimiento de PySpark e inspecciona el particionamiento y el shuffle.

← Todas las guías rápidas