--- title: "0.1.3 Estructura del curso, repositorio y uso de la IA" description: "Cómo se organiza el curso en niveles, módulos y lecciones, cuándo saltarse un nivel, el repositorio personal y las reglas para aprender con IA." url: "https://pythonparatrading.com/curso-python-trading/nivel-0/estructura-del-curso-y-aprendizaje-con-ia/" lang: "es" image: "https://pythonparatrading.com/og/curso-python-trading/nivel-0/estructura-del-curso-y-aprendizaje-con-ia.png" --- # 0.1.3 · Estructura del curso, tests de entrada, repositorio personal y aprendizaje con IA > Ocho niveles, un repositorio que crece contigo y unas reglas claras para usar asistentes de IA sin dejar de aprender. Esta lección explica cómo recorrer el curso y qué tener preparado antes del módulo 0.2. - Curso: [Nivel 0: Python desde cero y mentalidad de datos](https://pythonparatrading.com/curso-python-trading/nivel-0/) - Módulo: 0.1 · Bienvenida y expectativas - Duración: 25 min - Requisitos: [0.1.1 · Trading sistemático, algorítmico y cuantitativo frente al discrecional](https://pythonparatrading.com/curso-python-trading/nivel-0/trading-sistematico-algoritmico-cuantitativo/) ## Al terminar esta lección - Conocer la estructura del curso (niveles, módulos, lecciones y proyectos) y elegir la ruta que corresponde a tu punto de partida. - Usar las autoevaluaciones como test de entrada para decidir si puedes saltarte un nivel. - Preparar la estructura del repositorio personal que acompaña todo el curso. - Aplicar las reglas del curso para aprender con asistentes de IA: primero sin ayuda, después con revisión y tests. ## 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. ```mermaid 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: *Fig. — Rutas por el curso según el punto de partida.* Rejilla de cuatro perfiles por niveles. Desde cero: niveles 0, 1, 2, 4, 3, 5, 6 y 7, en ese orden. Trader discrecional: test de entrada y niveles 0 a 4, con 5 y 6 optativos. Programador o data scientist: test y niveles 1 a 7. Quant avanzado: módulos sueltos de los niveles 3, 5, 6 y 7. ## 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): ```python 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 "")) ``` ```output .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: ```bash 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. ```mermaid 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. **Solución.** No hay una respuesta única. Una buena respuesta cita el prerrequisito de cada nivel que te saltas y por qué lo cumples. Por ejemplo: «Empiezo por el nivel 0 completo: no he programado nunca. Después 1, 2 y 4, como en la ruta de principiante; el 3 lo haré solo con futuros, que es lo que opero». 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? **Solución.** Además de `.venv/`, `.env`, `datos/brutos/` y `__pycache__/`: los ficheros de estado de un sistema en real (posiciones, órdenes), los logs, las salidas grandes de los notebooks, los ficheros de configuración con datos de la cuenta del bróker y los ficheros de sistema del editor (`.vscode/`, `.idea/`) si no los compartes a propósito. La regla: no se versiona lo que es secreto, lo que se puede regenerar o lo que pesa mucho. 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. **Solución.** Algunas: ¿usa el cierre ajustado o sin ajustar (dividendos y splits, nivel 1)? ¿Rentabilidad simple o logarítmica (lección 0.7.1)? ¿Qué hace con el primer día, que no tiene día anterior? ¿Ordena la serie por fecha o supone que ya lo está? ¿Qué pasa si hay huecos o precios repetidos? Si el código no responde a alguna, el asistente ha tomado la decisión por ti sin decírtelo: esa es la razón de leerlo entero. ## Autoevaluación 1. Ya programas en Python y usas pandas a diario, pero no conoces los mercados. ¿Por dónde empiezas? - A. Por la lección 0.1.1 y todo el nivel 0 en orden - B. Por las autoevaluaciones del nivel 0; si las superas, por el nivel 1 - C. Por el nivel 5, que es el de machine learning - D. Por el proyecto final *Respuesta B: Por las autoevaluaciones del nivel 0; si las superas, por el nivel 1.* La ruta de programador o data scientist empieza con el test y entra por el nivel 1, que es donde están los mercados. Las autoevaluaciones del nivel 0 sirven para comprobarlo. 2. ¿Qué no debe entrar nunca en el repositorio del curso? - A. Los notebooks - B. Los tests - C. El fichero `.env` con claves de API - D. El `README.md` *Respuesta C: El fichero `.env` con claves de API.* Una clave subida a un repositorio, aunque sea privado y aunque se borre después, hay que darla por comprometida: queda en el historial de Git. Por eso `.env` va en `.gitignore` desde el primer commit. 3. Según las reglas del curso, ¿cuándo se empieza a usar un asistente de código con IA? - A. Desde la primera lección, para ir más rápido - B. Nunca - C. Después del nivel 0, una vez sabes escribir y leer código sin ayuda, y siempre con revisión y tests - D. Solo en el proyecto final *Respuesta C: Después del nivel 0, una vez sabes escribir y leer código sin ayuda, y siempre con revisión y tests.* Un asistente acelera a quien sabe juzgar su resultado. En el nivel 0 se aprende a escribir y leer código; a partir de ahí, la IA propone y tú revisas, pruebas y versionas. ## Ideas clave - El curso tiene 8 niveles acumulativos; cada nivel cierra con un proyecto y el curso con un proyecto final. - Las autoevaluaciones de un nivel hacen de test de entrada: si las superas todas, puedes saltártelo. - Un único repositorio Git crece durante todo el curso y acaba siendo tu framework personal. - Las claves y los datos brutos no se suben nunca: `.env` y `datos/brutos/` van en `.gitignore` desde el primer commit. - La IA propone, tú decides: primero sin asistente; después, con revisión, tests y control de versiones. ## Recursos ### Documentación - [Curso Python para Trading: mapa de niveles y rutas](https://pythonparatrading.com/curso-python-trading/) · pythonparatrading.com - [uv: trabajar con proyectos (documentación oficial)](https://docs.astral.sh/uv/guides/projects/) · docs.astral.sh - [Pro Git en español: guardar cambios en el repositorio](https://git-scm.com/book/es/v2/Fundamentos-de-Git-Guardando-cambios-en-el-Repositorio) · git-scm.com - [GitHub Docs: ignorar archivos con .gitignore](https://docs.github.com/es/get-started/git-basics/ignoring-files) · docs.github.com - [GitHub Docs: análisis de secretos](https://docs.github.com/es/code-security/secret-scanning/introduction/about-secret-scanning) · docs.github.com Lección anterior: [0.1.2 · Expectativas realistas: costes, tiempo y riesgo de pérdida](https://pythonparatrading.com/curso-python-trading/nivel-0/expectativas-realistas-costes-tiempo-riesgo/) Lección siguiente: [0.2.1 · Instalación de Python con uv: versiones y ciclo de soporte](https://pythonparatrading.com/curso-python-trading/nivel-0/instalar-python-con-uv/)