Saber Básico A.5: Entornos de interacción con el usuario 3ESO

Computación y Robótica – 3º ESO

1. De estructuras anidadas a un entorno completo

En el A.2 aprendiste a traducir una especificación en entrada, proceso y salida. En el A.4 aprendiste a anidar bucles y condicionales, uno dentro de otro. Hoy juntamos las dos cosas para resolver un problema muy concreto: ¿qué pasa si el usuario escribe algo que no tiene sentido?

Hasta ahora, cuando pedías un dato con preguntar... y esperar, el programa seguía adelante pasara lo que pasara. Un entorno de interacción de verdad no puede permitirse eso: si le pides la edad a alguien y escribe “manzana”, el programa no puede continuar como si nada.

2. ¿Qué es un entorno de interacción con el usuario?

Un entorno de interacción es el conjunto de entradas, salidas y lógica de control que garantiza que el programa solo avanza cuando tiene datos que puede usar. No es solo “preguntar y guardar”: es preguntar, comprobar, y solo entonces seguir.

Entorno mínimo (lo que ya sabías)	Entorno robusto (lo de hoy)
Pregunta una vez, guarda lo que sea	Pregunta, valida, y si está mal, vuelve a preguntar
Un dato incorrecto puede colar un error más adelante	Un dato incorrecto no sale nunca de la fase de entrada
El usuario no se entera de que se ha equivocado	El programa avisa y da otra oportunidad

Idea clave: un entorno de interacción no protege al programa de una entrada mala en el momento en que se usa; la protege en el momento en que se recibe.

3. El bucle de validación: repetir hasta que el dato sea correcto

Ya conoces repetir hasta que <condición> del A.4. Su uso más habitual en interfaces reales es este:

repetir hasta que <(edad > 0) y (edad < 120)>
   preguntar [¿Qué edad tienes?] y esperar
   fijar [edad] a (respuesta)
   si <not <(edad > 0) y (edad < 120)>> entonces
      decir [Ese dato no es válido, inténtalo de nuevo] por (2) segundos

Fíjate en la estructura: la condición de salida del bucle vive fuera (en el “repetir hasta que”), pero lo que la cambia vive dentro (la nueva pregunta). Si el dato es válido, el bucle no vuelve a entrar. Si no lo es, se repite entero, incluido el aviso de error.

Conecta con A.4: este patrón es exactamente un condicional dentro de un bucle, como viste con la estación del hábitat. La diferencia es que aquí la condición del “si” y la condición del “repetir hasta que” son la misma, mirada al revés.

Error típico: olvidar volver a preguntar dentro del bucle. Si el preguntar... y esperar está fuera, la variable nunca cambia entre vuelta y vuelta, y el bucle no termina nunca si el primer dato era incorrecto.

4. Menús: condicionales en cascada para elegir una opción

Otro elemento habitual de un entorno de interacción es el menú: el usuario escribe un número y el programa decide qué hacer según cuál sea, usando la cascada de “si… si no” que ya viste en A.4:

preguntar [1) Ver temperatura  2) Ver batería  3) Salir] y esperar
fijar [opción] a (respuesta)
si <opción = [1]> entonces
   decir (temperatura)
si no
   si <opción = [2]> entonces
      decir (batería)
   si no
      si <opción = [3]> entonces
         detener [todo]
      si no
         decir [Opción no válida]

Un menú es, en el fondo, una cascada de comprobaciones donde cada rama se plantea solo si la anterior no se cumplió. Con más de dos opciones, siempre hay que anidar.

5. Diseño de un entorno completo: validación + menú juntos

Lo potente aparece cuando combinas los dos patrones: un bucle de validación exterior que obliga a elegir una opción del menú que exista, y dentro, la cascada que decide qué hacer:

repetir hasta que <(opción = [1]) o (opción = [2]) o (opción = [3])>
   preguntar [1) Temperatura  2) Batería  3) Salir] y esperar
   fijar [opción] a (respuesta)
   si <not <(opción = [1]) o (opción = [2]) o (opción = [3])>> entonces
      decir [Escribe 1, 2 o 3] por (2) segundos

Y una vez que el bucle termina (porque la opción ya es válida), fuera de él va la cascada del apartado anterior, que ahora puede confiar en que opción solo vale 1, 2 o 3.

Paso del proceso	Qué hace
Entrada	Lo que escribe el usuario (respuesta)
Variable	opción
Proceso 1 (bucle exterior)	Repetir hasta que la opción sea una de las válidas
Proceso 2 (cascada, fuera del bucle)	Decidir qué acción ejecutar según el valor ya validado
Salida	Temperatura, batería, o fin del programa

Idea clave: separar “asegurarme de que el dato es correcto” de “actuar según el dato” hace que cada parte del programa sea más sencilla de leer y de corregir. Mezclarlas en un único bloque gigante es la causa más habitual de errores difíciles de encontrar.

6. De bloques a texto: el mismo patrón en Python

opcion = None
while opcion not in ("1", "2", "3"):
    opcion = input("1) Temperatura  2) Batería  3) Salir: ")
    if opcion not in ("1", "2", "3"):
        print("Escribe 1, 2 o 3")

if opcion == "1":
    print(temperatura)
elif opcion == "2":
    print(bateria)
else:
    print("Adiós")

Este patrón —pedir dentro de un while hasta que el dato sea válido— es tan habitual en programación real que tiene nombre propio: bucle de entrada validada. Aparece igual en Python, en apps móviles o en formularios web; solo cambia la sintaxis.

7. Errores típicos en un entorno de interacción

• Bucle infinito por no actualizar la variable dentro del bucle: si preguntar... y esperar está fuera de repetir hasta que, la condición nunca puede volverse verdadera.
• Condición de salida mal escrita: por ejemplo, usar “y” cuando el enunciado pide “o” (y al revés), dejando fuera opciones válidas o permitiendo alguna inválida.
• Validar y decidir mezclados: meter la cascada del menú dentro del bucle de validación en vez de después, ejecutando la acción elegida en cada intento fallido en lugar de una sola vez al final.
• Mensaje de error que no dice qué se espera: “Dato incorrecto” ayuda menos que “Escribe 1, 2 o 3”.

📝 PARA TU LIBRETA (Resumen clave para copiar)

Copia en tu cuaderno este resumen de 5 puntos:

1. Un entorno de interacción no solo pregunta y guarda: pregunta, valida y solo avanza si el dato es correcto.
2. El bucle de validación es un repetir hasta que cuya condición de salida se actualiza dentro del propio bucle, volviendo a preguntar en cada vuelta fallida.
3. Un menú es una cascada de condicionales anidados, uno por cada opción posible, con un último “si no” para la opción no reconocida.
4. Validación y decisión van en fases separadas: primero el bucle asegura un dato correcto, y solo después la cascada actúa sobre él.
5. En Python el mismo patrón es un while con input() dentro, comprobando la condición en cada vuelta.

---

FICHA DE TRABAJO DESENCHUFADA: ENTORNOS DE INTERACCIÓN ROBUSTOS

Saber Básico A.5: Entornos de interacción con el usuario

Nombre y Apellidos: ____________________________________________________

Curso y Grupo: 3.º ESO ____ | Fecha: __ /__ /2026

📖 Recuerda cómo se lee (consulta si tienes dudas)

La condición de salida de un bucle de validación se actualiza dentro · Primero se valida, después se decide · En una cascada, cada rama se plantea solo si la anterior no se cumplió.

---

🔍 RETO 1: Sigue el bucle de validación

repetir hasta que <(nota >= 0) y (nota <= 10)>
   preguntar [¿Qué nota has sacado?] y esperar
   fijar [nota] a (respuesta)
   si <not <(nota >= 0) y (nota <= 10)>> entonces
      decir [Nota no válida] por (2) segundos

Un alumno responde, en este orden: 15, -3, 7.

Intento	¿Qué responde?	¿Es válido?	¿Qué dice el programa?	¿El bucle vuelve a repetirse?
1	15
2	-3
3	7

Reflexión: ¿cuántas veces se ejecuta preguntar... y esperar en total? ¿Qué pasaría si un alumno no escribiera nunca un número entre 0 y 10?
Respuesta: ____________________________________________________________________

---

🧭 RETO 2: Diseña un menú en cascada

Una estación terrestre de BermejaSat debe mostrar este menú: 1) Ver altitud, 2) Ver velocidad, 3) Ver temperatura, 4) Salir. Si el usuario escribe cualquier otra cosa, debe avisar de que la opción no existe (sin bucle de validación todavía, solo la cascada).

Escribe el programa con sangrías, igual que en los apuntes:

____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________

Reflexión: ¿cuántos niveles de anidamiento tiene tu cascada como mínimo? ¿Por qué no se puede hacer con un solo “si”?
Respuesta: ____________________________________________________________________

---

🧩 RETO 3: De la especificación al entorno completo

Especificación: “El programa debe pedir un número de opción del menú del Reto 2 (1 a 4) y no debe aceptar ningún otro valor, avisando y repitiendo la pregunta. Una vez que el dato es válido, debe ejecutar la acción correspondiente.”

Paso del proceso	Qué necesito
Entrada
Variable(s)
Proceso 1 (bucle de validación)
Proceso 2 (cascada, fuera del bucle)
Salida

Escribe el entorno completo (bucle de validación + cascada) con sangrías:

____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________

---

🐞 RETO 4: Caza el error de validación

Programa A (debería repetir hasta que la opción sea 1, 2 o 3)

preguntar [1) Sí  2) No  3) Salir] y esperar
fijar [opción] a (respuesta)
repetir hasta que <(opción = [1]) o (opción = [2]) o (opción = [3])>
   decir [Opción no válida] por (2) segundos

Programa B (debería aceptar solo edades entre 1 y 99)

repetir hasta que <(edad > 1) y (edad < 99)>
   preguntar [¿Edad?] y esperar
   fijar [edad] a (respuesta)

Programa	¿Qué falla?	¿Cómo lo arreglo?
A
B

Reflexión: en el Programa B, ¿qué pasaría si alguien escribe exactamente 99? ¿Es eso lo que pedía la especificación (“entre 1 y 99”)?
Respuesta: ____________________________________________________________________

---

⚖️ RETO 5: El mismo patrón en Python

Traduce este fragmento de Scratch a Python, usando while e input():

repetir hasta que <(respuesta_valida)>
   preguntar [Escribe "sí" o "no"] y esperar
   fijar [dato] a (respuesta)
   si <(dato = [sí]) o (dato = [no])> entonces
      fijar [respuesta_valida] a [verdadero]

Tu versión en Python:
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________

Reflexión: ¿qué ventaja tiene usar directamente while dato not in ("sí", "no"): frente a una variable extra como respuesta_valida?
Respuesta: ____________________________________________________________________

---

💡 Dinámica sugerida para el aula (40-45 min)

• 10 min: Repaso oral en la pizarra del bucle de validación del apartado 3, trazando a mano qué pasa con una entrada mala y una buena.
• 25 min: Trabajo individual o en parejas con los Retos 1 a 5 (el 3 es el más largo, puede dejarse para el final).
• 5-10 min: Corrección conjunta del Reto 4, identificando en voz alta a qué falla exactamente el patrón de validación en cada caso.

---

Solucionario (solo para ti)

• Reto 1: Intento 1 (15): no válido → “Nota no válida” → se repite. Intento 2 (-3): no válido → “Nota no válida” → se repite. Intento 3 (7): válido → el bucle termina. Se ejecuta preguntar 3 veces. Si nunca escribiera un valor entre 0 y 10, el bucle no terminaría nunca (bucle infinito).
• Reto 2: si opción=1 → altitud / si no si opción=2 → velocidad / si no si opción=3 → temperatura / si no si opción=4 → salir / si no → “Opción no válida”. Tres niveles de anidamiento como mínimo (para llegar a la cuarta opción). No se puede con un solo “si” porque hay más de dos resultados posibles.
• Reto 3: Entrada: lo que escribe el usuario. Variable: opción. Proceso 1: repetir hasta que opción sea 1, 2, 3 o 4, preguntando y avisando si no lo es. Proceso 2: la cascada del Reto 2, después del bucle. Salida: la acción del menú, o el mensaje de opción no válida durante la validación.
• Reto 4: A) el preguntar está fuera del bucle: solo se pregunta una vez, y si la opción es inválida, el bucle repite el aviso para siempre sin volver a preguntar (bucle infinito con el mismo dato). Hay que meter el preguntar y el fijar dentro del bucle. B) usa > y < estrictos: alguien con edad exactamente 1 o exactamente 99 no pasaría la validación, aunque la especificación decía “entre 1 y 99” (normalmente inclusivo). Habría que usar >= y <= si se quieren incluir los extremos.
• Reto 5: dato = "" / while dato not in ("sí", "no"): / dato = input('Escribe "sí" o "no": '). Usar directamente la condición del while evita crear y mantener una variable extra (respuesta_valida) que hay que actualizar a mano; es menos código y menos posibilidades de olvidarse de ponerla a verdadero.