Skip to content

Situación de Aprendizaje Bloque A.1. "Gestor de estudiantes" ​

Creación Digital y Pensamiento Computacional · 1.º de Bachillerato · Bloque A · 15 sesiones

Esta situación de aprendizaje integra la parte de Python del Tema 1 (Partes 1 a 4): fundamentos de programación, estructuras de control, estructuras de datos, funciones y gestión de archivos. El producto final es el programa gestion_estudiantes.py, incluido en esta misma carpeta como solución de referencia.


1. Datos e identificación ​

  • Título: Gestor de estudiantes
  • Materia: Creación Digital y Pensamiento Computacional (CDPC).
  • Curso: 1.º de Bachillerato.
  • Bloque: A. Programación Gráfica Multimedia.
  • Saberes básicos: CDPC.1.A.1, CDPC.1.A.2, CDPC.1.A.3 y CDPC.1.A.4 (funciones y archivos).
  • Competencias específicas: 1 (pensamiento computacional y creatividad algorítmica).
  • Criterios de evaluación: 1.1 y 1.2.
  • Duración: 15 sesiones de 55 minutos (aproximadamente 14 horas).
  • Agrupamiento: individual, parejas y grupos de 3–4 personas.
  • Espacios: aula de informática con Python 3 instalado, editor de código y proyector.

2. Contexto y justificación ​

En el día a día de un centro educativo, el profesorado maneja listas de estudiantes, calificaciones, medias y listados de aprobados. Con frecuencia estas tareas se resuelven con hojas de cálculo dispersas o con libretas que se pierden o se duplican. El alumnado asumirá el papel de un equipo de desarrollo junior al que se le encarga construir una pequeña aplicación de consola para gestionar estudiantes y sus notas de forma sencilla, fiable y persistente.

La situación permite recorrer de forma natural todo el itinerario de programación del primer bloque:

  1. Parte 1 del Tema 1: analizar el problema, escribir pseudocódigo y construir los primeros programas con variables, tipos, operadores y entrada/salida.
  2. Parte 2 del Tema 1: tomar decisiones y repetir tareas con condicionales y bucles.
  3. Parte 3 del Tema 1: organizar la información con listas y diccionarios.
  4. Parte 4 del Tema 1: dividir el programa en funciones y guardar los datos en archivos.

El reto no es un ejercicio aislado: cada práctica de las sesiones intermedias produce una pieza que se reutiliza en el producto final. Así, el alumnado percibe el progreso de su propio código y comprende para qué sirve cada contenido antes de aplicarlo.


3. Reto / pregunta motriz ​

¿Cómo podemos construir una aplicación de consola en Python que permita registrar estudiantes, consultar sus notas, calcular estadísticas y conservar los datos entre ejecuciones?


4. Producto final ​

Cada estudiante o pareja entrega un programa gestion_estudiantes.py que:

  1. Presenta un menú interactivo que se repite hasta que el usuario decide salir.
  2. Permite añadir o modificar estudiantes con sus notas.
  3. Consulta los estudiantes ordenados por nombre, mostrando sus notas y su media.
  4. Calcula la media del grupo, los aprobados y un resumen de estadísticas.
  5. Permite eliminar estudiantes con confirmación.
  6. Guarda y carga los datos en un archivo de texto, conservándolos entre ejecuciones.
  7. Está organizado en funciones con docstrings, usa nombres claros y sigue un estilo legible.
  8. Valida las entradas y controla los errores más habituales sin cerrarse de forma abrupta.
  9. Se acompaña de un diagrama de flujo, un manual de uso y una memoria breve con el análisis, las pruebas realizadas y las dificultades encontradas.

Como ampliación opcional, el programa puede exportar los datos a CSV o JSON.


5. Concreción curricular ​

CriterioSaberes básicosSesionesEvidencia
1.1CDPC.1.A.1, CDPC.1.A.2, CDPC.1.A.31–8Prácticas de sesión y mini-retos
1.2CDPC.1.A.4 (funciones y archivos)9–14Programa final y memoria

Relación con las partes del Tema 1

ParteContenido movilizadoUso en el proyecto
Parte 1Algoritmos, pseudocódigo, variables, tipos, operadores, input()/print()Entrada de nombres y notas, cálculos y mensajes
Parte 2if/elif/else, while, for, break, validaciónMenú repetitivo, validación de notas y confirmaciones
Parte 3Listas, tuplas, diccionarios, conjuntos, comprensión de listasModelo {nombre: [notas]} y cálculo de estadísticas
Parte 4Funciones, parámetros, return, ámbito, módulos, archivos, try/exceptModularización y persistencia en estudiantes.txt

6. Secuenciación didáctica ​

Fase inicial (Sesión 0) ​

Sesión 0 — "Planteamos el reto"

  • Presentación del contexto, del producto final y de la rúbrica de evaluación.
  • Evaluación inicial: cuestionario breve sobre ideas previas (qué es un programa, variables, bucles, funciones y archivos).
  • Formación de parejas o grupos y firma del contrato de equipo (roles, normas y compromisos).
  • Configuración del entorno: Python, editor de código y carpeta de trabajo.
  • Primer contacto: ejecutar un programa mínimo que muestre un menú por pantalla.
  • Producto: cuestionario inicial y contrato de equipo.

Fase de desarrollo (Sesiones 1–12) ​

Sesión 1 — Del problema al algoritmo (Tema 1, Parte 1)

  • Algoritmo frente a código; secuenciación de instrucciones.
  • Pseudocódigo y diagramas de flujo.
  • Práctica: describir en pseudocódigo cómo se añadiría un estudiante y cómo se calcularía su media.
  • Producto: pseudocódigo y primer diagrama de flujo.

Sesión 2 — Variables, tipos y operadores (Tema 1, Parte 1)

  • Variables, tipos básicos, conversión de tipos, operadores y f-strings.
  • Entrada y salida de datos con input() y print().
  • Práctica: "Ficha de estudiante": pedir nombre y tres notas, calcular la media y mostrarla con dos decimales.
  • Producto: 01_ficha_estudiante.py.

Sesión 3 — Decisiones y validación (Tema 1, Parte 2)

  • if, elif, else y condiciones compuestas.
  • Validación de datos: comprobar que una nota está entre 0 y 10.
  • Práctica: clasificar una nota en suspenso, aprobado, notable o sobresaliente.
  • Producto: 02_clasificar_notas.py.

Sesión 4 — Bucles y menús (Tema 1, Parte 2)

  • while, for, range(), break y continue.
  • Construcción de un menú que se repite hasta elegir "Salir".
  • Práctica: menú con tres opciones que aún no guardan datos.
  • Producto: 03_menu.py.

Sesión 5 — Bucles anidados y mini-retos (Tema 1, Parte 2)

  • Validación repetitiva y bucles dentro de bucles.
  • Retos: pedir varias notas hasta dejar una vacía; impedir notas fuera de rango.
  • Producto: 04_retos_validacion.py.

Sesión 6 — Listas y tuplas (Tema 1, Parte 3)

  • Creación, recorrido, métodos y operaciones básicas con listas.
  • Cálculo de suma, media, máximo y mínimo.
  • Práctica: almacenar las notas de un estudiante en una lista y calcular sus estadísticas.
  • Producto: 05_listas_notas.py.

Sesión 7 — Diccionarios y estructuras anidadas (Tema 1, Parte 3)

  • Diccionarios, acceso por clave y recorrido con items().
  • Modelo de datos del proyecto: {nombre: [nota1, nota2, ...]}.
  • Práctica: registrar varios estudiantes y mostrar sus medias.
  • Producto: 06_diccionario_estudiantes.py.

Sesión 8 — Conjuntos, cadenas y comprensión de listas (Tema 1, Parte 3)

  • Conjuntos para evitar duplicados; ordenación de nombres.
  • Comprensión de listas para filtrar aprobados y calcular medias.
  • Producto: 07_filtros_estadisticas.py.

Sesión 9 — Funciones (Tema 1, Parte 4)

  • Definición, parámetros, valores por defecto, return y ámbito.
  • Refactorización del código anterior en funciones pequeñas y reutilizables.
  • Práctica: crear media(), pedir_nota() y mostrar_estudiantes().
  • Producto: 08_funciones.py.

Sesión 10 — Funciones II, módulos y estilo (Tema 1, Parte 4)

  • Docstrings, nombres significativos y PEP 8.
  • Uso de módulos de la biblioteca estándar (pathlib, math o statistics).
  • Producto: 09_funciones_avanzadas.py.

Sesión 11 — Archivos I: lectura y escritura (Tema 1, Parte 4)

  • open(), modos "r", "w" y "a", sentencia with y encoding="utf-8".
  • Lectura línea a línea, escritura y tratamiento de FileNotFoundError.
  • Práctica: guardar y recuperar una lista de estudiantes en estudiantes.txt.
  • Producto: 10_archivos.py y un archivo de datos de ejemplo.

Sesión 12 — Archivos II: formatos y robustez (Tema 1, Parte 4)

  • Formato de datos nombre;nota1,nota2,....
  • Validación de líneas mal formadas y uso de try/except.
  • Ampliación: exportar e importar en CSV o JSON con los módulos csv y json.
  • Producto: 11_persistencia_robusta.py.

Fase final (Sesiones 13–14) ​

Sesión 13 — Integración y pruebas

  • Ensamblado de gestion_estudiantes.py con todas las funciones.
  • Pruebas guiadas con casos límite (nombre vacío, nota incorrecta, archivo inexistente, línea corrupta, estudiante duplicado).
  • Elaboración del diagrama de flujo definitivo y del manual de uso.
  • Agrupamiento: parejas. DUA: se ofrece un esqueleto de código y una lista de comprobación.

Sesión 14 — Presentación y evaluación

  • Demostración del programa en funcionamiento (3–5 minutos por pareja).
  • Coevaluación con rúbrica y autoevaluación con el diario de aprendizaje.
  • Cierre del docente: síntesis de lo aprendido y conexión con el siguiente bloque.

7. Actividad final: "Gestor de estudiantes" ​

7.1. Análisis y diseño ​

Antes de escribir código, cada equipo debe:

  1. Identificar las entidades y los datos que se guardan: un estudiante tiene un nombre y una lista de notas.

  2. Elegir la estructura de datos adecuada: un diccionario {nombre: [notas]}.

  3. Diseñar el formato del archivo: una línea por estudiante, con el nombre separado de las notas por un punto y coma, y las notas entre sí por comas:

    text
    Ana;8,9
    Luis;6,7.5
    Marta;9.25,8.75,10
  4. Dibujar el diagrama de flujo del menú principal.

  5. Escribir el pseudocódigo de las operaciones principales: añadir, consultar, guardar y cargar.

Modelo de datos

El diccionario es la estructura clave del proyecto: la clave es el nombre del estudiante y el valor es una lista de notas. A partir de este modelo, casi todas las operaciones se resuelven recorriendo claves y valores.

7.2. Requisitos mínimos ​

  • [ ] El programa arranca sin errores y muestra un menú.
  • [ ] Se pueden añadir estudiantes con una o varias notas.
  • [ ] Las notas se validan: deben ser números entre 0 y 10.
  • [ ] Se pueden consultar los estudiantes con sus medias.
  • [ ] Se calcula la media del grupo y se listan los aprobados.
  • [ ] Se pueden guardar y cargar los datos en estudiantes.txt.
  • [ ] El código está dividido en funciones con docstrings.
  • [ ] El programa no se cierra de forma abrupta ante entradas incorrectas.
  • [ ] Se entregan el diagrama de flujo, el manual de uso y la memoria.

7.3. Hitos de implementación ​

HitoContenidoPartes implicadas
1Menú repetitivo y opción "Salir"Partes 1 y 2
2Añadir estudiante con validación de notasPartes 1, 2 y 3
3Consultar estudiantes y calcular mediasParte 3
4Refactorizar en funcionesParte 4
5Guardar y cargar datosParte 4
6Estadísticas, eliminación y pruebas finalesPartes 2, 3 y 4

7.4. Pruebas y depuración ​

Cada equipo debe probar, como mínimo, los siguientes casos:

Caso de pruebaResultado esperado
Nombre vacíoEl programa avisa y no añade el estudiante
Nombre con ; o ,El programa rechaza el nombre para no romper el formato
Nota abcEl programa avisa y vuelve a pedir la nota
Nota -1 o 11El programa avisa y vuelve a pedir la nota
Nota 7,5Se acepta como 7.5
Estudiante sin notasNo se añade y se informa
Estudiante duplicadoSe pide confirmación antes de sobrescribir
Archivo inexistenteSe informa y se empieza con un diccionario vacío
Línea mal formadaSe ignora la línea y se avisa
Nota fuera de rango en el archivoSe ignora la línea y se avisa
Guardar sin estudiantesSe pide confirmación antes de crear un archivo vacío
Salir con cambios sin guardarSe pregunta si se desea guardar

7.5. Entrega y defensa ​

La entrega incluye:

  1. gestion_estudiantes.py funcionando.
  2. Un archivo estudiantes.txt de ejemplo.
  3. memoria.md o memoria.pdf con:
    • análisis del problema y modelo de datos;
    • diagrama de flujo;
    • tabla de pruebas realizadas;
    • dificultades encontradas y cómo se resolvieron.
  4. manual.md con instrucciones de ejecución y descripción de las opciones.
  5. Opcionalmente, exportación a CSV o JSON.

La defensa consiste en una demostración breve del programa y una explicación de una decisión de diseño y un error corregido.

7.6. Ampliaciones ​

  • Añadir una opción para modificar solo las notas de un estudiante existente.
  • Guardar los datos en CSV con el módulo csv.
  • Guardar los datos en JSON con el módulo json.
  • Añadir fecha de registro o grupo/clase a cada estudiante.
  • Generar un informe en un archivo de texto con las estadísticas del grupo.
  • Ordenar a los estudiantes por media, no solo por nombre.
  • Incorporar pruebas automáticas con assert o unittest.

8. Evaluación ​

InstrumentoCriterioMomentoPeso
Portafolio de prácticas de sesión1.1Continuo30 %
Programa final (rúbrica)1.2Sesiones 13–1450 %
Memoria, diagrama, manual y defensa1.2Sesiones 13–1420 %
  • Evaluación formativa: observación en el aula, revisión de código entre parejas y retroalimentación breve al final de cada sesión.
  • Evaluación sumativa: rúbrica del producto final y de la documentación.
  • Autoevaluación: diario de aprendizaje.
  • Coevaluación: rúbrica entre parejas durante la presentación.

9. Materiales y recursos ​

  • Aula de informática con Python 3.x y editor de código (VS Code, Thonny o similar).
  • Tema 1 (Partes 1 a 4) de la asignatura como material de consulta.
  • Archivo de referencia gestion_estudiantes.py incluido en esta carpeta.
  • Plantilla de estudiantes.txt con datos de ejemplo.
  • Plantilla de diagrama de flujo y de memoria.
  • Rúbrica y lista de cotejo de los anexos.

10. Atención a la diversidad (DUA) ​

  • Múltiples formas de representación: explicaciones con pseudocódigo, diagramas y código comentado; versión escrita y oral de las instrucciones.
  • Múltiples formas de acción y expresión: se puede entregar la memoria en texto, presentación o vídeo breve; se permite trabajar con plantillas o desde cero.
  • Múltiples formas de implicación: retos de ampliación para quien avance más rápido y apoyo guiado para quien lo necesite; roles rotativos dentro del equipo.
  • Medidas específicas: esqueleto de código con funciones vacías, lista de comprobación y pruebas de ejemplo para el alumnado que requiera más apoyo.

11. Evaluación de la práctica docente ​

  • Cuestionario final al alumnado sobre claridad, ritmo, dificultad y utilidad del proyecto.
  • Análisis de los resultados por criterio de evaluación.
  • Revisión de la temporalización y de las plantillas de apoyo.
  • Ajuste del banco de retos y de los casos de prueba para el curso siguiente.

Anexos ​

Anexo A · Rúbrica del producto final ​

Criterio4 — Excelente3 — Adecuado2 — En desarrollo1 — Insuficiente
FuncionalidadCumple todos los requisitos y gestiona casos límiteCumple lo esencial con fallos menoresFunciona parcialmenteNo funciona o falla en lo básico
ModularidadFunciones pequeñas, claras y reutilizablesFunciones correctas con alguna duplicidadPocas funciones o mal organizadasTodo el código en un bloque
Estructuras de datosUsa diccionarios y listas de forma adecuada y eficienteUsa las estructuras correctas con algún errorEstructuras mejorablesNo emplea las estructuras adecuadas
PersistenciaGuarda y recupera sin pérdida de datos y con control de erroresGuarda y recupera correctamentePersistencia parcialNo persiste o corrompe los datos
Validación y erroresValida todas las entradas y evita cierres inesperadosValida lo principalValidación escasaNo valida ni controla errores
Documentación y defensaMemoria, diagrama y manual completos; defensa claraDocumentación suficienteDocumentación escasaSin documentación ni defensa

Anexo B · Lista de cotejo de entrega ​

  • [ ] El programa se ejecuta con python3 gestion_estudiantes.py.
  • [ ] El menú incluye todas las opciones y la opción de salir.
  • [ ] Se pueden añadir, consultar y eliminar estudiantes.
  • [ ] Las notas se validan y se muestran con dos decimales.
  • [ ] Se calculan media del grupo, aprobados y estadísticas.
  • [ ] Los datos se guardan y se cargan desde estudiantes.txt.
  • [ ] El código tiene docstrings y nombres significativos.
  • [ ] Se incluye un archivo de datos de ejemplo.
  • [ ] Se entregan memoria, diagrama de flujo y manual.
  • [ ] Se han probado los casos límite de la tabla de pruebas.

Anexo C · Diario de aprendizaje ​

  1. ¿Qué he aprendido en esta situación de aprendizaje?
  2. ¿Qué parte me ha resultado más difícil y cómo la he resuelto?
  3. ¿Cómo he colaborado con mi pareja o grupo?
  4. ¿Qué decisión de diseño tomé y por qué?
  5. ¿Qué mejoraría si volviera a empezar?
  6. Valoración personal del resultado (1–5) y justificación.

Anexo D · Banco de retos de ampliación ​

  • Exportar los datos a CSV y volver a importarlos.
  • Guardar la configuración del programa en JSON.
  • Añadir un informe de estadísticas generado automáticamente.
  • Ordenar por media y mostrar un "top 3" de la clase.
  • Incorporar pruebas automáticas con assert.
  • Refactorizar el programa con dataclasses.
  • Añadir varios grupos o clases y filtrar por grupo.

Anexo E · Correspondencia con los saberes básicos ​

Saber básicoCómo se trabaja en la SdA
CDPC.1.A.1 Fundamentos de programaciónVariables, tipos, operadores, entrada/salida y estructuras básicas
CDPC.1.A.2 Instrucción, secuenciación, algoritmo vs. códigoPseudocódigo, diagrama de flujo y descomposición del problema
CDPC.1.A.3 Estructuras de controlCondicionales, bucles, validación y menús
CDPC.1.A.4 Funciones y archivosFunciones con parámetros y return; lectura y escritura en archivos

Anexo F · Solución de referencia ​

El archivo gestion_estudiantes.py de esta carpeta contiene una solución de referencia del producto final. No es la única solución posible: el alumnado puede organizar las funciones de otra forma siempre que cumpla los requisitos.

Aspectos destacados de la solución:

  • Modelo de datos: diccionario {nombre: [notas]}.
  • Funciones de entrada: pedir_nombre(), pedir_nota() y pedir_notas() validan los datos.
  • Funciones de consulta: consultar_estudiantes(), mostrar_media(), mostrar_aprobados() y mostrar_estadisticas().
  • Funciones de gestión: pedir_estudiante() y eliminar_estudiante().
  • Persistencia: guardar_datos() y cargar_datos() trabajan con with open(..., encoding="utf-8").
  • Control de errores: try/except para notas no numéricas, líneas mal formadas y archivos inexistentes.
  • Menú: mostrar_menu() y main() coordinan el flujo del programa y avisan si hay cambios sin guardar.

Para ejecutarlo:

bash
python3 gestion_estudiantes.py

Ejemplo de archivo de datos:

text
Ana;8,9
Luis;6,7.5
Marta;9.25,8.75,10

Publicado bajo la licencia MIT.