Explorar guías rápidas · Python

Tecnología: PythonCategoría: Análisis de datosNivel: PrincipianteActualizado

Inspeccionar un DataFrame de pandas

Inspecciona un DataFrame de pandas de forma rápida y segura para entender su forma, columnas, tipos de datos, nulos, duplicados, distribuciones y valores sospechosos antes de transformar los datos.

En esta página
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Comprueba la forma y los nombres de columna
  5. 2. Inspecciona el esquema y el uso de memoria
  6. 3. Muestra las primeras y las últimas filas
  7. 4. Toma una muestra aleatoria de filas
  8. 5. Inspecciona los tipos de datos
  9. 6. Cuenta los nulos por columna
  10. 7. Comprueba las filas duplicadas
  11. 8. Comprueba los duplicados por clave de negocio
  12. 9. Resume las columnas numéricas
  13. 10. Resume todos los tipos de columna
  14. 11. Cuenta los valores únicos
  15. 12. Inspecciona los valores categóricos
  16. 13. Inspecciona varias columnas categóricas de forma segura
  17. 14. Inspecciona los rangos numéricos
  18. 15. Comprueba los rangos de fechas
  19. 16. Encuentra espacios sospechosos en columnas de texto
  20. 17. Distingue las cadenas vacías de los nulos
  21. 18. Encuentra cadenas comunes que equivalen a nulos
  22. 19. Inspecciona un registro por clave de negocio
  23. 20. Crea una función de inspección compacta y reutilizable
  24. Qué significa el resultado
  25. Qué revisar
  26. Columna numérica cargada como object o string
  27. Columna de fecha cargada como texto
  28. Porcentaje de nulos muy alto
  29. Cardinalidad inesperadamente alta en una columna de categorías
  30. Cardinalidad inesperadamente baja
  31. Rango mín./máx. muy amplio
  32. Claves de negocio duplicadas
  33. Notas de producción
  34. Las operaciones de inspección pueden ser costosas
  35. df.info(memory_usage="deep") puede ser lento
  36. Los tipos de datos de pandas requieren interpretación
  37. No modifiques los datos mientras los inspeccionas
  38. Las muestras pueden ocultar problemas poco frecuentes
  39. Los pipelines de producción necesitan aserciones o reglas de calidad
  40. Errores comunes
  41. 1. Confiar en que head() es representativo
  42. 2. Llamar a drop_duplicates() de inmediato
  43. 3. Rellenar todos los nulos con cero
  44. 4. Suponer que pandas infirió el dtype correcto
  45. 5. Imprimir todos los valores únicos
  46. 6. Convertir datos incorrectos antes de inspeccionarlos
  47. 7. Perfilar todas las columnas de un DataFrame enorme
  48. Siguiente paso
  49. Para profundizar

Problema

Cargaste en pandas un CSV, un archivo Parquet, la respuesta de una API o el resultado de una consulta, y necesitas entender qué contienen realmente los datos antes de transformarlos.

El objetivo es responder rápidamente:

  • ¿Cuántas filas y columnas hay?
  • ¿Cuáles son los nombres y los tipos de datos de las columnas?
  • ¿Qué columnas contienen nulos?
  • ¿Hay filas duplicadas?
  • ¿Qué valores predominan en las columnas categóricas?
  • ¿Los rangos numéricos son plausibles?
  • ¿Las columnas de fecha se interpretaron realmente como fechas?
  • ¿Hay cadenas sospechosas, tipos mezclados o valores inesperados?

Hazlo antes de los joins, las agregaciones, el filtrado o la escritura de los datos.

Respuesta rápida

Empieza con una pasada de inspección compacta:

import pandas as pd

df = pd.read_parquet("data.parquet")

print(df.shape)
print(df.columns.tolist())
df.info()

print(df.head())
print(df.isna().sum().sort_values(ascending=False).head(20))
print(df.duplicated().sum())

print(df.describe(include="all").T)

Esto te da:

  • las dimensiones
  • los nombres de columna
  • los tipos de datos inferidos
  • el recuento de nulos
  • el recuento de duplicados
  • filas de ejemplo
  • resúmenes numéricos y no numéricos

No empieces a transformar los datos hasta que el esquema y la calidad de los datos parezcan plausibles.

Código / comandos

1. Comprueba la forma y los nombres de columna

print(df.shape)
print(df.columns.tolist())

Hazlo inmediatamente después de cargar los datos.

Ejemplo:

(125000, 18)

significa:

  • 125.000 filas
  • 18 columnas

Si la forma es inesperadamente pequeña o grande, verifica el origen antes de hacer cualquier otra cosa.


2. Inspecciona el esquema y el uso de memoria

df.info()

Para ver la memoria con más detalle:

df.info(memory_usage="deep")

Úsalo para inspeccionar:

  • los nombres de columna
  • el recuento de valores no nulos
  • los dtypes
  • el uso aproximado de memoria

memory_usage="deep" es más preciso en DataFrames con muchas columnas object o string, pero puede tardar más con grandes volúmenes de datos.


3. Muestra las primeras y las últimas filas

print(df.head())
print(df.tail())

Elige un número concreto cuando sea útil:

print(df.head(10))

Úsalo para verificar:

  • el comportamiento del delimitador y del análisis
  • la alineación de las columnas
  • los nulos evidentes
  • los encabezados inesperados
  • el formato de las fechas
  • los valores sospechosos

No te bases solo en head() para sacar conclusiones sobre la calidad de los datos.


4. Toma una muestra aleatoria de filas

print(df.sample(10, random_state=42))

Una muestra aleatoria suele ser más representativa que las primeras filas.

Usa un random_state fijo cuando quieras una inspección reproducible.


5. Inspecciona los tipos de datos

print(df.dtypes)

Filtra por tipo:

numeric_cols = df.select_dtypes(include="number").columns
text_cols = df.select_dtypes(include=["object", "string"]).columns
date_cols = df.select_dtypes(include=["datetime", "datetimetz"]).columns

Úsalo para detectar problemas como:

  • columnas numéricas cargadas como cadenas
  • fechas cargadas como cadenas
  • identificadores inferidos por error como números

6. Cuenta los nulos por columna

null_counts = df.isna().sum().sort_values(ascending=False)
print(null_counts)

Añade el porcentaje:

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)

Usa porcentajes, porque los recuentos brutos de nulos son difíciles de interpretar sin el número de filas.


7. Comprueba las filas duplicadas

duplicate_count = df.duplicated().sum()
print(duplicate_count)

Inspecciona los duplicados:

duplicates = df[df.duplicated(keep=False)]
print(duplicates.head(20))

No elimines duplicados automáticamente hasta saber si realmente son inválidos.

Las filas repetidas pueden ser eventos legítimos.


8. Comprueba los duplicados por clave de negocio

Las comprobaciones de duplicados sobre la fila completa pueden pasar por alto los duplicados que realmente importan.

Ejemplo:

key_cols = ["customer_id", "order_id"]

duplicate_keys = df[
    df.duplicated(subset=key_cols, keep=False)
].sort_values(key_cols)

print(duplicate_keys.head(50))

Usa las columnas que deberían identificar de forma única una entidad o un evento de negocio.


9. Resume las columnas numéricas

print(df.describe().T)

Entre los campos útiles están:

  • el recuento (count)
  • la media
  • la desviación estándar
  • el mínimo
  • los cuartiles
  • el máximo

Es una forma rápida de detectar:

  • valores negativos imposibles
  • máximos extremos
  • ceros sospechosos
  • una escala inesperada

10. Resume todos los tipos de columna

summary = df.describe(include="all").T
print(summary)

Esto puede mostrar:

  • el recuento de valores únicos
  • los valores más frecuentes
  • la distribución numérica
  • los rangos de fechas, cuando se admiten

En datos muy anchos o de alta cardinalidad, prefiere resúmenes específicos en lugar de perfilar todo a ciegas.


11. Cuenta los valores únicos

unique_counts = df.nunique(dropna=False).sort_values()
print(unique_counts)

Útil para detectar:

  • columnas constantes
  • identificadores casi únicos
  • categorías con una cardinalidad inesperadamente alta
  • booleanos codificados como cadenas o enteros

Ejemplo:

constant_cols = df.columns[df.nunique(dropna=False) <= 1]
print(constant_cols.tolist())

12. Inspecciona los valores categóricos

print(df["status"].value_counts(dropna=False))

Muestra porcentajes:

print(
    df["status"]
    .value_counts(dropna=False, normalize=True)
    .mul(100)
    .round(2)
)

Úsalo para detectar:

  • variaciones ortográficas
  • categorías inesperadas
  • cadenas que equivalen a nulos, como "NULL" o "N/A"
  • valores predominantes

13. Inspecciona varias columnas categóricas de forma segura

for col in ["status", "country", "channel"]:
    print(f"\n--- {col} ---")
    print(df[col].value_counts(dropna=False).head(20))

Evita imprimir todos los valores únicos de las columnas de alta cardinalidad.

Limita la salida.


14. Inspecciona los rangos numéricos

numeric_summary = df.select_dtypes(include="number").agg(
    ["min", "max", "mean", "median"]
).T

print(numeric_summary)

Úsalo para validar las expectativas del dominio.

Preguntas de ejemplo:

  • ¿Puede la cantidad ser negativa?
  • ¿Debería un porcentaje superar 100?
  • ¿Puede una edad ser 250?
  • ¿Deberían los ingresos ser cero alguna vez?

15. Comprueba los rangos de fechas

Si la columna de fecha ya está interpretada:

print(df["event_time"].min())
print(df["event_time"].max())

Si todavía es texto:

parsed = pd.to_datetime(df["event_time"], errors="coerce")
print(parsed.min())
print(parsed.max())
print(parsed.isna().sum())

errors="coerce" es útil durante la inspección porque los valores inválidos se convierten en NaT.

No sobrescribas la columna original hasta entender qué valores no se pudieron interpretar.


16. Encuentra espacios sospechosos en columnas de texto

col = "customer_name"

leading_or_trailing_space = df[
    df[col].notna()
    & (df[col] != df[col].str.strip())
]

print(leading_or_trailing_space.head(20))

Los problemas de espacios pueden romper:

  • los joins
  • la deduplicación
  • las agrupaciones
  • las comparaciones de igualdad

17. Distingue las cadenas vacías de los nulos

empty_string_counts = (
    df.select_dtypes(include=["object", "string"])
    .apply(lambda s: s.eq("").sum())
    .sort_values(ascending=False)
)

print(empty_string_counts)

Una cadena vacía no es lo mismo que NaN o None.

Trátalas según la semántica del sistema de origen.


18. Encuentra cadenas comunes que equivalen a nulos

null_like_values = {"", "null", "none", "n/a", "na", "unknown"}

for col in df.select_dtypes(include=["object", "string"]).columns:
    s = df[col].astype("string").str.strip().str.lower()
    count = s.isin(null_like_values).sum()

    if count:
        print(col, count)

Úsalo solo como diagnóstico.

No conviertas globalmente estas cadenas en nulos sin confirmar su significado de negocio.


19. Inspecciona un registro por clave de negocio

row = df.loc[df["customer_id"].eq(12345)]
print(row)

Para varias condiciones:

row = df.loc[
    df["customer_id"].eq(12345)
    & df["order_id"].eq("A1007")
]

print(row)

Suele ser la forma más rápida de validar un registro problemático conocido.


20. Crea una función de inspección compacta y reutilizable

def inspect_dataframe(df: pd.DataFrame) -> None:
    print("Shape:", df.shape)

    print("\nDtypes:")
    print(df.dtypes)

    print("\nNulls:")
    print(df.isna().sum().sort_values(ascending=False).head(20))

    print("\nUnique values:")
    print(df.nunique(dropna=False).sort_values().head(20))

    print("\nDuplicate rows:", df.duplicated().sum())

    print("\nSample:")
    print(df.sample(min(5, len(df)), random_state=42))

Úsala para análisis locales rápidos.

En pipelines de producción, prefiere la validación y el logging estructurados en lugar de una inspección basada en print.

Qué significa el resultado

Señal Por qué importa
df.shape Confirma si el volumen ingerido se parece a lo que esperabas.
df.dtypes Muestra cómo interpretó pandas cada columna. Una inferencia incorrecta puede romper cálculos y joins.
recuento de valores no nulos Revela columnas rellenadas solo parcialmente.
porcentaje de nulos Ayuda a distinguir valores faltantes ocasionales de campos que faltan de forma sistemática.
nunique() Ayuda a identificar ID, constantes, categorías y cardinalidades sospechosas.
duplicados Señalan registros repetidos, pero solo después de definir qué significa «duplicado».
mín./máx. Exponen rápidamente valores numéricos o de fecha imposibles o sospechosos.
value_counts() Muestra la distribución de categorías y los valores inesperados.
uso de memoria Ayuda a prever si operaciones posteriores, como joins o copias, pueden volverse costosas.

Qué revisar

Columna numérica cargada como object o string

Causas posibles:

  • símbolos de moneda
  • comas
  • valores mezclados
  • tokens inválidos
  • inconsistencias de formato en el origen

No llames inmediatamente a astype(float).

Inspecciona primero los valores incorrectos.

Columna de fecha cargada como texto

Comprueba:

  • si hay varios formatos de fecha
  • los indicadores de zona horaria
  • los valores inválidos
  • la ambigüedad entre día y mes

Interpreta las fechas de forma explícita.

Porcentaje de nulos muy alto

Pregúntate si la columna es:

  • opcional
  • específica de un origen
  • de incorporación reciente
  • defectuosa aguas arriba

No rellenes automáticamente los nulos con cero o con una cadena vacía.

Cardinalidad inesperadamente alta en una columna de categorías

Causas posibles:

  • espacios
  • diferencias entre mayúsculas y minúsculas
  • ID almacenados en el campo equivocado
  • datos de origen sucios

Cardinalidad inesperadamente baja

Un identificador que debería ser único y que solo tiene unos pocos valores es una señal importante.

Verifica el origen y la lógica de transformación.

Rango mín./máx. muy amplio

Investiga:

  • inconsistencias de unidades
  • errores de signo
  • la conversión de moneda
  • un análisis mal formado
  • los valores atípicos

Claves de negocio duplicadas

Esto puede indicar:

  • duplicación en el origen
  • relaciones de uno a muchos
  • eventos reprocesados
  • una definición de clave incompleta

No elimines nada hasta que la granularidad de negocio esté clara.

Notas de producción

Las operaciones de inspección pueden ser costosas

Algunas operaciones recorren todas las filas:

  • isna().sum()
  • nunique()
  • duplicated()
  • describe()
  • value_counts()

En DataFrames muy grandes, evita ejecutar a ciegas todas las operaciones de perfilado.

Prefiere empezar con columnas específicas o con una exploración sobre muestras.

df.info(memory_usage="deep") puede ser lento

La inspección profunda de memoria mide con más precisión la memoria de los objetos y cadenas de Python.

Úsala cuando importe diagnosticar la memoria, no de forma automática en cada pipeline.

Los tipos de datos de pandas requieren interpretación

Ejemplos:

  • object puede contener cadenas, objetos de Python mezclados o valores inconsistentes
  • los dtypes de pandas que admiten nulos, como Int64, boolean y string, se comportan de forma distinta a los tipos primitivos de NumPy
  • los datetimes con zona horaria difieren de los datetimes sin zona horaria

No deduzcas la semántica de negocio solo a partir del dtype.

No modifiques los datos mientras los inspeccionas

Prefiere comprobaciones no destructivas.

Mal patrón:

df["amount"] = pd.to_numeric(df["amount"], errors="coerce")

durante la inspección inicial.

Más seguro:

parsed_amount = pd.to_numeric(df["amount"], errors="coerce")

Después, compara los fallos antes de reemplazar la columna original.

Las muestras pueden ocultar problemas poco frecuentes

head() y sample() son útiles, pero incompletos.

Usa comprobaciones sobre la columna completa para:

  • los nulos
  • los duplicados
  • la integridad de las claves
  • la validación de rangos

cuando la precisión importe.

Los pipelines de producción necesitan aserciones o reglas de calidad

La inspección manual sirve para explorar y solucionar problemas.

Con el tiempo, los pipelines de producción deberían codificar expectativas como:

assert df["order_id"].notna().all()
assert not df["order_id"].duplicated().any()

En sistemas más grandes, usa un framework de validación adecuado o controles de calidad a nivel de pipeline.

Errores comunes

1. Confiar en que head() es representativo

Las primeras filas pueden proceder todas de la misma partición, fecha, cliente u orden de clasificación.

Usa muestras aleatorias y comprobaciones agregadas.

2. Llamar a drop_duplicates() de inmediato

Los duplicados pueden ser legítimos.

Define primero la clave de negocio y la granularidad de los eventos.

3. Rellenar todos los nulos con cero

Cero y faltante no son lo mismo.

Esto puede corromper el significado de los datos sin que nadie lo note.

4. Suponer que pandas infirió el dtype correcto

Inspecciona siempre los dtypes después de la ingesta.

Los datos CSV, en particular, son vulnerables a problemas de inferencia.

5. Imprimir todos los valores únicos

Esto puede saturar los logs o los notebooks con columnas de alta cardinalidad.

Usa:

value_counts().head()

o nunique() primero.

6. Convertir datos incorrectos antes de inspeccionarlos

Usar errors="coerce" directamente sobre la columna de origen puede ocultar los valores inválidos originales.

Compara primero y luego limpia de forma deliberada.

7. Perfilar todas las columnas de un DataFrame enorme

Algunas operaciones de inspección recorren todos los datos.

Empieza por:

  • la forma
  • los dtypes
  • recuentos de nulos específicos
  • una muestra
  • las columnas críticas de negocio conocidas

Después, amplía solo donde haga falta.

Siguiente paso

Usa los hallazgos de la inspección para decidir qué hacer a continuación.

  • Dtypes incorrectos → normaliza los tipos con cuidado e inspecciona los fallos de conversión.
  • Valores faltantes → determina si son esperables antes de rellenarlos o eliminarlos.
  • Claves de negocio duplicadas → define la granularidad correcta y rastrea el origen de la duplicación aguas arriba.
  • Categorías inesperadas → normaliza espacios y mayúsculas/minúsculas solo después de validar la semántica.
  • Valores numéricos extremos → valida las unidades, la lógica del origen y los rangos de negocio.
  • Gran consumo de memoria → inspecciona los dtypes, la representación de las cadenas y la selección de columnas.
  • El esquema parece limpio → pasa al filtrado, los joins, las agregaciones o la validación.
  • Los datos son demasiado grandes para recorridos completos repetidos → reduce columnas o filas, o lleva el procesamiento a un motor distribuido.

← Todas las guías rápidas