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