Explorar guías rápidas · Python
Gestionar valores faltantes en pandas
Inspecciona, filtra, rellena, elimina y valida valores faltantes en pandas sin cambiar silenciosamente el significado ni el dtype de los datos de producción.
En esta página
- Problema
- Respuesta rápida
- Código / comandos
- 1. Contar valores faltantes por columna
- 2. Calcular porcentajes de valores faltantes
- 3. Encontrar filas con un valor faltante en una columna
- 4. Encontrar filas con algún valor faltante
- 5. Encontrar filas donde faltan todos los campos seleccionados
- 6. Eliminar filas sin una clave de negocio obligatoria
- 7. Exigir al menos N valores no nulos
- 8. Eliminar columnas completamente vacías
- 9. Rellenar explícitamente un valor categórico faltante
- 10. Rellenar valores numéricos solo cuando cero sea semánticamente correcto
- 11. Rellenar a partir de otra columna
- 12. Propagar valores hacia adelante (forward fill)
- 13. Propagar valores hacia atrás (backward fill)
- 14. Interpolar valores numéricos
- 15. Conservar la semántica de enteros nullable
- 16. Usar el dtype de cadena nullable
- 17. Convertir valores numéricos no válidos en valores faltantes para inspeccionarlos
- 18. Convertir fechas no válidas en NaT e inspeccionar los fallos
- 19. Detectar cadenas vacías por separado de los valores faltantes
- 20. Normalizar con cuidado cadenas conocidas equivalentes a nulo
- 21. Reemplazar valores centinela conocidos por valores faltantes
- 22. Rellenar por grupo
- 23. Comparar antes y después del tratamiento de valores faltantes
- 24. Verificar los campos obligatorios después de la limpieza
- Qué significa el resultado
- Qué revisar
- El porcentaje de nulos aumentó de repente
- Falta un identificador obligatorio
- Los valores faltantes aparecen solo después de un merge
- Aparecen nulos numéricos después de una conversión
- Aparecen fechas nulas después del análisis
- Una categoría tiene tanto nulos como "Unknown"
- Notas de producción
- Los valores faltantes son lógica de negocio
- Rellenar valores puede destruir información
- El comportamiento de los nulos depende del dtype
- dropna() puede eliminar grandes cantidades de datos
- La propagación hacia adelante requiere un orden
- La imputación cambia los datos
- DataFrames grandes
- Errores comunes
- 1. Rellenar todos los nulos con cero
- 2. Llamar a dropna() sin subset
- 3. Usar == np.nan
- 4. Tratar automáticamente las cadenas vacías como faltantes
- 5. Propagar hacia adelante datos sin ordenar
- 6. Rellenar después de un join defectuoso
- 7. Sobrescribir de inmediato las conversiones fallidas
- 8. Eliminar una columna con muchos nulos sin comprobar la importancia de sus escasos valores
- Siguiente paso
- Para profundizar
Problema
Los conjuntos de datos reales suelen contener valores faltantes:
- atributos de cliente ausentes
- mediciones no reportadas
- errores de análisis (parsing)
- joins incompletos
- campos opcionales
- valores de origen vacíos
- datos de origen retrasados
La operación técnica es sencilla.
Lo difícil es decidir qué significa un valor faltante antes de modificarlo.
Necesitas saber:
- dónde hay valores faltantes
- si son esperados
- si indican un problema de calidad de datos
- si las filas deben conservarse o eliminarse
- si rellenar los valores cambia su significado de negocio
- si una conversión creó nuevos valores faltantes
- si los valores faltantes rompen joins, agregaciones o tipos posteriores
Respuesta rápida
Empieza por perfilar los valores faltantes.
null_summary = (
pd.DataFrame(
{
"null_count": df.isna().sum(),
"null_pct": df.isna().mean().mul(100),
}
)
.sort_values("null_pct", ascending=False)
)
print(null_summary)
Filtra las filas con valores faltantes:
missing_email = df.loc[df["email"].isna()]
Rellena solo cuando el valor de reemplazo tenga un significado de negocio claro:
df["country"] = df["country"].fillna("Unknown")
Elimina filas solo cuando el campo faltante haga que la fila sea inutilizable:
df = df.dropna(subset=["order_id"])
No uses fillna(0) ni dropna() de forma global sin entender la semántica de los datos.
Código / comandos
1. Contar valores faltantes por columna
null_counts = (
df.isna()
.sum()
.sort_values(ascending=False)
)
print(null_counts)
Es la primera comprobación más rápida.
2. Calcular porcentajes de valores faltantes
null_summary = (
pd.DataFrame(
{
"null_count": df.isna().sum(),
"null_pct": df.isna().mean().mul(100),
}
)
.sort_values("null_pct", ascending=False)
)
print(null_summary)
Los porcentajes son más útiles que los conteos cuando el tamaño de las columnas o de los conjuntos de datos varía mucho.
3. Encontrar filas con un valor faltante en una columna
missing_email = df.loc[
df["email"].isna()
]
Encuentra las filas donde el valor existe:
has_email = df.loc[
df["email"].notna()
]
Usa .isna() y .notna() en lugar de comparar con None o np.nan.
4. Encontrar filas con algún valor faltante
rows_with_missing = df.loc[
df.isna().any(axis=1)
]
Cuéntalas:
print(df.isna().any(axis=1).sum())
Es útil para una inspección general, pero no trates todos los campos faltantes como igual de importantes.
5. Encontrar filas donde faltan todos los campos seleccionados
cols = ["email", "phone", "mobile"]
no_contact_details = df.loc[
df[cols].isna().all(axis=1)
]
Esto suele ser más significativo que evaluar la fila completa.
6. Eliminar filas sin una clave de negocio obligatoria
df_clean = df.dropna(
subset=["order_id"]
)
Para varios campos obligatorios:
df_clean = df.dropna(
subset=["order_id", "customer_id"]
)
Usa esto solo cuando una clave faltante realmente haga inutilizable el registro.
7. Exigir al menos N valores no nulos
df_clean = df.dropna(
thresh=3
)
Esto conserva las filas con al menos tres valores no nulos en todo el DataFrame.
Puedes aplicar la regla a columnas seleccionadas:
df_clean = df.dropna(
subset=["email", "phone", "mobile"],
thresh=1,
)
Esto conserva las filas donde hay al menos un campo de contacto.
8. Eliminar columnas completamente vacías
df_clean = df.dropna(
axis="columns",
how="all",
)
Es seguro cuando una columna no contiene ninguna información.
No elimines automáticamente una columna mayoritariamente nula si sus escasos valores son críticos para el negocio.
9. Rellenar explícitamente un valor categórico faltante
df["country"] = (
df["country"]
.fillna("Unknown")
)
Usa una etiqueta como "Unknown" solo cuando ese valor signifique claramente:
el valor no se conoce
No uses una categoría real como "US" como valor predeterminado, a menos que la regla de negocio lo garantice.
10. Rellenar valores numéricos solo cuando cero sea semánticamente correcto
df["discount_amount"] = (
df["discount_amount"]
.fillna(0)
)
Esto solo es correcto si el valor faltante significa:
no se aplicó ningún descuento
Es incorrecto si el valor faltante significa:
los datos del descuento no estaban disponibles
Cero y desconocido son estados diferentes.
11. Rellenar a partir de otra columna
df["billing_country"] = (
df["billing_country"]
.fillna(df["shipping_country"])
)
Usa esto solo cuando el valor alternativo sea válido según la regla de negocio.
12. Propagar valores hacia adelante (forward fill)
df["status"] = df["status"].ffill()
Es útil cuando las filas representan una secuencia ordenada y un valor sigue siendo válido hasta que se reemplaza.
Ejemplo:
df = df.sort_values(
["device_id", "event_time"]
)
df["status"] = (
df.groupby("device_id")["status"]
.ffill()
)
Define siempre el orden correcto y el ámbito de agrupación antes de propagar hacia adelante.
13. Propagar valores hacia atrás (backward fill)
df["status"] = df["status"].bfill()
Usa la propagación hacia atrás solo cuando un valor conocido posterior sea un reemplazo válido para las filas faltantes anteriores.
Es menos habitual en datos transaccionales de producción y debe justificarse explícitamente.
14. Interpolar valores numéricos
df["temperature"] = (
df["temperature"]
.interpolate()
)
Para datos indexados por tiempo:
df = df.sort_values("event_time").set_index("event_time")
df["temperature"] = (
df["temperature"]
.interpolate(method="time")
)
La interpolación es adecuada para algunas mediciones continuas.
Suele ser inadecuada para:
- identificadores
- categorías
- importes de transacciones financieras
- eventos discretos
- claves de negocio
15. Conservar la semántica de enteros nullable
Una columna de enteros NumPy normal no puede representar NaN.
Usa el dtype de entero nullable de pandas cuando los enteros faltantes sean válidos.
df["customer_age"] = (
pd.to_numeric(
df["customer_age"],
errors="coerce",
)
.astype("Int64")
)
Esto conserva los valores enteros y a la vez permite pd.NA.
16. Usar el dtype de cadena nullable
df["customer_name"] = (
df["customer_name"]
.astype("string")
)
Ofrece un comportamiento más coherente ante valores faltantes que las columnas object genéricas.
Comprueba:
print(df["customer_name"].dtype)
17. Convertir valores numéricos no válidos en valores faltantes para inspeccionarlos
parsed_amount = pd.to_numeric(
df["amount"],
errors="coerce",
)
Encuentra las filas cuya conversión falló:
failed = df.loc[
df["amount"].notna()
& parsed_amount.isna()
]
print(failed)
No sobrescribas la columna de origen hasta entender por qué falló el análisis.
18. Convertir fechas no válidas en NaT e inspeccionar los fallos
parsed_date = pd.to_datetime(
df["event_time"],
errors="coerce",
)
Encuentra los análisis fallidos:
failed_dates = df.loc[
df["event_time"].notna()
& parsed_date.isna()
]
print(failed_dates)
NaT es el valor datetime faltante de pandas.
19. Detectar cadenas vacías por separado de los valores faltantes
Una cadena vacía no necesariamente se trata como un valor faltante.
empty_strings = (
df.select_dtypes(include=["object", "string"])
.apply(lambda s: s.eq("").sum())
.sort_values(ascending=False)
)
print(empty_strings)
Inspecciona también las cadenas que solo contienen espacios en blanco:
whitespace_only = (
df.select_dtypes(include=["object", "string"])
.apply(
lambda s: (
s.astype("string")
.str.strip()
.eq("")
.sum()
)
)
)
print(whitespace_only)
No supongas que los sistemas de origen codifican la ausencia de forma coherente.
20. Normalizar con cuidado cadenas conocidas equivalentes a nulo
Supón que el origen usa valores como:
NULL
N/A
None
unknown
Inspecciona primero:
null_like = {
"",
"null",
"none",
"n/a",
"na",
}
for col in df.select_dtypes(
include=["object", "string"]
).columns:
normalized = (
df[col]
.astype("string")
.str.strip()
.str.lower()
)
matches = normalized.isin(null_like).sum()
if matches:
print(col, matches)
Convierte estos valores en faltantes solo después de confirmar que realmente representan una ausencia en ese campo.
21. Reemplazar valores centinela conocidos por valores faltantes
Ejemplo:
df["temperature"] = (
df["temperature"]
.replace(-9999, pd.NA)
)
Esto solo es apropiado cuando -9999 está documentado como valor centinela del sistema de origen.
No adivines valores centinela a partir de datos de aspecto inusual.
22. Rellenar por grupo
Ejemplo: rellenar el gerente regional faltante a partir de los valores conocidos dentro de cada región.
df["regional_manager"] = (
df.groupby("region")["regional_manager"]
.transform(
lambda s: s.ffill().bfill()
)
)
Usa esto solo cuando los valores sean estables dentro del grupo y el orden de las filas sea adecuado.
Un relleno a nivel de grupo puede propagar silenciosamente datos erróneos si la clave de agrupación es incorrecta.
23. Comparar antes y después del tratamiento de valores faltantes
before = df["country"].isna().sum()
df["country"] = (
df["country"]
.fillna("Unknown")
)
after = df["country"].isna().sum()
print("Before:", before)
print("After:", after)
Las transformaciones de producción deben hacer explícito el cambio esperado en la calidad de los datos.
24. Verificar los campos obligatorios después de la limpieza
assert df["order_id"].notna().all()
assert df["customer_id"].notna().all()
Para varios campos:
required = [
"order_id",
"customer_id",
"event_time",
]
assert df[required].notna().all().all()
Las aserciones son útiles en pipelines controlados, pero los sistemas de producción pueden necesitar validación estructurada y manejo de errores en lugar de una terminación brusca del proceso.
Qué significa el resultado
| Valor / método | Significado |
|---|---|
np.nan |
Marcador habitual de valor faltante de punto flotante. |
pd.NA |
Escalar de valor faltante nullable de pandas, usado por los dtypes nullable. |
NaT |
Valor datetime/timedelta faltante. |
isna() |
Detecta los valores faltantes reconocidos por pandas. |
notna() |
Detecta los valores no faltantes. |
dropna() |
Elimina filas o columnas según reglas sobre valores faltantes. |
fillna() |
Reemplaza los valores faltantes con valores explícitos. |
ffill() |
Propaga hacia adelante el último valor válido. |
bfill() |
Propaga hacia atrás el siguiente valor válido. |
interpolate() |
Estima valores intermedios según un método. |
Lo importante es la semántica:
faltante != cero
faltante != cadena vacía
faltante != falso
faltante != "Unknown"
a menos que tus reglas de negocio los hagan explícitamente equivalentes.
Qué revisar
El porcentaje de nulos aumentó de repente
Posibles causas:
- cambio de esquema en el origen
- join fallido
- error de análisis
- partición de origen faltante
- cambio en la semántica del origen
Compara con ejecuciones anteriores antes de hacer desaparecer esos valores rellenándolos.
Falta un identificador obligatorio
Suele ser más grave que la falta de una descripción opcional.
Prioriza los valores faltantes según su importancia para el negocio, no solo según su porcentaje.
Los valores faltantes aparecen solo después de un merge
Causas probables:
- claves sin correspondencia
- diferencias de formato en las claves
- tabla de búsqueda incompleta
- columnas de join incorrectas
Investiga el merge antes de rellenar los campos de enriquecimiento.
Aparecen nulos numéricos después de una conversión
Probablemente el origen contenía valores no numéricos.
Inspecciona las conversiones fallidas en lugar de tratarlas como valores faltantes genuinos.
Aparecen fechas nulas después del análisis
Inspecciona:
- un formato inesperado
- fechas imposibles
- texto de zona horaria
- convenciones de fecha mezcladas
Una categoría tiene tanto nulos como "Unknown"
Ahora son dos estados diferentes.
Puede ser correcto, pero debe ser intencionado.
Notas de producción
Los valores faltantes son lógica de negocio
No existe una regla universal como:
< 5% faltantes -> eliminar
> 5% faltantes -> rellenar
La acción correcta depende de:
- la semántica del campo
- la fiabilidad del origen
- el uso posterior
- los requisitos regulatorios
- las expectativas de reporting
Rellenar valores puede destruir información
Una vez que reemplazas los nulos por 0, "Unknown" u otro valor, puedes perder la distinción entre:
- el valor observado originalmente
- el valor de origen faltante
- el valor imputado
Para los datos importantes, considera conservar un indicador:
df["country_was_missing"] = (
df["country"].isna()
)
df["country"] = (
df["country"]
.fillna("Unknown")
)
El comportamiento de los nulos depende del dtype
pandas puede usar distintos marcadores de valor faltante según el dtype.
Prefiere los dtypes nullable modernos cuando los valores faltantes formen parte del modelo.
Ejemplos:
Int64
boolean
string
dropna() puede eliminar grandes cantidades de datos
Mide siempre el impacto primero.
before = len(df)
candidate = df.dropna(
subset=["customer_id"]
)
removed = before - len(candidate)
print("Rows removed:", removed)
La propagación hacia adelante requiere un orden
Esto no es seguro:
df["status"].ffill()
si las filas no están en la secuencia de negocio correcta.
Ordena primero.
La imputación cambia los datos
La media, la mediana, la interpolación, la propagación hacia adelante y otros métodos de imputación producen valores derivados.
Si la distinción importa, registra que el valor fue imputado.
DataFrames grandes
Las operaciones con valores faltantes suelen recorrer columnas completas.
Con grandes volúmenes de datos:
- inspecciona primero las columnas concretas
- evita recorridos repetidos de todo el DataFrame
- selecciona solo las columnas necesarias
- acerca la validación al origen cuando sea posible
Errores comunes
1. Rellenar todos los nulos con cero
Cero es un valor real.
Faltante significa desconocido/ausente, a menos que la regla de negocio indique lo contrario.
2. Llamar a dropna() sin subset
Esto puede eliminar filas por campos opcionales irrelevantes.
Apunta a los campos que realmente determinan la validez de la fila.
3. Usar == np.nan
Esto no detecta valores faltantes de forma fiable.
Usa:
isna()
4. Tratar automáticamente las cadenas vacías como faltantes
Algunos sistemas distinguen:
NULL
""
" "
Normaliza solo cuando la semántica de negocio lo respalde.
5. Propagar hacia adelante datos sin ordenar
Esto puede propagar valores a lo largo de la secuencia equivocada.
Ordena y agrupa correctamente primero.
6. Rellenar después de un join defectuoso
Si los nulos se crearon porque las claves no coincidieron, rellenarlos puede ocultar el defecto del join.
Corrige primero el problema de correspondencia.
7. Sobrescribir de inmediato las conversiones fallidas
Esto destruye la evidencia.
Crea una Series analizada, inspecciona los fallos y luego asigna el resultado de forma intencionada.
8. Eliminar una columna con muchos nulos sin comprobar la importancia de sus escasos valores
Una columna puede ser nula en un 99% y aun así contener excepciones críticas.
Inspecciona su uso real antes de eliminarla.
¿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.