Data Analysis · Lección 12 de 19

EDA Completo: Análisis Exploratorio de Datos

El Análisis Exploratorio de Datos (EDA) es el proceso sistemático de examinar un dataset antes de cualquier modelado o decisión de negocio. No es un paso — es el paso. Un EDA mal hecho lleva a conclusiones equivocadas. Uno bien hecho te da la intuición necesaria para hacer las preguntas correctas.

120–150 min Prerrequisitos: Lecciones 04-11

Concepto teórico

¿Qué es el EDA y por qué importa?

El EDA fue formalizado por John Tukey en 1977 en su libro "Exploratory Data Analysis". La idea central es: antes de hacer modelos o pruebas, mirá los datos. Suena obvio, pero en la práctica muchos analistas saltan directo a las conclusiones sin entender la estructura de los datos.

El EDA responde 5 preguntas fundamentales:
1. ¿Qué forma tienen los datos? (dimensiones, tipos, estructura)
2. ¿Qué tan limpios están? (nulos, duplicados, inconsistencias)
3. ¿Cómo se distribuyen las variables numéricas? (centralidad, dispersión, outliers)
4. ¿Cómo se distribuyen las variables categóricas? (frecuencias, desbalances)
5. ¿Qué relaciones existen entre variables? (correlaciones, patrones)

Los 6 pasos del EDA profesional

#	Paso	Herramientas	Objetivo
1	Reconocimiento	`shape, dtypes, head, info`	Entender la estructura básica
2	Calidad	`isna, duplicated, describe`	Evaluar la salud de los datos
3	Univariado numérico	Histogramas, box plots, estadísticas	Distribución de cada variable numérica
4	Univariado categórico	value_counts, countplot	Distribución de cada variable categórica
5	Bivariado	Scatter, heatmap de correlación, boxplot por grupo	Relaciones entre pares de variables
6	Insights	Resumen escrito, visualización clave	Hallazgos accionables del negocio

Analogía del detective: un detective no empieza un caso con una teoría preconcebida. Primero examina la escena del crimen (paso 1), recolecta evidencia (pasos 2-4), busca conexiones (paso 5) y finalmente formula hipótesis (paso 6). El EDA es exactamente eso: investigar sin sesgo, dejar que los datos hablen.

En el trabajo real: cuando recibís un dataset nuevo en tu primer día de trabajo, la expectativa es que en las primeras 2-4 horas entregues un EDA con las características principales de los datos, problemas de calidad detectados y 3-5 hallazgos preliminares. Es tu primera oportunidad de demostrar seniority analítico.

EDA paso a paso: caso práctico completo

Paso 1: Reconocimiento del dataset

Lo primero siempre: ¿cuántas filas y columnas? ¿Qué tipo de datos hay? ¿Cómo se ven las primeras filas?

eda_paso01_reconocimiento.pyPython

import pandas as pd
import numpy as np

# Creamos un dataset realista de clientes bancarios
np.random.seed(42)
n = 200

df = pd.DataFrame({
    "Cliente_ID": range(1, n+1),
    "Edad": np.random.randint(18, 70, n),
    "Genero": np.random.choice(["M", "F"], n),
    "Ciudad": np.random.choice(["CABA", "Rosario", "Córdoba", "Mendoza", "Tucumán"], n, p=[0.35, 0.25, 0.20, 0.12, 0.08]),
    "Segmento": np.random.choice(["Premium", "Estándar", "Básico"], n, p=[0.15, 0.55, 0.30]),
    "Antigüedad": np.random.randint(0, 25, n),
    "Ingreso": np.abs(np.random.normal(400000, 180000, n)).astype(int),
    "Saldo": np.abs(np.random.normal(300000, 200000, n)).astype(int),
    "Productos": np.random.randint(1, 8, n),
    "Activo": np.random.choice([0, 1], n, p=[0.2, 0.8])
})

# Inyectar problemas realistas
df.loc[np.random.choice(n, 15, replace=False), "Ingreso"] = np.nan
df.loc[np.random.choice(n, 8, replace=False), "Saldo"] = np.nan
idx_dup = np.random.choice(n, 5, replace=False)
df = pd.concat([df, df.iloc[idx_dup]], ignore_index=True)

# === PASO 1: RECONOCIMIENTO ===
print(f"Dimensiones: {df.shape[0]} filas × {df.shape[1]} columnas")
print(f"\n=== Primeras 5 filas ===")
print(df.head())
print(f"\n=== Tipos de datos ===")
print(df.dtypes)
print(f"\n=== Info general ===")
print(f"Columnas numéricas: {list(df.select_dtypes('number').columns)}")
print(f"Columnas categóricas: {list(df.select_dtypes('object').columns)}")

Hacé clic en ▶ Ejecutar

Paso 2: Evaluación de calidad

¿Cuántos nulos? ¿Duplicados? ¿Valores atípicos? Este paso decide si podemos confiar en las métricas que calculemos después.

eda_paso02_calidad.pyPython

import pandas as pd
import numpy as np

np.random.seed(42)
n = 200
df = pd.DataFrame({
    "Cliente_ID": range(1, n+1),
    "Edad": np.random.randint(18, 70, n),
    "Ciudad": np.random.choice(["CABA", "Rosario", "Córdoba", "Mendoza"], n),
    "Segmento": np.random.choice(["Premium", "Estándar", "Básico"], n),
    "Ingreso": np.abs(np.random.normal(400000, 180000, n)).astype(int),
    "Saldo": np.abs(np.random.normal(300000, 200000, n)).astype(int),
    "Activo": np.random.choice([0, 1], n, p=[0.2, 0.8])
})
df.loc[np.random.choice(n, 15, replace=False), "Ingreso"] = np.nan
df.loc[np.random.choice(n, 8, replace=False), "Saldo"] = np.nan
idx_dup = np.random.choice(n, 5, replace=False)
df = pd.concat([df, df.iloc[idx_dup]], ignore_index=True)

# === PASO 2: CALIDAD ===
print("=" * 50)
print("REPORTE DE CALIDAD DE DATOS")
print("=" * 50)

# Nulos
nulos = df.isna().sum()
nulos_pct = round(df.isna().sum() / len(df) * 100, 1)
print("\nNulos por columna:")
for col in nulos[nulos > 0].index:
    print(f"  {col}: {nulos[col]} ({nulos_pct[col]}%)")

# Duplicados
dupes = df.duplicated().sum()
print(f"\nDuplicados: {dupes} filas ({round(dupes/len(df)*100, 1)}%)")

# Estadísticas básicas
print(f"\nResumen estadístico:")
print(df.describe().round(0))

Hacé clic en ▶ Ejecutar

Paso 3: Análisis univariado numérico

Distribuir cada variable numérica: histogramas, box plots, estadísticas. Detectar asimetrías y outliers.

eda_paso03_univariado_num.pyPython

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np

np.random.seed(42)
n = 200
df = pd.DataFrame({
    "Edad": np.random.randint(18, 70, n),
    "Ingreso": np.abs(np.random.normal(400000, 180000, n)).astype(int),
    "Saldo": np.abs(np.random.normal(300000, 200000, n)).astype(int),
    "Productos": np.random.randint(1, 8, n)
})

num_cols = ["Edad", "Ingreso", "Saldo", "Productos"]

fig, axes = plt.subplots(2, 2, figsize=(12, 8))

for i, col in enumerate(num_cols):
    ax = axes[i // 2, i % 2]
    sns.histplot(data=df, x=col, kde=True, bins=20, ax=ax, color="#2196F3")
    media = df[col].mean()
    mediana = df[col].median()
    ax.axvline(mediana, color="#FF5722", linestyle="--", linewidth=1.5, label=f"Mediana: {mediana:,.0f}")
    ax.set_title(f"Distribución: {col}", fontweight="bold")
    ax.legend(fontsize=8)

fig.suptitle("Análisis Univariado — Variables Numéricas", fontsize=14, fontweight="bold", y=1.01)
plt.tight_layout()
plt.show()

# Tabla resumen
for col in num_cols:
    s = df[col]
    asimetria = "→ derecha" if s.mean() > s.median() else "← izquierda" if s.mean() < s.median() else "simétrica"
    print(f"{col:12s}: media={s.mean():>10,.0f}  mediana={s.median():>10,.0f}  std={s.std():>10,.0f}  {asimetria}")

Hacé clic en ▶ Ejecutar

Paso 4: Análisis univariado categórico

¿Cómo se distribuyen las categorías? ¿Hay desbalances? Las frecuencias categóricas revelan sesgos en la muestra.

eda_paso04_univariado_cat.pyPython

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np

np.random.seed(42)
n = 200
df = pd.DataFrame({
    "Ciudad": np.random.choice(["CABA", "Rosario", "Córdoba", "Mendoza", "Tucumán"], n, p=[0.35, 0.25, 0.20, 0.12, 0.08]),
    "Segmento": np.random.choice(["Premium", "Estándar", "Básico"], n, p=[0.15, 0.55, 0.30]),
    "Activo": np.random.choice(["Sí", "No"], n, p=[0.80, 0.20])
})

cat_cols = ["Ciudad", "Segmento", "Activo"]

fig, axes = plt.subplots(1, 3, figsize=(14, 5))

for i, col in enumerate(cat_cols):
    order = df[col].value_counts().index
    sns.countplot(data=df, x=col, ax=axes[i], palette="Set2", order=order)
    axes[i].set_title(f"Distribución: {col}", fontweight="bold")
    axes[i].tick_params(axis='x', rotation=30)
    # Agregar porcentaje sobre cada barra
    total = len(df)
    for p in axes[i].patches:
        pct = f"{p.get_height()/total*100:.0f}%"
        axes[i].annotate(pct, (p.get_x() + p.get_width()/2, p.get_height()),
                         ha='center', va='bottom', fontsize=9, fontweight='bold')

fig.suptitle("Análisis Univariado — Variables Categóricas", fontsize=14, fontweight="bold", y=1.01)
plt.tight_layout()
plt.show()

for col in cat_cols:
    print(f"\n{col}:")
    for val, cnt in df[col].value_counts().items():
        print(f"  {val}: {cnt} ({cnt/len(df)*100:.0f}%)")

Hacé clic en ▶ Ejecutar

Paso 5: Análisis bivariado — Relaciones entre variables

¿Qué variables se relacionan? Correlaciones entre numéricas, distribuciones numéricas segmentadas por categóricas.

eda_paso05_bivariado.pyPython

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np

np.random.seed(42)
n = 200
antiguedad = np.random.randint(0, 25, n)
ingreso = antiguedad * 25000 + np.abs(np.random.normal(150000, 80000, n))

df = pd.DataFrame({
    "Antigüedad": antiguedad,
    "Ingreso": ingreso.astype(int),
    "Saldo": (ingreso * 0.5 + np.random.normal(0, 50000, n)).astype(int),
    "Segmento": np.random.choice(["Premium", "Estándar", "Básico"], n, p=[0.15, 0.55, 0.30]),
    "Productos": np.clip(antiguedad * 0.3 + np.random.normal(2, 1, n), 1, 7).astype(int)
})

fig, axes = plt.subplots(2, 2, figsize=(12, 10))

# 1. Heatmap de correlación
corr = df.select_dtypes("number").corr()
sns.heatmap(corr, annot=True, cmap="RdYlBu_r", center=0, fmt=".2f",
            ax=axes[0, 0], square=True)
axes[0, 0].set_title("Correlaciones", fontweight="bold")

# 2. Scatter: Antigüedad vs Ingreso
sns.regplot(data=df, x="Antigüedad", y="Ingreso", ax=axes[0, 1],
            scatter_kws={"alpha": 0.4, "s": 20}, line_kws={"color": "#E91E63"})
axes[0, 1].set_title("Antigüedad vs Ingreso", fontweight="bold")

# 3. Boxplot: Ingreso por Segmento
sns.boxplot(data=df, x="Segmento", y="Ingreso", ax=axes[1, 0],
            palette="Set2", order=["Premium", "Estándar", "Básico"])
axes[1, 0].set_title("Ingreso por Segmento", fontweight="bold")

# 4. Barplot: Productos promedio por Segmento
sns.barplot(data=df, x="Segmento", y="Productos", ax=axes[1, 1],
            palette="Set2", order=["Premium", "Estándar", "Básico"], errorbar="sd")
axes[1, 1].set_title("Productos por Segmento", fontweight="bold")

fig.suptitle("Análisis Bivariado", fontsize=14, fontweight="bold", y=1.01)
plt.tight_layout()
plt.show()

print("Hallazgos clave:")
print(f"  Corr(Antigüedad, Ingreso) = {corr.loc['Antigüedad','Ingreso']:.2f}")
print(f"  Corr(Ingreso, Saldo) = {corr.loc['Ingreso','Saldo']:.2f}")

Hacé clic en ▶ Ejecutar

Referencia rápida — Checklist de EDA

Paso	Código clave	¿Qué buscás?
Dimensiones	`df.shape`	Filas × columnas
Tipos	`df.dtypes`	¿object donde debería ser number?
Head	`df.head()`	¿Los datos tienen sentido?
Nulos	`df.isna().sum()`	¿Cuántos y dónde?
Duplicados	`df.duplicated().sum()`	¿Filas repetidas?
Describe	`df.describe()`	Estadísticas rápidas
Distribución num	`sns.histplot(kde=True)`	Forma, asimetría
Distribución cat	`df["col"].value_counts()`	Desbalances
Outliers	`sns.boxplot()`	Valores atípicos
Correlaciones	`sns.heatmap(df.corr())`	Relaciones lineales
Relación num-cat	`sns.boxplot(x=cat, y=num)`	¿La distribución varía por grupo?

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Reconocimiento con shape y dtypes

Imprimí las dimensiones del DataFrame y los tipos de datos. Debe incluir la palabra int.

ejercicio_01.pyDebe incluir "int"

import pandas as pd
import numpy as np
np.random.seed(42)

df = pd.DataFrame({
    "Edad": np.random.randint(18, 65, 50),
    "Ingreso": np.random.normal(400000, 100000, 50).astype(int),
    "Ciudad": np.random.choice(["CABA","Rosario","Córdoba"], 50)
})

# Imprimí shape y dtypes

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Reporte de nulos y duplicados

Imprimí la cantidad de nulos por columna y el total de duplicados. Debe incluir el número 0.

ejercicio_02.pyDebe incluir "0"

import pandas as pd
import numpy as np
np.random.seed(42)

df = pd.DataFrame({
    "Nombre": ["Ana","Luis","Pedro","Ana","María"],
    "Edad": [25, 30, np.nan, 25, 28],
    "Saldo": [500, np.nan, 300, 500, 400]
})

# Nulos por columna + duplicados

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: describe()

Ejecutá describe() sobre el DataFrame. Debe incluir mean.

ejercicio_03.pyDebe incluir "mean"

import pandas as pd
import numpy as np
np.random.seed(42)

df = pd.DataFrame({
    "Edad": np.random.randint(18, 65, 30),
    "Ingreso": np.random.normal(400000, 100000, 30).astype(int),
    "Productos": np.random.randint(1, 8, 30)
})

# describe()

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Histograma con mediana

Graficá la distribución de Ingreso con sns.histplot(kde=True) y agregá una línea en la mediana. Imprimí Univariado OK.

ejercicio_04.pyDebe imprimir "Univariado OK"

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np
np.random.seed(42)

df = pd.DataFrame({"Ingreso": np.random.normal(400000, 120000, 100).astype(int)})

# Histograma + mediana + print

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: value_counts con porcentaje

Imprimí el value_counts(normalize=True) de Segmento para ver porcentajes. Debe incluir la palabra Estándar.

ejercicio_05.pyDebe incluir "Estándar"

import pandas as pd
import numpy as np
np.random.seed(42)

df = pd.DataFrame({
    "Segmento": np.random.choice(["Premium","Estándar","Básico"], 100, p=[0.15,0.55,0.30])
})

# value_counts normalizado (porcentajes)

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Boxplot por categoría

Graficá un boxplot de Ingreso por Segmento. Imprimí Bivariado OK.

ejercicio_06.pyDebe imprimir "Bivariado OK"

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np
np.random.seed(42)

df = pd.DataFrame({
    "Segmento": np.random.choice(["Premium","Estándar","Básico"], 90),
    "Ingreso": np.random.normal(400000, 120000, 90).astype(int)
})

# Boxplot por segmento

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Heatmap de correlaciones

Calculá la matriz de correlación y graficála con heatmap. Imprimí la correlación entre Antigüedad e Ingreso. Debe incluir un número decimal (ej: 0.).

ejercicio_07.pyDebe incluir "0."

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np
np.random.seed(42)

ant = np.random.randint(1, 20, 50)
df = pd.DataFrame({
    "Antigüedad": ant,
    "Ingreso": (ant * 30000 + np.random.normal(0, 50000, 50)).astype(int),
    "Saldo": np.random.normal(300000, 100000, 50).astype(int)
})

# Correlación + heatmap + print

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Limpieza + análisis

El dataset tiene nulos y duplicados. Limpiálo (fillna con mediana, drop_duplicates), después imprimí media y mediana del saldo. Debe incluir Limpio.

ejercicio_08.pyDebe incluir "Limpio"

import pandas as pd
import numpy as np
np.random.seed(42)

df = pd.DataFrame({
    "ID": [1,2,3,4,5,1,2],
    "Saldo": [500, np.nan, 300, 800, np.nan, 500, np.nan]
})

# 1. fillna con mediana
# 2. drop_duplicates por ID
# 3. Imprimí "Limpio" + media + mediana

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Dashboard EDA de 4 gráficos

Creá 4 subplots: histograma de Ingreso, countplot de Segmento, boxplot Ingreso×Segmento, scatter Antigüedad×Ingreso. Imprimí EDA dashboard.

ejercicio_09.pyDebe imprimir "EDA dashboard"

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np
np.random.seed(42)

df = pd.DataFrame({
    "Segmento": np.random.choice(["Premium","Estándar","Básico"], 60),
    "Antigüedad": np.random.randint(1, 20, 60),
    "Ingreso": np.random.normal(400000, 120000, 60).astype(int)
})

# fig, axes = plt.subplots(2, 2, ...)
# 4 gráficos del EDA

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Reporte EDA con insights escritos

Generá un reporte EDA completo: (1) dimensiones, (2) nulos %, (3) estadísticas por segmento, (4) un hallazgo clave. Debe incluir la palabra Hallazgo.

ejercicio_10_desafio.pyDebe incluir "Hallazgo"

import pandas as pd
import numpy as np
np.random.seed(42)

n = 100
seg = np.random.choice(["Premium","Estándar","Básico"], n, p=[0.15, 0.55, 0.30])
df = pd.DataFrame({
    "Segmento": seg,
    "Ingreso": np.where(seg=="Premium", np.random.normal(800000,100000,n),
               np.where(seg=="Estándar", np.random.normal(400000,80000,n),
                        np.random.normal(150000,50000,n))).astype(int),
    "Productos": np.where(seg=="Premium", np.random.randint(4,8,n),
                 np.where(seg=="Estándar", np.random.randint(2,5,n),
                          np.random.randint(1,3,n)))
})
df.loc[np.random.choice(n, 5, replace=False), "Ingreso"] = np.nan

# Reporte EDA completo con insights

Hacé clic en ▶ Ejecutar

Resumen y conexión

El EDA sigue 6 pasos: reconocimiento → calidad → univariado numérico → univariado categórico → bivariado → insights.
Las primeras 4 líneas de cualquier EDA: shape, dtypes, isna().sum(), describe().
Los histogramas revelan la forma de los datos (simétricos, sesgados, bimodales).
Los box plots detectan outliers automáticamente y comparan distribuciones por categoría.
El heatmap de correlaciones identifica relaciones lineales entre todas las variables numéricas.
Siempre terminá con insights escritos — los gráficos sin interpretación no generan valor.

En la siguiente lección (13 · NumPy fundamentos) vas a profundizar en la biblioteca que está debajo de pandas: arrays de alto rendimiento, operaciones vectorizadas y álgebra lineal básica.

Recursos: pandas — Calculate statistics · Seaborn Tutorial

Hecho con ❤️ por Rodri Gonzalez