How pichu2707/curso-de-python-basico works
Qué es este proyecto (tipo y propósito)
Este repo no es una app “deployable” (no hay backend/frontend, ni servicios). Es un repositorio educativo / curso de Python desde cero con:
• Scripts sueltos por lección (01…07, clases, etc.) que se ejecutan localmente con el intérprete de Python.
• Ejercicios en texto (ejercicios/) y soluciones (resultados/).
• Un mini-proyecto paquetizado para enseñar importación y estructura de paquetes: 07-importacion-paquetes/mi_proyecto/ con main.py y módulos en utilidades/.
• Material adicional: machine-learning/*.ipynb (notebooks) y algún .txt.
• Soporte de entorno: requirements.txt y un venv/ (local).
Cómo leer el file tree para derivar componentes arquitectónicos
Separa el repo en “containers”/zonas funcionales (muy útil para el diagrama):
Lecciones (scripts raíz)
Archivos:
• 01_comentarios.py
• 02_variable.py
• 03_flujos.py
• 04_control_errores.py
• 05_funciones.py
• 06_funciones_avanzadas.py
• 07_clases_python.py
Rol: ejemplos autocontenidos; normalmente dependen de stdlib y del runtime local. No forman una aplicación única, sino “módulos de aprendizaje”.
Módulo “Importación de paquetes” (carpeta 07-importacion-paquetes/)
Archivos clave:
• 07-01-librerias-python.py (stdlib / ejemplos de librerías)
• python-libreria-terceros.py (ejemplos con terceros)
• requirements.txt (dependencias)
• mi_proyecto/ (paquete real)
• venv/ (entorno local; normalmente NO se documenta como parte lógica, pero sí como “entorno de ejecución”)
Dentro de mi_proyecto/:
• main.py (entrypoint de ejemplo)
• utilidades/
• __init__.py (marca paquete)
• matematicas.py
• texto.py
• buenas_practicas.txt (guía / notas)
Rol: es la parte más “arquitectónica” porque ya hay estructura de paquete, un punto de entrada y módulos reutilizables.
Ejercicios vs soluciones
• ejercicios/*.txt: enunciados
• resultados/*.py: soluciones (ej. 02_res_variables.py, 03_res_flujos.py, etc.)
Rol: artefactos de aprendizaje. En el diagrama conviene mostrarlos como “recursos” conectados a cada tema.
Machine learning (notebooks)
• machine-learning/*.ipynb
• Customer-Churn-Model.txt
Rol: ejecución en Jupyter. Arquitectónicamente es otro “runtime” (kernel) distinto al “python script”.
Assets
• images/ (banner)
• README.md
Qué diagrama dibujar (recomendación: 3 vistas complementarias)
Para que sea “lo más exacto” y detallado (sin inventar infraestructura), yo dibujaría tres diagramas, tipo C4 adaptado a repo educativo:
Vista 1 — “Contexto” (muy simple)
Actores:
• *Alumno/Developer local*
• *Contenido en Twitch/YouTube* (fuente del curso; no interactúa con el código, pero explica el propósito)
Sistema: “Curso de Python (repo)”.
Flechas:
• Alumno clona repo → ejecuta scripts / notebooks → revisa resultados.
• Alumno consulta README / ejercicios.
> Esta vista evita que el lector piense que hay microservicios; deja claro que todo corre local.
Vista 2 — “Containers / Zonas del repositorio”
Aquí el repo es el “sistema” y dentro pones contenedores:
Entorno local (Python interpreter + opcional venv + requirements.txt)
Flechas típicas:
• “Python Interpreter” → ejecuta → “Lecciones” / “Soluciones”
• “Jupyter Kernel” → ejecuta → “Notebooks ML”
• “requirements.txt” → instala → “Dependencias de terceros” (si aplica)
• “Ejercicios” → guían → “Lecciones/Soluciones” (flecha semántica/documental)
Vista 3 — “Componentes del mini-proyecto paquetizado (mi_proyecto)"
Esta es la vista más “arquitectura de software” real:
• main.py (entrypoint)
• importa/llama a → utilidades.matematicas
• importa/llama a → utilidades.texto
• utilidades/__init__.py (exposición de API del paquete, si aplica)
• (opcional) relación con buenas_practicas.txt como “documentación interna”
Flechas: dependencias de import y llamadas.
Relaciones e interacciones que DEBEN aparecer
En este repo las relaciones importantes no son HTTP/DB, sino:
Ejecución
• “Usuario” ejecuta scripts con python archivo.py
• “Usuario” ejecuta notebooks en Jupyter
Dependencias de import
• Dentro de mi_proyecto: main.py depende de utilidades/*
• Dentro de 07-importacion-paquetes: scripts demuestran stdlib y terceros (refleja “tipo de dependencia”: stdlib vs third-party)
Flujo pedagógico
• README → referencia → archivos de lección (ej. 02_variable.py, 03_flujos.py, 04_control_errores.py)
• Ejercicios → se resuelven → resultados
Estas flechas “documentales” son válidas en un diagrama de arquitectura de un repo educativo (y evitan perder el propósito).
Patrones / principios a resaltar (lo que el diagrama debería “contar”)
• Separación por temas (cada script = tema).
• Modularidad + empaquetado (en mi_proyecto/):
• entrypoint separado de utilidades
• utilidades agrupadas por dominio (matemáticas vs texto)
• Entorno reproducible (requirements + venv) para demostrar instalación/aislamiento.
• Dos runtimes:
• Python scripts (CLI)
• Jupyter notebooks (kernel)
Tecnologías/librerías a etiquetar en el diagrama
Como el README no enumera librerías concretas, etiqueta a un nivel correcto (sin inventar):
• Python 3.x
• Stdlib Python (para 07-01-librerias-python.py)
• Third-party packages (representados por requirements.txt y python-libreria-terceros.py)
• Jupyter Notebook (para machine-learning/*.ipynb)
• Virtualenv/venv (como entorno local)
Reglas prácticas para este repo
• Cada carpeta top-level es un bloque.
• Cada archivo “entrypoint” es un bloque (scripts raíz, main.py, notebooks).
• Cada conjunto reutilizable es un bloque (el paquete mi_proyecto.utilidades y sus módulos).
• Añade flechas de:
• “ejecuta”
• “importa”
• “referencia/documenta”
Convenciones visuales recomendadas
• Rectángulos: código ejecutable (scripts, main.py)
• Carpeta/borde discontinuo: agrupaciones (dir)
• Documento: .txt, README, ejercicios
• Cilindro NO aplica (no hay DB); evita meter bases de datos ficticias
• Nube: dependencias externas (third-party)
• Etiquetas cortas y específicas
• “Python Interpreter (local)”
• “Jupyter Kernel”
• “Entry script: 03_flujos.py”
• “Package: mi_proyecto.utilidades”
• Flechas direccionales
• Usuario → (runs) → Script
• Script → (imports) → Module
• README → (references) → Lesson script
• requirements.txt → (installs) → Third-party libs
Checklist final (para que el diagrama sea “best & accurate”)
• [ ] No representar infra (API gateways, DBs, colas) que no existen.
• [ ] Mostrar explícitamente los dos modos de ejecución: scripts vs notebooks.
• [ ] Desglosar mi_proyecto a nivel de módulos (main/utilidades/matematicas/texto).
• [ ] Dibujar flechas de import/call en mi_proyecto.
• [ ] Incluir requirements.txt como origen de dependencias de terceros (sin nombrarlas si no están en README).
• [ ] Separar claramente: contenido pedagógico (ejercicios/README) vs código ejecutable (scripts/notebooks).
• [ ] Etiquetas consistentes (“runs”, “imports”, “references”, “installs”).