Explorar guías rápidas · Python

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

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
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Contar valores faltantes por columna
  5. 2. Calcular porcentajes de valores faltantes
  6. 3. Encontrar filas con un valor faltante en una columna
  7. 4. Encontrar filas con algún valor faltante
  8. 5. Encontrar filas donde faltan todos los campos seleccionados
  9. 6. Eliminar filas sin una clave de negocio obligatoria
  10. 7. Exigir al menos N valores no nulos
  11. 8. Eliminar columnas completamente vacías
  12. 9. Rellenar explícitamente un valor categórico faltante
  13. 10. Rellenar valores numéricos solo cuando cero sea semánticamente correcto
  14. 11. Rellenar a partir de otra columna
  15. 12. Propagar valores hacia adelante (forward fill)
  16. 13. Propagar valores hacia atrás (backward fill)
  17. 14. Interpolar valores numéricos
  18. 15. Conservar la semántica de enteros nullable
  19. 16. Usar el dtype de cadena nullable
  20. 17. Convertir valores numéricos no válidos en valores faltantes para inspeccionarlos
  21. 18. Convertir fechas no válidas en NaT e inspeccionar los fallos
  22. 19. Detectar cadenas vacías por separado de los valores faltantes
  23. 20. Normalizar con cuidado cadenas conocidas equivalentes a nulo
  24. 21. Reemplazar valores centinela conocidos por valores faltantes
  25. 22. Rellenar por grupo
  26. 23. Comparar antes y después del tratamiento de valores faltantes
  27. 24. Verificar los campos obligatorios después de la limpieza
  28. Qué significa el resultado
  29. Qué revisar
  30. El porcentaje de nulos aumentó de repente
  31. Falta un identificador obligatorio
  32. Los valores faltantes aparecen solo después de un merge
  33. Aparecen nulos numéricos después de una conversión
  34. Aparecen fechas nulas después del análisis
  35. Una categoría tiene tanto nulos como "Unknown"
  36. Notas de producción
  37. Los valores faltantes son lógica de negocio
  38. Rellenar valores puede destruir información
  39. El comportamiento de los nulos depende del dtype
  40. dropna() puede eliminar grandes cantidades de datos
  41. La propagación hacia adelante requiere un orden
  42. La imputación cambia los datos
  43. DataFrames grandes
  44. Errores comunes
  45. 1. Rellenar todos los nulos con cero
  46. 2. Llamar a dropna() sin subset
  47. 3. Usar == np.nan
  48. 4. Tratar automáticamente las cadenas vacías como faltantes
  49. 5. Propagar hacia adelante datos sin ordenar
  50. 6. Rellenar después de un join defectuoso
  51. 7. Sobrescribir de inmediato las conversiones fallidas
  52. 8. Eliminar una columna con muchos nulos sin comprobar la importancia de sus escasos valores
  53. Siguiente paso
  54. 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.

Siguiente paso

Usa el patrón de valores faltantes para decidir qué hacer a continuación.

  • Faltan claves obligatorias → rastrea la calidad del origen antes del procesamiento posterior.
  • Aparecieron nulos después de un join → inspecciona las claves sin correspondencia y la cardinalidad del join.
  • Aparecieron nulos después del análisis → inspecciona los valores de origen no válidos y las reglas de conversión de tipos.
  • El valor faltante tiene un valor predeterminado válido → rellena explícitamente y documenta la regla.
  • El valor faltante significa desconocido → considera conservar el nulo o usar una categoría claramente etiquetada.
  • Las filas son inutilizables sin el campo → elimina solo el subconjunto afectado y mide el impacto.
  • Se esperan huecos en la serie temporal → considera la interpolación o la propagación hacia adelante solo con el orden y la semántica correctos.
  • Los valores faltantes tienen importancia operativa → agrega métricas de validación y sigue la evolución de la tasa de nulos a lo largo del tiempo.

← Todas las guías rápidas