NumPy y Pandas: el motor de la manipulacion de datos

import numpy as np
import time

# Dataset grande
np.random.seed(42)
N = 1_000_000
alturas = np.random.normal(170, 10, N)  # cm
pesos   = np.random.normal(70, 15, N)    # kg

# MANERA 1: loop ingenuo (Python puro, ~10x mas lento)
start = time.perf_counter()
imcs = []
for i in range(N):
    h_m = alturas[i] / 100
    imcs.append(pesos[i] / (h_m ** 2))
print(f"Loop Python:     {time.perf_counter() - start:.3f}s")

# MANERA 2: list comprehension (mejor, pero todavia lenta)
start = time.perf_counter()
imcs = [pesos[i] / ((alturas[i] / 100) ** 2) for i in range(N)]
print(f"List comp:       {time.perf_counter() - start:.3f}s")

# MANERA 3: vectorizacion NumPy (30-100x mas rapido)
start = time.perf_counter()
imcs_np = pesos / ((alturas / 100) ** 2)
print(f"NumPy vectorial: {time.perf_counter() - start:.3f}s")

# Las 3 dan el MISMO resultado. NumPy es ~50x mas rapido.

import numpy as np

# Normalizacion Z-score columna por columna (operacion clave de ML)
X = np.random.randn(100, 5)  # 100 muestras, 5 features
mean = X.mean(axis=0)        # shape (5,)
std  = X.std(axis=0)         # shape (5,)
X_norm = (X - mean) / std    # broadcasting: (100, 5) - (5,) → (100, 5)

print("X.shape:    ", X.shape)
print("mean.shape: ", mean.shape)
print("X_norm.mean(axis=0):", X_norm.mean(axis=0).round(10))  # ~[0, 0, 0, 0, 0]
print("X_norm.std(axis=0): ", X_norm.std(axis=0).round(10))   # ~[1, 1, 1, 1, 1]

# Ejemplo que FALLA: shapes incompatibles
A = np.ones((3, 4))
B = np.ones((3,))  # solo 1 dimension
try:
    C = A + B
except ValueError as e:
    print(f"\nError esperado: {e}")
# Solucion: reshape B a (1, 3) y luego broadcast a (?, 3) — pero
# eso no matchearia las 4 columnas. Mejor: usar (3, 1) si queremos
# restar por fila.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'region':   ['Norte', 'Sur', 'Centro', 'Norte', 'Sur'],
    'producto': ['A', 'B', 'A', 'B', 'A'],
    'monto':    [100, 200, 150, 300, 250],
    'fecha':    pd.to_datetime(['2024-01-01', '2024-01-02', '2024-01-03', '2024-01-04', '2024-01-05'])
}, index=['t1', 't2', 't3', 't4', 't5'])

# Por etiqueta
print(df.loc['t2', 'monto'])   # 200

# Por posicion
print(df.iloc[1, 2])          # 200

# Query: legible para filtros complejos
print(df.query("monto > 150 and region == 'Sur'"))

# Asignacion: USAR .loc, NUNCA encadenar []
df.loc[df['monto'] > 150, 'monto_alto'] = True
print(df)

import pandas as pd

# Wide format: 1 fila por anio, 1 columna por trimestre
wide = pd.DataFrame({
    'anio':    [2023, 2024],
    'Q1':      [100, 120],
    'Q2':      [110, 130],
    'Q3':      [105, 125],
    'Q4':      [115, 135],
})
print("Wide:")
print(wide)

# Long format: 1 fila por (anio, trimestre, ventas)
long = pd.melt(wide, id_vars=['anio'], var_name='trimestre', value_name='ventas')
print("\nLong (tidy):")
print(long)

# Para volver a wide: pivot
back_to_wide = long.pivot(index='anio', columns='trimestre', values='ventas')
print("\nDe vuelta a wide:")
print(back_to_wide)

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'region':  ['Norte', 'Norte', 'Sur', 'Sur', 'Centro', 'Centro'],
    'producto':['A', 'B', 'A', 'B', 'A', 'B'],
    'monto':   [100, 200, 150, 300, 120, 180],
    'unidades':[1, 2, 1, 3, 1, 2]
})

# 1) AGG: reduce a 1 fila por grupo. La salida es mas chica que la entrada.
print("=== agg ===")
print(df.groupby('region').agg(
    ventas_totales=('monto', 'sum'),
    venta_promedio=('monto', 'mean'),
    unidades_totales=('unidades', 'sum'),
))

# 2) TRANSFORM: conserva la forma original. Util para features.
print("\n=== transform ===")
df['pct_del_total'] = df.groupby('region')['monto'].transform(
    lambda x: x / x.sum()
)
print(df[['region', 'monto', 'pct_del_total']])

# 3) APPLY: maxima flexibilidad, minima performance.
# Solo usar cuando agg/transform no alcanzan.
print("\n=== apply ===")
print(df.groupby('region').apply(lambda g: g.nlargest(1, 'monto')))

import pandas as pd
import numpy as np

def eda_rapido(df: pd.DataFrame, target: str = None) -> None:
    """EDA de 5 minutos: 6 chequeos que SIEMPRE hay que hacer."""
    print(f"=== EDA rapido: {df.shape[0]} filas x {df.shape[1]} columnas ===\n")

    # 1. Tipos
    print("1. Tipos de dato:")
    print(df.dtypes.value_counts())

    # 2. Nulos
    print("\n2. Valores nulos:")
    nulos = df.isna().sum()
    if nulos.sum() == 0:
        print("  Sin nulos")
    else:
        print(nulos[nulos > 0].sort_values(ascending=False))

    # 3. Duplicados
    n_dups = df.duplicated().sum()
    print(f"\n3. Duplicados: {n_dups} ({n_dups/len(df):.1%})")

    # 4. Numericas: distribucion
    print("\n4. Estadisticas de columnas numericas:")
    print(df.describe().T.round(2))

    # 5. Categoricas: cardinalidad
    cat_cols = df.select_dtypes(include=['object', 'category']).columns
    if len(cat_cols) > 0:
        print("\n5. Cardinalidad de categoricas:")
        for c in cat_cols:
            n_unique = df[c].nunique()
            print(f"  {c}: {n_unique} valores unicos {'⚠️ ALTA' if n_unique > 50 else ''}")

    # 6. Target (si existe)
    if target and target in df.columns:
        print(f"\n6. Distribucion del target '{target}':")
        vc = df[target].value_counts(normalize=True).round(3)
        print(vc)
        if len(vc) > 2 and vc.min() < 0.1:
            print("  ⚠️  CLASES DESBALANCEADAS: considera stratified split y metricas como F1/PR-AUC.")

# Uso:
# eda_rapido(df, target='churn')