Práctica 2.2: Sentencias iterativas y saltos
P2.2 - Sentencias iterativas y de salto¶
En esta práctica vas a automatizar tareas que se repiten: recorrer rangos y cadenas, acumular resultados, leer datos hasta un centinela y construir patrones con bucles anidados. También analizarás cuándo una sentencia de salto hace el flujo más claro y cuándo es preferible expresar la terminación en la condición del bucle.
La actividad continúa la teoría de sentencias iterativas y de salto. El resultado esperado es una colección de programas pequeños, ejecutables y documentados, con pruebas que demuestren que terminan y respetan sus límites.
1. Objetivos¶
- Elegir
forpara recorridos conocidos ywhilepara condiciones que evolucionan o entradas controladas por un centinela. - Inicializar y actualizar correctamente contadores, acumuladores y variables de control.
- Resolver recorridos de cadenas, bucles anidados, búsquedas y cálculos de dígitos sin delegar el algoritmo en una función que lo haga directamente.
- Reconocer el efecto de
break,continueypass, priorizando un flujo estructurado sin saltos innecesarios. - Probar límites, entradas vacías y condiciones de terminación para evitar bucles infinitos.
2. Relación con RA y criterios de evaluación¶
| Código | Descripción literal de la normativa |
|---|---|
| RA 3 | Escribe y depura código, analizando y utilizando las estructuras de control del lenguaje. |
| CE 3.b | Se han utilizado estructuras de repetición. |
| CE 3.c | Se han reconocido las posibilidades de las sentencias de salto. |
| CE 3.e | Se han creado programas ejecutables utilizando diferentes estructuras de control. |
Las evidencias se concretan así:
- CE 3.b: los ejercicios 2.2.1 a 2.2.25 deben utilizar recorridos, contadores, acumuladores o condiciones de repetición adecuadas.
- CE 3.c: los ejercicios con centinelas, búsquedas y terminación anticipada
permiten reconocer el efecto de
break,continueypass, justificando cuándo se usan o por qué no son necesarios. - CE 3.e: se entregan los veinticinco archivos Python ejecutables y el
README.mdcon pruebas, resultados y decisiones de flujo.
3. Requisitos y recursos¶
- Python 3, un editor o IDE y una terminal.
- Conocimientos de variables, tipos básicos, operadores,
input,printy condiciones; se recomienda haber completado la práctica de sentencias condicionales. - Lectura previa de la teoría de sentencias iterativas y de salto.
- La presentación de iterativas como repaso visual.
- La teoría de depuración para preparar las evidencias.
En los ejercicios cuyo objetivo es construir un algoritmo, no uses funciones o
métodos que resuelvan directamente el cálculo: por ejemplo, len, sum,
max, min, count, reversed o split cuando el enunciado pide recorrer
los datos. Sí puedes usar range, int, float, print y las operaciones
básicas. Si una excepción de conversión no se ha estudiado todavía, trabaja con
datos del tipo indicado y deja el control de errores para la práctica de
excepciones.
4. Pasos a seguir¶
4.1. Preparar el trabajo¶
- Crea una carpeta de trabajo llamada
practica_u2_2_iterativasy guarda cada ejercicio enejercicio2.2.1.py,ejercicio2.2.2.py, hastaejercicio2.2.25.py. - Incluye el enunciado resumido en un comentario o docstring y usa nombres que indiquen si una variable es un contador, un acumulador, un centinela o un dato procesado.
- Ejecuta cada archivo desde la terminal y conserva ejemplos de entrada y
salida en el
README.mdde la entrega.
4.2. Diseñar el bucle antes de programarlo¶
- Decide si el número de repeticiones es conocido. Si lo es, empieza por un
forconrange; si depende de una condición o de una entrada, considerawhile. - Escribe la inicialización, la condición de continuación, la actualización y el resultado que debe quedar al terminar.
- Identifica el centinela cuando el ejercicio lea una cantidad indeterminada de datos y asegúrate de que el centinela no se procese como un dato normal.
- No uses
breaknicontinuecomo primera opción: expresa la terminación o el filtrado mediante una condición visible. Estudia esas sentencias solo para reconocer código existente y documenta su efecto si aparecen.
4.3. Implementar por bloques de dificultad¶
- Resuelve los ejercicios 2.2.1 a 2.2.8 con
for,rangey bucles anidados. Comprueba especialmente los límites exclusivos derange. - Continúa con los ejercicios 2.2.9 a 2.2.13 para practicar
while, centinelas y recorridos de texto. - Resuelve los ejercicios 2.2.14 a 2.2.18 usando acumuladores, máximos y extracción matemática de dígitos.
- Termina con los ejercicios 2.2.19 a 2.2.25, que combinan menú, búsqueda, validación, bucles anidados y más de un contador.
- Tras cada bloque, revisa el número de iteraciones y prueba también la primera entrada como condición de salida.
4.4. Probar, depurar y documentar¶
- Prueba un caso pequeño que puedas calcular a mano y un caso frontera, como altura 1, edad 0, número primo 2, frase vacía o primer dato igual al centinela.
- Si el bucle no termina o repite un valor, comprueba qué variable lo acerca a la condición de salida y dónde se actualiza.
- En al menos dos ejercicios, coloca un punto de ruptura y observa la variable
de iteración y un contador o acumulador; registra la evidencia en el
README.md. - No introduzcas
breaknicontinuesi puedes resolver el ejercicio con una condición estructurada. Si aparecen en una variante, explica su efecto; unpassno sustituye una implementación pendiente sin justificarlo.
5. Comprobaciones de finalización¶
- Los veinticinco programas se ejecutan con los datos previstos y terminan sin quedar bloqueados en un bucle infinito.
- Los ejercicios 2.2.1 a 2.2.8 respetan los límites y el orden solicitado de cada recorrido.
- Los ejercicios controlados por centinela no procesan el centinela:
0,-1,salir,*y/tienen el significado indicado en cada enunciado. - Los acumuladores empiezan con el valor neutro adecuado y el máximo se inicializa de forma segura cuando todavía no hay datos.
- Los ejercicios de dígitos funcionan con números de una cifra y con el valor límite que termina la entrada.
- Se han probado los casos de entrada vacía o sin datos, siempre que el enunciado los permita, y se muestra un mensaje comprensible.
- Se ha mantenido un flujo estructurado;
breakycontinueno aparecen salvo que se documente una variante de reconocimiento, ypasssolo se usa cuando dejar el bloque vacío es una decisión intencionada. - El
README.mdincluye casos de prueba, resultados esperados, dos evidencias de depuración y una nota sobre las decisiones de diseño.
6. Ejercicios y entregables¶
- Ejercicio 2.2.1 — Repetir una palabra. Pide una palabra y muéstrala diez veces, una por línea.
- Ejercicio 2.2.2 — Años cumplidos. Pide una edad y muestra los años desde 1 hasta esa edad. Decide qué salida corresponde a la edad 0.
- Ejercicio 2.2.3 — Impares. Pide un entero positivo y muestra los impares desde 1 hasta ese número, separados por comas.
- Ejercicio 2.2.4 — Cuenta atrás. Pide un entero positivo y muestra la cuenta desde ese número hasta 0, separados por comas.
- Ejercicio 2.2.5 — Inversión. Pide cantidad, interés anual y años, y
muestra el capital al terminar cada año. Actualiza con
capital *= 1 + interes / 100. - Ejercicio 2.2.6 — Triángulo de asteriscos. Pide la altura y muestra un
triángulo rectángulo cuya fila
ncontienenasteriscos. - Ejercicio 2.2.7 — Tablas de multiplicar. Muestra las tablas del 1 al 10, con los productos del 1 al 10. Usa dos bucles anidados.
- Ejercicio 2.2.8 — Triángulo numérico. Pide la altura y muestra, para
cada fila, los impares en orden descendente:
1;3 1;5 3 1, y así sucesivamente. - Ejercicio 2.2.9 — Contraseña con reintentos. Guarda una contraseña de ejemplo y pide entradas hasta que coincidan. No cuentes el centinela: aquí la coincidencia es la condición de terminación.
- Ejercicio 2.2.10 — Número primo. Pide un entero y decide si es primo. Los valores menores que 2 no son primos y la búsqueda de divisores debe terminar cuando encuentre uno.
- Ejercicio 2.2.11 — Palabra al revés. Pide una palabra y muestra sus letras desde la última hasta la primera, una por línea.
- Ejercicio 2.2.12 — Contar una letra. Pide una frase y una letra, y
cuenta cuántas veces aparece la letra. Recorre la frase y no uses
str.count. - Ejercicio 2.2.13 — Eco. Muestra el eco de cada línea introducida hasta
recibir
salir. El textosalirno se repite. - Ejercicio 2.2.14 — Suma hasta cero. Lee enteros hasta
0y muestra la suma de todos los valores anteriores. - Ejercicio 2.2.15 — Suma de positivos. Lee enteros hasta
0y suma solo los positivos; los negativos se leen, pero no se acumulan. - Ejercicio 2.2.16 — Mayor hasta cero. Lee enteros positivos hasta
0e informa del mayor. Indica qué ocurre si la primera entrada es0. - Ejercicio 2.2.17 — Suma de dígitos. Pide un entero positivo y suma sus
dígitos usando
% 10para extraer el último y// 10para eliminarlo. - Ejercicio 2.2.18 — Dígitos y pares. Lee enteros positivos hasta
-1. Para cada uno muestra la suma de sus dígitos y, al final, cuántos números introducidos eran pares. El-1no cuenta como dato. - Ejercicio 2.2.19 — Menú. Repite un menú con las opciones 1, comenzar; 2, imprimir listado; y 3, finalizar. Informa de las opciones incorrectas y vuelve a mostrar el menú después de 1 y 2.
- Ejercicio 2.2.20 — Primera coincidencia. Pide una frase y una letra, recorre la frase carácter a carácter e informa de las posiciones sin coincidencia. Cuando encuentre la primera coincidencia, indícala y termina el recorrido.
- Ejercicio 2.2.21 — Compras y descuento. Lee importes hasta
0. Ignora los negativos y pide otro importe; al terminar, aplica un descuento del 10 % si el total supera 1 000 euros. - Ejercicio 2.2.22 — Dígitos pares e impares. Lee enteros positivos hasta
0, informa de los dígitos pares e impares de cada número y acumula ambos totales para el resumen final. - Ejercicio 2.2.23 — Títulos por líneas. Lee títulos hasta
*. Una línea con/cierra la línea actual; informa de cuántos dígitos aparecen en ella y del número total de líneas completas. - Ejercicio 2.2.24 — Contar primos. Lee una cantidad indeterminada de
números mayores que 1 hasta
0y cuenta cuántos son primos. - Ejercicio 2.2.25 — Palabra más larga. Pide una frase, cuenta sus
palabras y muestra la primera palabra más larga si hay empate. Considera
uno o más espacios como separadores y resuelve el recorrido sin usar
str.split. - Entregables. Entrega los veinticinco archivos
ejercicio2.2.1.pyaejercicio2.2.25.py, unREADME.mdcon tu nombre o identificador, casos de prueba y resultados, dos evidencias de depuración y una explicación breve de las decisiones de flujo. Si has elegido no usarpass, explica que no era necesario para completar estos algoritmos y que conoces su efecto.
7. Solución orientativa¶
Para contrastar cada solución, escribe primero el patrón del bucle en palabras:
qué se procesa, qué variable cambia y qué condición hace que termine. Un
for con range expresa un recorrido conocido; un while controlado por un
centinela necesita una lectura inicial, un cuerpo que procese el dato y una
nueva lectura antes de volver a evaluar la condición.
| Ejercicio | Orientación para contrastar la solución |
|---|---|
| 2.2.1 | Usa diez iteraciones; el cuerpo solo debe mostrar la palabra. |
| 2.2.2 | Recorre desde 1 hasta la edad incluida; range debe recibir como límite final edad + 1. |
| 2.2.3 | Recorre con paso 2 desde 1 y no añadas una coma después del último valor. |
| 2.2.4 | La cuenta atrás necesita paso -1 y un límite final que incluya el 0. |
| 2.2.5 | Conserva el capital actualizado y muestra una línea por año; prueba interés 0. |
| 2.2.6 | La longitud de la fila coincide con su número de iteración. |
| 2.2.7 | El bucle exterior selecciona la tabla y el interior sus multiplicadores. |
| 2.2.8 | En cada fila, el mayor impar es 2 * fila - 1 y el menor es 1; recorre hacia atrás. |
| 2.2.9 | El while continúa mientras la contraseña introducida sea distinta de la almacenada. |
| 2.2.10 | Prueba divisores desde 2 y usa una condición o una bandera para terminar la búsqueda sin break. |
| 2.2.11 | Recorre índices desde el último hasta el primero o construye el resultado anteponiendo cada letra. |
| 2.2.12 | Inicializa un contador a 0 e increméntalo solo cuando el carácter actual coincida. |
| 2.2.13 | Comprueba el centinela antes de imprimir y actualiza la entrada en cada vuelta. |
| 2.2.14 | El acumulador comienza en 0 y recibe cada entero distinto del centinela. |
| 2.2.15 | Mantén la lectura y separa la condición de finalización de la condición que permite acumular. |
| 2.2.16 | Usa None para representar que aún no hay mayor; no confundas el 0 centinela con un dato. |
| 2.2.17 | Mientras quede una parte del número, suma numero % 10 y reduce con numero // 10. |
| 2.2.18 | Calcula los dígitos de cada número, suma sus valores y comprueba la paridad del número original. |
| 2.2.19 | La condición principal continúa mientras la opción sea distinta de 3; una opción inválida no debe terminar. |
| 2.2.20 | Usa una bandera o una condición exterior para detener el recorrido al encontrar la primera coincidencia; informa de forma distinta si no se encuentra. |
| 2.2.21 | Rechaza los importes negativos sin sumarlos y calcula el descuento solo después de cerrar la entrada. |
| 2.2.22 | Usa dos contadores de dígitos y actualízalos mientras extraes cada dígito con operaciones enteras. |
| 2.2.23 | Separa el contador de dígitos de la línea del contador de líneas; reinicia el primero al recibir /. |
| 2.2.24 | Para cada número, comprueba divisores y aumenta el contador de primos solo cuando no encuentres ninguno. |
| 2.2.25 | Recorre la frase con un contador de caracteres, cierra una palabra al detectar un espacio y conserva la primera en caso de empate. |
Una solución orientativa no consiste en copiar una implementación única: debe
permitir explicar la terminación, el valor de cada acumulador y los casos
frontera. En el informe final, contrasta al menos un resultado manual con la
salida del programa y explica cómo se ha expresado la terminación sin break ni
continue. La sentencia pass se estudia aquí para reconocer un bloque vacío;
no es necesario introducirla artificialmente en un ejercicio que ya tiene una
implementación completa.
8. Fuentes y referencias¶
- Teoría de sentencias iterativas y de salto de la unidad.
- Presentación de iterativas.
- Tutorial oficial de Python: instrucciones de control.
- Documentación oficial de Python: sentencia
while. - Aprende con Alf: ejercicios de bucles.
- Python para todos: iteraciones.
- Normativa oficial del título de Desarrollo de Aplicaciones Web.