Estructura del curso, tests de entrada, repositorio personal y aprendizaje con IA.

Niveles, módulos y lecciones

El curso tiene ocho niveles, del 0 (Python desde cero) al 7 (producción y proyecto final). Cada nivel se divide en módulos y cada módulo en lecciones como esta. La figura de la cabecera muestra las horas orientativas de cada nivel: el total ronda las 750–850 horas.

flowchart TB
  L[Lección] --> E[Ejercicios] --> A[Autoevaluación]
  A --> M{¿Todo claro?}
  M -- sí --> S[Siguiente lección]
  M -- no --> L
  S -. al final del nivel .-> P[Proyecto del nivel]
  P -. al final del curso .-> C[Proyecto final]

Todas las lecciones tienen las mismas piezas:

• Objetivos al principio: lo que deberías saber hacer al terminar.
• Contenido con código ejecutable. Todo el código del curso se ha ejecutado de verdad y las salidas que ves son reales. Los datos del nivel 0 son sintéticos (generados con semilla) para que obtengas exactamente el mismo resultado.
• Ejercicios con la solución plegada. Intenta resolverlos antes de abrirla.
• Autoevaluación: tres a cinco preguntas con la respuesta y su porqué.
• Ideas clave y recursos para profundizar.

Los niveles son acumulativos, pero no hay que recorrerlos todos en orden. El temario propone cuatro rutas según el punto de partida:

Tests de entrada: cuándo saltarse un nivel

Cada nivel tiene un prerrequisito explícito (en la página del nivel). Para saber si puedes saltártelo, usa sus autoevaluaciones como test de entrada: recorre las de todas sus lecciones sin mirar el contenido. Si respondes bien a todas y entiendes el porqué de cada respuesta, pasa al nivel siguiente. Si fallas las de un módulo, haz solo ese módulo.

Dos avisos. El primero: el nivel 0 parece prescindible para quien ya programa, pero incluye herramientas que han cambiado mucho en dos años (uv, pandas 3.0, Polars, DuckDB); revisa al menos el módulo 0.5. El segundo: las autoevaluaciones miden conceptos, no soltura. Si una pregunta te parece fácil pero no podrías escribir el código del ejercicio sin ayuda, no te saltes el módulo.

Tu repositorio del curso

Todo lo que escribas durante el curso vive en un único repositorio Git. Empieza con unas pocas carpetas y termina siendo tu framework personal: las funciones del nivel 1 (descarga y limpieza de datos) las usará el backtest del nivel 2, y las dos las usará el sistema en real del nivel 4.

La estructura recomendada, creada con pathlib (se ve en el módulo 0.4; aquí solo importa el resultado):

import tempfile
from pathlib import Path

raiz = Path(tempfile.mkdtemp()) / "ppt-curso"
carpetas = ["datos/brutos", "datos/procesados", "notebooks", "src/ppt",
            "tests", "informes"]
for carpeta in carpetas:
    (raiz / carpeta).mkdir(parents=True)
(raiz / "src/ppt/__init__.py").touch()
(raiz / "README.md").write_text("# Mi repositorio del curso\n")
ignorar = [".venv/", ".env", "datos/brutos/", "__pycache__/"]
(raiz / ".gitignore").write_text("\n".join(ignorar) + "\n")

for ruta in sorted(raiz.rglob("*")):
    nivel = len(ruta.relative_to(raiz).parts) - 1
    print("    " * nivel + ruta.name + ("/" if ruta.is_dir() else ""))

.gitignore
README.md
datos/
    brutos/
    procesados/
informes/
notebooks/
src/
    ppt/
        __init__.py
tests/

• datos/brutos/: lo que descargas, tal cual. No se versiona (puede pesar mucho y a veces su licencia no permite redistribuirlo); se puede volver a descargar.
• datos/procesados/: datos limpios, en Parquet a partir del nivel 1.
• notebooks/: exploración. Lo que funciona en un notebook se mueve a src/.
• src/ppt/: tu código reutilizable, como paquete de Python.
• tests/: pruebas con pytest (lección 0.4.5).
• informes/: los informes que generan los proyectos.

En la práctica no se crea con Python, sino con uv y Git desde la terminal. Lo harás en el módulo 0.2; estos son los comandos, para que los reconozcas:

uv init ppt-curso          # proyecto con pyproject.toml (lección 0.2.2)
cd ppt-curso
git init                   # repositorio (lección 0.2.5)
git add .
git commit -m "Estructura inicial del curso"

Aprender con IA: las reglas del curso

Los asistentes de código (Copilot, Claude Code, Codex, Cursor) escriben en segundos funciones que a un principiante le llevan una hora. Eso los hace muy útiles para quien sabe juzgar el resultado y peligrosos para quien no: el código que generan es plausible, y plausible no es lo mismo que correcto. En trading, un error plausible —una señal desplazada un día de más o de menos, un coste olvidado— produce un backtest bonito y una estrategia que pierde dinero.

Por eso el curso tiene tres reglas:

1. Nivel 0 sin asistente. Escribe y lee el código de este nivel tú mismo. Puedes preguntar dudas conceptuales a un chat, pero no pidas el código de los ejercicios.
2. Después, la IA propone y tú decides. A partir del nivel 1, usa asistentes con un flujo fijo: primero escribes la prueba que debe pasar el código, después pides el código, lo lees entero, ejecutas las pruebas y solo entonces haces commit.
3. Nada sensible en el prompt. Ni claves, ni datos con licencia que no permita compartirlos, ni datos personales.

flowchart TB
  T[Escribes la prueba] --> P[Pides el código] --> L[Lo lees entero]
  L --> X{¿Pasan las pruebas?}
  X -- no --> P
  X -- sí --> C[Commit]

La lección 0.2.6 vuelve sobre los asistentes con más detalle, y el nivel 6 dedica un módulo entero a usarlos como copiloto de investigación.

Ejercicios

1. Elige tu ruta. Con la figura de rutas y la página de cada nivel, escribe en el README.md de tu repositorio (o en una nota, si aún no lo tienes) por qué nivel empiezas, qué niveles harás completos y cuáles solo en parte.

2. Escribe el .gitignore de tu repositorio. Además de lo de la lección, ¿qué otras cosas no deberían versionarse en un proyecto de trading?

3. Pide a un asistente de IA una función de Python que calcule la rentabilidad diaria de una serie de precios, sin darle más contexto. Antes de leer la respuesta, escribe tres preguntas cuya respuesta debería estar en el código.