De variables sueltas
a un pipeline
que se puede confiar

Clase 00

Introducción y calendario

Presentación institucional de la materia: por qué Python en ciencia de datos, y el mapa completo del cuatrimestre.

Conceptos clave

• Origen de Python (Guido van Rossum, CWI, 1989-1991) y por qué se volvió estándar en ciencia de datos.
• Estructura del curso: unidades 1 a 6, clases 1 a 21, dos parciales, simulacros, recuperatorio y final.
• Mapa temático completo: introducción → buenas prácticas/excepciones → NumPy/Pandas → limpieza/formatos → Matplotlib → Seaborn → estadística descriptiva/groupby → outliers/transformaciones → Scikit-learn → Git/GitHub → testing (Pytest/unittest).

Clase 02

Buenas prácticas (PEP8, docstrings) y manejo básico de errores

Transformar "código que funciona" en código legible, documentado y robusto ante errores — la base de calidad que se exige en toda la materia.

Conceptos clave

• PEP 8: indentación de 4 espacios, snake_case para variables/funciones, CapWords para clases, imports agrupados al inicio.
• PEP 257 / docstrings: triple comilla """...""", formato con Args, Returns, Raises; se accede con __doc__ y help().
• Comentarios efectivos: explican el "por qué" (decisiones, reglas de negocio), no repiten el "qué" del código.
• Excepciones: modelo try / except / else / finally; raise ... from exc para encadenar y conservar la causa original; excepciones propias heredando de ValueError/Exception.
• E/S de datos: TXT (open()), CSV (csv.DictReader), JSON (json.load/json.dump); pathlib.Path en vez de strings sueltos.

Ejemplo

def cargar_configuracion(ruta: str) -> dict:
    """Carga configuración desde un archivo JSON.

    Args:
        ruta: Ubicación del archivo.
    Returns:
        Diccionario con la configuración.
    Raises:
        FileNotFoundError: Si la ruta no existe.
    """
    try:
        texto = Path(ruta).read_text(encoding="utf-8")
        return json.loads(texto)
    except FileNotFoundError as exc:
        raise FileNotFoundError(f"No existe: {ruta}") from exc
    except json.JSONDecodeError as exc:
        raise ValueError("El archivo no contiene JSON válido") from exc

Clase 02.1

Manejo robusto de excepciones con JSON, TXT y CSV

Aplica el manejo de errores específicamente a leer/escribir archivos de datos: archivos faltantes, permisos, codificación, formatos inválidos y columnas ausentes.

Conceptos clave

• Principios: fallar pronto, ser específico (capturar FileNotFoundError, PermissionError, json.JSONDecodeError, csv.Error, UnicodeDecodeError según el caso), cerrar recursos con with, registrar contexto con logging.exception().
• Flujo recomendado: comprobar ruta → abrir seguro → parsear formato → validar estructura → convertir tipos → reportar/elevar.
• Excepción de dominio reutilizable, ej. class DataFileError(Exception), que envuelve errores técnicos con raise ... from exc.
• Capas de error distintas: lectura (FileNotFoundError, OSError), parseo (JSONDecodeError, csv.Error), validación (ValueError, KeyError), negocio (reglas propias).
• Pandas como alternativa de alto nivel: pd.read_csv(on_bad_lines="error"), pd.to_numeric(errors="raise").

Ejemplo

def leer_ventas_csv(path: str) -> list[dict]:
    columnas = {"fecha", "producto", "region_ventas", "cantidad_ventas"}
    with Path(path).open("r", encoding="utf-8", newline="") as archivo:
        lector = csv.DictReader(archivo)
        if not lector.fieldnames or not columnas.issubset(lector.fieldnames):
            faltantes = columnas - set(lector.fieldnames or [])
            raise ValueError(f"Columnas faltantes: {faltantes}")
        return list(lector)

Clase 02.2

Bibliotecas de ciencia de datos (repaso integrador)

El "mapa" del stack de Python para ciencia de datos — cuál biblioteca usar según la tarea — y puente hacia NumPy/Pandas y Matplotlib/Seaborn.

Conceptos clave

• NumPy: ndarray, cálculo vectorizado — np.array(), np.mean(), np.where(), np.reshape().
• pandas: Series/DataFrame — read_csv(), head(), describe(), groupby(), merge().
• Matplotlib: plt.plot(), plt.bar(), plt.hist(). seaborn: sns.scatterplot(), sns.heatmap().
• SciPy complementa NumPy (optimización, álgebra lineal, estadística). scikit-learn: patrón fit() / predict() / score().
• Pipeline integrador típico: entrada → validación → análisis (pandas+NumPy) → modelo → salida (reporte.csv + log).

Ejemplo

try:
    df = pd.read_csv("ventas.csv")
    df["monto"] = pd.to_numeric(df["monto"])
    resumen = df.groupby("producto")["monto"].sum()
except FileNotFoundError:
    print("No existe ventas.csv")
except KeyError as error:
    print(f"Columna faltante: {error}")

Clase 03

NumPy y Pandas: arreglos y datos tabulares

Los dos pilares técnicos del resto de la materia: cálculo vectorizado con NumPy y manipulación de datos tabulares con Pandas.

Conceptos clave

• ndarray: propiedades ndim, shape, size, dtype; conversión con .astype().
• Vectorización y broadcasting: operar arreglos enteros sin loops for explícitos.
• Indexación y máscaras booleanas: x[1:3], x[::2], arr[arr >= 18].
• Series y DataFrame: pd.Series(...), pd.DataFrame({...}); inspección con head(), info(), describe(), dtypes.
• loc vs iloc: df.loc[] por etiqueta (incluye ambos extremos), df.iloc[] por posición (excluye el final).
• Condiciones booleanas combinadas con &/| (nunca and/or).
• Limpieza: .str.replace(), pd.to_numeric(errors="coerce"), .fillna(), .drop_duplicates().
• Agrupar/pivotear/combinar: groupby().agg(), pd.pivot_table(), pd.merge(on=..., how=...).
• np.where() para una regla condicional, np.select() para varias reglas a la vez.

Ejemplo

ventas['precio'] = ventas['precio'].str.replace('$', '', regex=False)
ventas['precio'] = pd.to_numeric(ventas['precio'], errors='coerce')
ventas['precio'] = ventas['precio'].fillna(ventas['precio'].median())

condiciones = [reporte['minutos'] <= 25, reporte['minutos'] <= 40]
reporte['clasificacion'] = np.select(condiciones, ['Rápida', 'Normal'], default='Demorada')

Clase 04

Preparación y movimiento de datos: índices, limpieza y formatos

Indexación avanzada, combinar datasets (concat vs. merge), un proceso de limpieza basado en diagnóstico, y persistencia en CSV/Excel/SQL/JSON. La clase más orientada a "pipeline reproducible".

Conceptos clave

• concat apila (misma estructura, sin clave común) — merge relaciona (clave común, con cardinalidad 1:1/1:N/N:M). Son operaciones distintas que se confunden seguido.
• merge: tipos de join inner/left/right/outer; validate="many_to_one"; indicator=True para ver qué coincidió.
• Diagnóstico de calidad: df.isna().sum(), df.duplicated().sum(), df.nunique(), df.describe(include="all").
• Nulos: eliminar vs. imputar (mediana robusta, moda para categorías); marcar con una columna bandera df['col_faltante'].
• Tipos: pd.to_numeric(errors="coerce"), pd.to_datetime(errors="coerce", dayfirst=True), .astype("category").
• Formatos de E/S: CSV (sep, decimal, parse_dates), Excel (sheet_name=None para todas las hojas), SQL (read_sql_query con parámetros — nunca concatenar), JSON (json_normalize para aplanar estructuras anidadas).
• index=False al exportar, para no escribir el índice como columna.

Ejemplo

mascara = (ventas["importe_num"] >= 800) & ventas["producto"].isin(["A", "B"])
seleccion = ventas.loc[mascara, ["cliente_id", "producto", "importe_num"]]

ventas_clientes = ventas.merge(clientes, on="cliente_id", how="left",
                                validate="many_to_one", indicator=True)

df["importe_num"] = pd.to_numeric(
    df["importe"].str.replace("$", "", regex=False), errors="coerce"
)

Clase 05

Visualización con Matplotlib

Traducir una pregunta analítica en una visualización correcta (tendencia, comparación, distribución, relación), con la interfaz Figure/Axes. Énfasis en comunicación honesta, no sólo en sintaxis.

Conceptos clave

• Elección de gráfico según la pregunta: tendencia → líneas; comparación → barras (base en cero); distribución → histograma; relación → dispersión (no prueba causalidad).
• Anatomía: Figure = lienzo completo, Axes = área de dibujo; fig, ax = plt.subplots(...).
• Subgráficos múltiples: plt.subplots(n, m, figsize=...), indexado axes[i,j].
• Ajuste lineal con np.polyfit(x, y, 1) para una recta de tendencia sobre un scatter.
• Cierre: fig.tight_layout(), plt.show(), fig.savefig(..., dpi=...).

Ejemplo

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(meses, ventas, marker="o")
ax.set_title("Ventas mensuales"); ax.set_xlabel("Mes"); ax.set_ylabel("Unidades")
fig.tight_layout(); plt.show()

m = np.mean(df['minutos'])
plt.hist(df['minutos'], bins=np.arange(15,55,5), color='teal', edgecolor='white')
plt.axvline(m, color='red', linestyle='--', label=f'Media={m:.1f}')
plt.legend()

Clase 06

Visualización con Seaborn

Seaborn como interfaz estadística de alto nivel sobre Matplotlib, usada junto con Pandas: Pandas organiza → Seaborn visualiza → Matplotlib controla figura/exportación.

Conceptos clave

• sns.heatmap(df.corr(), annot=True): cerca de +1/-1 = asociación lineal fuerte; cerca de 0 = poca asociación lineal (no independencia).
• sns.boxplot() + sns.stripplot(): mediana, caja = rango intercuartílico, puntos externos = posibles atípicos.
• sns.pairplot(hue=...): matriz de relaciones por pares — útil con pocas variables, lento con muchas.
• Multivariado con un solo scatter: hue, size, style — una variable por canal visual, sin sobrecargar.
• Exportación para informes: PNG (dpi=300) para web/Office, PDF/SVG (vectorial) para impresión.

Ejemplo

corr = df.select_dtypes("number").corr()
sns.heatmap(corr, annot=True, cmap="vlag", vmin=-1, vmax=1)

sns.boxplot(data=df, x="Curso", y="Nota", hue="Curso", legend=False)
sns.stripplot(data=df, x="Curso", y="Nota", color="black", alpha=.4)

sns.scatterplot(data=df, x="Horas", y="Nota", hue="Curso", size="Proyectos",
                 style="Curso", sizes=(40, 220), alpha=.78)