Curso orientado a personas sin experiencia previa en programación. Aprenderemos a pensar y razonar como programadores, antes de escribir código Python.

Módulo 1. Introducción a la programación y pensamiento computacional

• Qué es programar y qué problemas permite resolver.
• Algoritmos e instrucciones ordenadas.
• Descomposición de problemas.
• Pensamiento lógico, patrones y abstracción.
• Pseudocódigo y diagramas de flujo.
• Predicción de resultados.
• Errores como parte del aprendizaje.

Módulo 2. Preparación del entorno

• Qué es Python y cómo se ejecuta.
• Instalación en Windows y Linux.
• Editores de código e IDE.
• Archivos .py y organización del trabajo.
• Primer programa.
• Ejecución desde el editor y la terminal.
• Comandos básicos de terminal.
• Problemas habituales de instalación.

Módulo 3. Cómo leer y escribir código

• Instrucciones, expresiones y sintaxis.
• Orden de ejecución.
• Comentarios e indentación.
• Errores de sintaxis.
• Interpretación de mensajes de error.
• Modificación de programas existentes.
• Convenciones de legibilidad.

Módulo 4. Variables, tipos de datos y operadores

• Variables y asignación.
• Nombres significativos.
• Números enteros y decimales.
• Booleanos, texto y None.
• Tipado dinámico y objetos.
• Conversión de tipos.
• Operadores y prioridades.
• Igualdad, identidad y pertenencia.
• Errores de tipos y precisión numérica.

Módulo 5. Entrada, salida y cadenas de texto

• print() e input().
• Conversión y validación de datos.
• Cadenas y concatenación.
• Índices y segmentación.
• Métodos de texto.
• f-strings.
• Caracteres especiales, Unicode y UTF-8.
• Interacción clara con el usuario.

Módulo 6. Condiciones y toma de decisiones

• Condiciones.
• if, elif y else.
• Condiciones compuestas.
• Valores verdaderos y falsos.
• Condiciones anidadas.
• Expresiones condicionales.
• match y case.
• Casos límite y errores lógicos.

Módulo 7. Bucles y repetición

• Repetición de instrucciones.
• while y for.
• range().
• Contadores y acumuladores.
• break y continue.
• Bucles anidados.
• Cláusula else de los bucles.
• Bucles infinitos.
• Elección de estructuras de repetición.

Módulo 8. Colecciones de datos

• Concepto de colección.
• Listas y sus operaciones.
• Índices, segmentación y mutabilidad.
• Tuplas y desempaquetado.
• Conjuntos.
• Diccionarios.
• Recorrido de colecciones.
• Estructuras anidadas.
• Referencias y copias.
• Comprensiones.
• Selección de estructuras apropiadas.

Módulo 9. Funciones y descomposición del código

• Definición y llamada de funciones.
• Parámetros y argumentos.
• Valores de retorno.
• Diferencia entre imprimir y devolver.
• Argumentos posicionales y nominales.
• Valores predeterminados.
• Ámbito de variables.
• Funciones pequeñas y reutilizables.
• Funciones puras y efectos secundarios.
• Docstrings.
• *args, **kwargs y funciones lambda.

Módulo 10. Resolver problemas de principio a fin

• Requisitos y definición del problema.
• Entradas, procesamiento y resultados.
• Diseño de algoritmos.
• Descomposición en funciones.
• Implementación incremental.
• Pruebas y casos límite.
• Depuración.
• Simplificación de soluciones.
• Justificación de decisiones.

Módulo 11. Errores, excepciones y depuración

• Errores de sintaxis, ejecución y lógica.
• Tracebacks.
• Excepciones frecuentes.
• try, except, else y finally.
• raise.
• Captura específica de excepciones.
• Depuración paso a paso.
• Mensajes de error.
• logging.

Módulo 12. Módulos, paquetes e importaciones

• Biblioteca estándar.
• Importaciones.
• Creación de módulos.
• Organización en varios archivos.
• Paquetes.
• Importaciones absolutas y relativas.
• __main__.
• Ejecución mediante la terminal.
• Conflictos de nombres e importaciones circulares.

Módulo 13. Archivos y persistencia

• Rutas y localización de archivos.
• Lectura y escritura.
• Gestores de contexto.
• Codificación de caracteres.
• pathlib.
• Diferencias de rutas entre Windows y Linux.
• CSV y JSON.
• Persistencia de datos.
• Errores de archivos y permisos.

Módulo 14. Programación orientada a objetos

• Clases e instancias.
• Atributos y métodos.
• self e __init__().
• Atributos de instancia y clase.
• Encapsulación.
• property.
• Herencia y composición.
• Polimorfismo.
• Métodos especiales.
• dataclasses.
• Cuándo utilizar clases.

Módulo 15. Rasgos distintivos e idiomáticos de Python

• Zen de Python y código Pythonic.
• Indentación significativa.
• Asignación múltiple y desempaquetado.
• Iterables e iteradores.
• Generadores y yield.
• Comprensiones.
• Gestores de contexto.
• Funciones como objetos y decoradores.
• Operadores y métodos especiales.
• Identidad, mutabilidad y referencias.
• Particularidades de los argumentos.
• Comparación con otros lenguajes.

Módulo 16. Código legible y mantenible

• PEP 8 y PEP 257.
• Nombres descriptivos.
• Responsabilidades bien definidas.
• Evitar duplicación y complejidad.
• Constantes y valores mágicos.
• Comentarios útiles.
• DRY y KISS.
• Separación de responsabilidades y SOLID.
• Refactorización.
• Ruff.
• Revisiones de código.

Módulo 17. Pruebas y fiabilidad

• Pruebas manuales y automatizadas.
• Pruebas unitarias.
• unittest y pytest.
• Casos normales, extremos e inválidos.
• Pruebas de funciones y dependencias.
• Regresión.
• Cobertura.
• Integración de pruebas en el desarrollo.

Módulo 18. Tipado y documentación

• Anotaciones de tipos.
• Tipado de funciones y colecciones.
• Tipos opcionales y None.
• typing.
• Comprobación estática.
• Diferencia entre anotaciones y validación en ejecución.
• Docstrings, README y documentación de proyectos.
• Consulta de la documentación oficial.

Módulo 19. Terminal, Git y gestión de proyectos

• Terminal en Windows y Linux.
• Argumentos de línea de comandos.
• Git.
• Repositorios, cambios, commits y ramas.
• .gitignore.
• Entornos virtuales con venv.
• pip y dependencias.
• requirements.txt.
• pyproject.toml.
• Estructura de proyectos.
• Reproducibilidad y portabilidad.

Módulo 20. Biblioteca estándar y aplicaciones útiles

• Biblioteca estándar.
• datetime.
• Matemáticas y estadísticas.
• Valores aleatorios.
• argparse.
• Variables de entorno.
• Archivos y directorios.
• Expresiones regulares.
• HTTP y APIs.
• SQLite.
• Seguridad básica.

Módulo 21. Comparación con otros lenguajes y portabilidad

• Tipado dinámico y estático.
• Sintaxis e indentación.
• Objetos y memoria.
• Colecciones.
• Iteradores, generadores y comprensiones.
• Excepciones y gestores de contexto.
• Convenciones y restricciones.
• Comparación con Java, C, JavaScript y C#.
• Portabilidad entre Windows y Linux.
• Elección de lenguaje según el problema.

Módulo 22. Proyecto final integrador

• Definición de requisitos.
• Diseño del algoritmo.
• Elección de estructuras de datos.
• Funciones y módulos.
• Entrada, salida y persistencia.
• Validación y tratamiento de errores.
• Pruebas automatizadas.
• Refactorización.
• Documentación y Git.
• Ejecución en Windows y Linux.
• Presentación y evaluación.
• Plan de aprendizaje posterior.

Módulo 23. Concurrencia y asincronía

Módulo 24. Patrones de diseño en Python

Módulo 25. Rendimiento y profiling

Módulo 26. Publicación y CI/CD

• Documentación oficial de Python 3.15 (inglés): https://docs.python.org/3.15/
• Referencia del lenguaje: https://docs.python.org/3.15/reference/index.html
• Referencia de la biblioteca estándar: https://docs.python.org/3.15/library/index.html
• Tutorial oficial: https://docs.python.org/3.15/tutorial/index.html
• Línea de comandos y entorno de Python: https://docs.python.org/3/using/cmdline.html

[BUENA PRÁCTICA] La documentación oficial permite cambiar de versión desde el selector de la esquina superior izquierda. Si trabajas con una versión distinta de 3.15 (por ejemplo, 3.12 o 3.13), asegúrate de consultar la documentación de tu versión, no la más reciente.

• Real Python (tutoriales y artículos): https://realpython.com
• Python Weekly (boletín de novedades): https://www.pythonweekly.com/
• PyCoder's Weekly (boletín): https://pycoders.com/
• Awesome Python (lista curada de bibliotecas y recursos): https://awesome-python.com/
• Python Discourse (foro oficial de la comunidad): https://discuss.python.org/