Explorar guías rápidas · Python
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
- Problema
- Respuesta rápida
- Código / comandos
- 1. Comprueba la forma y los nombres de columna
- 2. Inspecciona el esquema y el uso de memoria
- 3. Muestra las primeras y las últimas filas
- 4. Toma una muestra aleatoria de filas
- 5. Inspecciona los tipos de datos
- 6. Cuenta los nulos por columna
- 7. Comprueba las filas duplicadas
- 8. Comprueba los duplicados por clave de negocio
- 9. Resume las columnas numéricas
- 10. Resume todos los tipos de columna
- 11. Cuenta los valores únicos
- 12. Inspecciona los valores categóricos
- 13. Inspecciona varias columnas categóricas de forma segura
- 14. Inspecciona los rangos numéricos
- 15. Comprueba los rangos de fechas
- 16. Encuentra espacios sospechosos en columnas de texto
- 17. Distingue las cadenas vacías de los nulos
- 18. Encuentra cadenas comunes que equivalen a nulos
- 19. Inspecciona un registro por clave de negocio
- 20. Crea una función de inspección compacta y reutilizable
- Qué significa el resultado
- Qué revisar
- Columna numérica cargada como object o string
- Columna de fecha cargada como texto
- Porcentaje de nulos muy alto
- Cardinalidad inesperadamente alta en una columna de categorías
- Cardinalidad inesperadamente baja
- Rango mín./máx. muy amplio
- Claves de negocio duplicadas
- Notas de producción
- Las operaciones de inspección pueden ser costosas
- df.info(memory_usage="deep") puede ser lento
- Los tipos de datos de pandas requieren interpretación
- No modifiques los datos mientras los inspeccionas
- Las muestras pueden ocultar problemas poco frecuentes
- Los pipelines de producción necesitan aserciones o reglas de calidad
- Errores comunes
- 1. Confiar en que head() es representativo
- 2. Llamar a drop_duplicates() de inmediato
- 3. Rellenar todos los nulos con cero
- 4. Suponer que pandas infirió el dtype correcto
- 5. Imprimir todos los valores únicos
- 6. Convertir datos incorrectos antes de inspeccionarlos
- 7. Perfilar todas las columnas de un DataFrame enorme
- Siguiente paso
- 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:
objectpuede contener cadenas, objetos de Python mezclados o valores inconsistentes- los dtypes de pandas que admiten nulos, como
Int64,booleanystring, 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.
¿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.