1. Objetivos

El objetivo de este capítulo es introducir al alumno en el uso de estructuras repetitivas en el lenguaje de programación Python. Para ello se verán los conceptos sobre estructuras repetitivas, las sintaxis y los usos correctos de las mismas. 

Terminado el capítulo el alumno deberá ser capaz de reconocer las diferentes estructuras repetitivas en Python, y utilizarlas de forma correcta y eficiente como parte de los códigos que desarrolle de acá al futuro.

2. Introducción

Generalmente los programas deben realizar tareas repetitivas sin cometer errores, y dado que las computadoras son capaces de hacer esto y de forma eficiente, Python proporciona varias características que permiten hacerlas de manera más sencillas, utilizando lo que definimos en clases anteriores como ESTRUCTURAS REPETITIVAS.

Pero primero definamos algunas cuestiones básicas sobre las estructuras repetitivas para luego proseguir con las estructuras que veremos en este cursado.

¿Qué es un BUCLE?

Un bucle o ciclo en programación, es una secuencia de instrucciones de código que se ejecuta repetidas veces, hasta que la condición asignada a dicho bucle deja de cumplirse.

¿Qué es una ITERACIÓN?

Es la repetición de un proceso con el objetivo de alcanzar una meta o resultado deseado.

También se le llama iteración a cada repetición del proceso, y los resultados de cada iteración se puede utilizar como punto de partida para la siguiente iteración.

Ejemplo:

Imagine que se quiere llenar un balde con agua y para ello debe utilizar una taza.  

El proceso que se debe realizar es:

1. Llenar con agua la taza.
2. Volcar el agua de la taza en el balde.
3. Preguntar: ¿puedo colocar más agua?.

¿Por qué utilizar estructuras repetitivas?

El uso de estructuras repetitivas tiene las siguientes ventajas:

1. Eficiencia: el código se escribe una sola vez y se utiliza las veces que se quiera.
2. Flexibilidad: nos permite ajustar el número de ejecuciones que se deben realizar en funciona de las necesidades del usuario. Por ejemplo, si tenemos un programa que ejecuta un set de instrucciones 5 veces y luego queremos modificarlo para que lo haga 100 veces, utilizando estructuras repetitivas es mucho más sencillo debido a que solo es necesario modificar la condición de salida del bucle.
3. Reducción de errores: se reduce la posibilidad de cometer errores, como olvidar una instrucción o equivocarse en una variable.

3. Variables dependiendo de su Uso

Hemos visto que en programación, existen distintos tipos de variables (enteras, reales, lógicas, etc.). Sin embargo, hay variables que sin importar el tipo de datos que manejan, están definidas acorde a la tarea que realizan.

A continuación, veremos los tres tipos de variables según su USO más comunes.

3.1. Bandera o Centinela

La variable tipo BANDERA (también conocida como CENTINELA), es una variable que nos permite saber si cierta parte del código se ha ejecutado o no, esto lo hace cambiando entre dos posibles valores.

Al solo poder alternar entre dos valores, la BANDERA o CENTINELA es una variable del tipo lógica (VERDADERO o FALSO). Por lo tanto para esta variable se utiliza el tipo de dato BOOLEANO (lógico).

Por lo general la BANDERA tiene como valor inicial False y cambiará al estado True solamente cuando la situación esperada se presenta. Hay que tener en cuenta, que pueden existir casos que en los que es mejor que la BANDERA se inicie en True y cambie a False cuando se presenta la situación esperada.

Las BANDERAS son muy útiles en programación, principalmente en el uso de los bucles "while" como veremos más adelante.

Ejemplo:

El script que se muestra a continuación determina si la palabra que se ingresó por teclado es un "palíndromo". Un palíndromo es una palabra que se lee igual en un sentido u otro.

En el ejemplo se observa que "es_palindromo" solamente cambia de valor cuando se constata que la palabra ingresada es un palíndromo, por lo tanto es una variable tipo BANDERA.

La sentencia "cadena[::-1]" devuelve una nueva cadena con los caracteres de la original en orden inverso.

3.2. Acumulador

El ACUMULADOR en programación es una variable (int o float) cuyo valor se incrementa (o decrementa en el caso de que se reste) con los valores que se procesan.

Este tipo de datos se suele utilizar para acumular los valores que se ingresan en cada iteración de un bucle repetitivo ("while" o "for").

El valor inicial (antes de que se comiencen a sumar los datos ingresados) es importante y por regla general SIEMPRE es 0 (cero) en caso de ser una variable numérica o "" (cadena vacía) en caso de ser una variable del tipo cadena de caracteres.

¿Por qué debemos "vaciar" la variable antes de acumular?:

Imaginemos una taza que queremos agregar leche, pero ya tiene algo de café. Al completar la taza con leche tendremos leche con algo de café pero no solamente leche.

Ejemplo de uso de la variable acumulador 

En el siguiente ejemplo, se quiere acumular los valores que son ingresados para luego calcular el promedio.

En este caso el acumulador se comporta como el rollo de una calculadora, porque va acumulando los ingresos parciales, los cuales NO tienen porque tener el mismo valor.

Podemos ver otro ejemplo de acumulador pero utilizando datos del tipos "string" (cadena de caracteres).

• EL INCREMENTO/DECREMENTO EN LOS ACUMULADORES ES VARIABLE

• Comente la línea 8 del primer ejemplo. ¿Funciona el programa de forma correcta?.
• Comente la línea 16 del segundo ejemplo y corra el programa varías veces. ¿Funciona el programa de forma correcta?.

3.3. Contador

El CONTADOR en programación es una variable, cuyo valor se incrementa o decrementa en un valor FIJO. El uso principal que se le da al CONTADOR es para contar el número de veces que un bucle se repite.

Por lo tanto, EL CONTADOR ES UN CASO PARTICULAR DEL ACUMULADOR CUANDO EL VALOR DE INCREMENTO/DECREMENTO SE MANTIENE FIJO.

En el ejemplo siguiente se tiene un CONTADOR para llevar un registro de la cantidad de números que se ingresan y luego poder calcular el promedio.

Observar que en el ejemplo hay tanto un CONTADOR como un ACUMULADOR y lo único que los diferencia, es que mientras al ACUMULADOR se le suma el valor ingresado por teclado (variables) al CONTADOR siempre se le suma 1 (uno).

Ejemplo de CONTADORES:

• contador = contador + 1 o contador += 1
• contador = contador + 2 o contador += 2
  
• contador = contador + 5 o contador += 5
  
• contador = contador - 1 o contador -= 1
  
• contador = contador - 5 o contador -= 5
  

4. Tipos de Bucles en Python

En Python existen 2 estructuras repetitivas principales: el bucle "for" y el bucle "while". Y si bien ambas estructuras hacen lo mismo, iterar sobre una porción de código, difieren en la forma que lo realizan.

Bucle "for":

El bucle "for" es un tipo de estructura repetitiva que tiene como característica principal que el número de iteraciones es conocido, por ejemplo, si en una parte del código de un programa se necesita ingresar las notas del primer parcial de los alumnos, se debería utilizar como estructura de repetición el bucle "for" debido a que el número de estudiantes de una materia es un dato conocido.

Bucle "while":

Hay situaciones, en las cuales no se sabe a priori la cantidad de veces que un conjunto de instrucciones se debe ejecutar. En esos casos se debe utilizar el bucle "while", debido a que el mismo se ejecutará hasta que se cumpla la condición de salida o de finalización del bucle.

Algo que tienen en común los dos tipos de bucles, es que deben ser finitos, es decir, en algún momento deben terminar.

Bucle "infinito":

Los bucles infinitos son bucles que no terminan nunca, ya sea porque su condición de salida no se cumple o porque no se ha definido una condición de salida adecuada. Deben ser evitados, debido a que no se ejecutarían más instrucciones del código, perdiéndose el control del programa.

En los casos que se esta ante un bucle infinito, se puede pulsar la combinación de teclas Ctrl+C para interrumpir el programa, lo que mostrará un mensaje de error similar al siguiente:

5. Ciclo "for"

Al igual que el "while", la sentencia "for" se encuentra en todos los lenguajes de programación más utilizados. Sin embargo, en Python la sintaxis y forma de implementación difiere levemente de las utilizadas en otros lenguajes como el C o Pascal.

La sintaxis de la instrucción "for" en Python es la siguiente:

donde tenemos las palabras reservadas (keywords) for e in, la variable i, una secuencia de datos (secuencia) que la variable i irá tomando en cada iteración, los dos puntos y en la línea inferior en un nivel de indentación el conjunto de instrucciones que se deben ejecutar dentro del "for".

Como se puede observar, la sintaxis de la sentencia "for" en Python difiere principalmente en que no se tiene la variable contador inicializada en algún valor, la condición de fin y el incremento, como vimos en los pseudocódigos de los ejercicios del tema 2 - Introducción a Estructuras Básicas - Estructuras Repetitivas.  Sin embargo, esta sintaxis si se mantiene en otros lenguajes de programación como es el caso de C o C++.

La sentencia "for" en Python tiene la característica de que puede recorrer tipos datos que sean iterables, más adelante en el tema 7 se verán otros tipos de datos denominados colecciones de datos los cuales se pueden utilizar en la sentencia "for" para ser recorridos.

Sin embargo, Python tiene una forma de implementar la sentencia "for" de manera similar a la de los otros lenguajes de programación, y es mediante el uso de la Función range().

Llegado a este punto debemos ser capaces de seleccionar la herramienta adecuada ("for" o "while") según el problema que se nos presente. Sin embargo, generalmente suele suceder que se opta por utilizar siempre la misma, debido a que se comprende mejor su uso por haber dedicado más tiempo a su estudio. Llevando a tener que realizar adecuaciones que no deberían ser necesarias si se hubiera optado por la herramienta adecuada.

CUANDO TU ÚNICA HERRAMIENTA ES UN MARTILLO, TODO PARECE UN CLAVO 

5.1. Función range(start, stop, step)

La función "range( )" devuelve una secuencia de números enteros a partir de un inicio (cero por defecto) hasta un valor final especificado, en pasos enteros (uno por defecto).

La sintaxis de la función range( ) es la siguiente:

Algunas observaciones a tener en cuenta de la función range( ) son:

• Cada argumento (inicio, fin y paso) van separados por comas.
  
• Solo es necesario especificar un argumento (fin), el resto la función toma los valores por defecto (inicio = 0 y paso = 1).
  
• Se puede especificar dos argumentos, en ese caso la función considera que los argumentos que se están ingresando son el inicio y el fin, por lo tanto toma el valor de paso por defecto.
  
• En caso de no recordar el orden de los argumento se puede utilizar la regla mnemotécnica INFINITO INCREMENTO: INicio, FINito, INCREMENTO.
  
• El último valor de la secuencia generada es igual al valor de "fin" menos el "paso".
  

A continuación veremos ejemplos del uso de la función range( ).

Función range(inicio, fin, paso) con tres argumentos

En el siguiente ejemplo se observa el uso de la función con tres argumentos, en conjunto con la sentencia "for"

La salida de este código es:

donde podemos realizar la siguiente observación:

• El programa muestra por pantalla 2 números, correspondientes al valor de inicio especificado como argumento y el valor final menos el paso, datos que también fueron pasados como argumento a la función.

• ¿Qué salida se tiene si range(5, 25, 5)?.

Función range(inicio, fin) con dos argumentos

En el siguiente ejemplo se observa el uso de la función con dos argumentos, en conjunto con la sentencia "for"

La salida de este código es:

donde podemos realizar las siguientes observaciones:

• Al especificar 2 argumentos tomó por defecto solamente el valor del paso.
• El programa muestra por pantalla 4 números, que es igual al valor de "fin" menos "inicio".
• El primer valor mostrado es 1, que es el valor de inicio pasado como argumento a la función.

• ¿Qué se mostraría por pantalla si range(2, 10)?.
• ¿Y si range(2, 2)?.
• ¿Cómo sería la salida del código si el valor de inicio es mayor que el de fin?, por ejemplo: inicio = 10 y fin = 2.
• ¿Cuántas veces se ejecuta el ciclo "for" en este último caso?. Tiene sentido la salida?.

Función range(fin) con solo un argumento

En el siguiente ejemplo se observa el uso de la función con un solo argumento, en conjunto con la sentencia "for"

La salida de este código es:

donde podemos realizar las siguientes observaciones:

• Al especificar solo un argumento tomó por defecto como inicio el valor 0, y como paso el valor 1
  
• El programa muestra por pantalla 5 números, que es igual al valor pasado como argumento a la función range( ).
  
• El último valor mostrado es el 4, que es igual al valor del argumento menos el paso.

Función range( ) con paso negativo o decremento

Con la función "range( )" también se puede generar una secuencia de números cuyo valor se vayan decrementando. Para ello el "inicio" debe ser mayor que el "fin" y se debe especificar el paso negativo como se muestra a continuación.

siendo la salida del programa la siguiente:

• Si el valor del paso es -6, ¿Qué salida se obtiene?.
• Si el paso es 2, ¿Qué salida se obtiene?.
• Si no se especifica el paso, ¿Qué salida se obtiene?.
• ¿Es cierto que cuando quiero obtener una secuencia negativa tengo que cargar si o si los tres argumentos de la función range( )?. ¿Por qué?.

5.2. Ciclo "for" y datos del tipo "string"

Hemos visto en el Tema 3: Variables y Constantes que los "string" son arreglos de caracteres y que es posible acceder a cada elemento del "string" mediante la posición.

Además, se comentó que el "for" en Python puede recorrer tipos datos que sean iterables. Y los "string" son iterables por lo tanto podemos recorrer un "string" utilizando la sentencia "for".

Por ejemplo:

este código devuelve la siguiente salida:

como podemos observar, "i" toma en cada iteración del bucle "for" un valor de la cadena de caracteres, que luego es mostrada por pantalla con la función "print( )". Esto se repite en el caso de los otros tipos de datos iterables que veremos más adelante.

• Considerando la forma de acceder a cada elemento de un "string" que se vio en el Tema 3. Modifique el código para utilizar la función "range( )". 

5.3. Ejemplos del uso de la sentencia "for"

Consigna 1:

Crear un código en Python que obtenga la suma de todos los números positivos divisibles por tres hasta el mil.

• ¿De qué otra forma se le ocurre que se puede obtener el mismo resultado?.

Consigna 2:

Realizar un programa en Python que pida al usuario que ingrese un número y calcular su factorial.

• Observe la función range( ). ¿Por qué se inicia en 1 y se termina en "num + 1"?.
• Modifique el programa para que en caso de ingresar un número negativo pida el reingreso.

Consigna 3:

Realizar un programa en Python que cuente la cantidad de vocales y consonantes que tiene una frase ingresada por teclado.

• Según su uso, ¿Qué tipo de variable es "es_vocal"?.
• ¿Qué es "isalpha( )"?.
• ¿Cuál es la función de "isalpha( )" en el código?.
• ¿Por qué en la línea 7 se coloca en FALSO "es_vocal" en cada iteración del bucle "for" más externo?.
• ¿Por qué en la línea14 no se utiliza un "else" en lugar del "elif"?.

5.4. Ejercicios propuestos "for"

1) Imprimir los números del 1 al 10 al revés utilizando el ciclo for.

--------------------------------------------------------------------------------------------------------------------------

2) Crear un bucle que cuente todos los números pares hasta el 100.

-------------------------------------------------------------------------------------------------------------------------

3) Crear un programa que muestre la tabla del 2.

-------------------------------------------------------------------------------------------------------------------------

4) Crear un programa que muestre las tabla del 2 al 9.

-------------------------------------------------------------------------------------------------------------------------

8) Cree un bucle que sume los números del 100 al 200

-------------------------------------------------------------------------------------------------------------------------

9) Definir una constante N. Definir un string con una cantidad de caracteres mayor a N. 

Se debe utilizar un ciclo for para recorrer el string, un contador para contar y para almacenar en los primeros N caracteres en otro string.

------------------------------------------------------------------------------------------------------------------------

10) Se ingresa "x" por teclado, mostrar los primeros "x" términos de la serie  x^x  .

Ej: Si ingreso x=5, se muestra 1, 1, 4, 27, 256. 

6. Ciclo "while"

El "while" es una estructura repetitiva básica y muy utilizada en los lenguajes de programación.

La sintaxis de la instrucción "while" en Python es la siguiente:

la misma cuenta con la palabra reservada (keyword) while, la condición (lógica) y dos puntos. En la línea inferior en un nivel de identación más adentro se encontrará el conjunto de instrucciones que se deben ejecutar mientras la condición del "while" sea VERDADERA.

¿Cómo interpretar la sentencia "while"?

La palabra "while" en inglés significa "mientras", por lo tanto, la sentencia se interpreta de la siguiente manera:

"MIENTRAS LA CONDICIÓN SEA VERDADERA EJECUTA EL BLOQUE DE INSTRUCCIONES"

¿Cuándo utilizar el ciclo "while"?

Este ciclo se utiliza cuando NO SE CONOCE el número de veces que se deben ejecutar las instrucciones que se encuentran dentro de ella, por lo tanto, se tiene un número indefinido de iteraciones. Tener en cuenta, que indefinido no significa infinito, el bucle tiene un final, el cual será cuando la condición sea FALSA.

6.1. Ejemplos de usos de "while" controlado por valor

Consigna 1:

Ingresar números por teclado y acumular hasta que el valor acumulado supere a 1000. Se debe ir mostrando el acumulado a medida que se cargan los valores y el acumulado total al finalizar.

Consigna 2:

Ingresar números por teclado y acumular hasta que el acumulado supere a 1000, al finalizar mostrar el promedio. Hay que tener en cuenta, que para calcular el promedio se necesita saber la cantidad de números que fueron ingresados, por lo tanto es necesario contar cada ingreso.

• ¿Generaría un problema que el usuario ingrese el valor 0.5?.
• En los dos ejemplos anteriores, ¿Qué sucede si el usuario ingresa un carácter en lugar de un número?. En caso de que exista un problema, aplique una solución con los conocimientos adquiridos hasta acá.

6.2. Ejemplos de usos de "while" controlado por evento

Consigna 1:

Calcular el promedio de notas que se ingresa, el proceso finaliza al ingresar -1 (uno negativo).

Para simplificar el código, se asume que no se van a ingresar valores que puedan producir un error de excepción (ingreso de carácter)

• ¿Qué evento debe pasar para que el bucle se termine?.
• ¿Qué sucede si el primer valor que se ingresa es -1?.

• Se dice que el ingreso de notas termina por un EVENTO, porque la condición que aborta el ciclo, es un ingreso no válido (no una excepción)

Consigna 2:

Se quiere calcular el promedio de notas que se van ingresado, el proceso finaliza al ingresar un string que no sean números.

• En línea 10 se establece calculando = True para que en la línea 11 la condición del "while" sea verdadera e ingrese al bucle de nuestro programa.
• En línea 12 se ingresa por teclado la nota como "string".
  
• Defino un bloque try, para que intente convertir la nota tipo "string" ingresada a un valor "float", si lo consigue NO hay excepción, y puede acumular y contar.
  
• Si se genera una excepción, en la linea 14, nota = float(nota) , esta sería por "ValueError", no puede convertir el string a float, por lo que ejecuta el bloque de excepción.
  
• En el bloque de excepción se cambia el valor de calculando = False para que se aborte el bucle "while".
• Fuera del "while", línea 21 cálculo el promedio y en la 23 muestro.

• ¿Qué diferencias observa en los scripts mostrados para garantizar el ingreso al bucle?.
• ¿Qué tipo de dato es "calculando" en el segundo script?.
• ¿Cree que el código es correcto?.
• ¿Qué sucede si se ingresan valores negativos para las notas? ¿Funciona?.
• ¿Qué sucede si las notas ingresadas no pertenecen a [0,10]? ¿Funciona?.
• ¿Qué pasa si el primer valor ingresado es una letra?.

A continuación, se deja otra posible solución a la Consigna 2 para que lo analice.

• Vemos que a medida que avanzamos en el materia, los programas se vuelven mas largos y complejos.
• Ver que si tuviéramos que incorporar consideraciones para que no se ingresen notas negativas o fuera de [0,10] el programa adquiere mayor dificultad y se vuelve mas largo (más código).
• Vemos que considerar TODAS las alternativas y prevenirse de ingresos no válidos hace mas complejo el código.
• Respecto del punto anterior, algunas veces las consignas que se plantean, limitan los ingresos (ejemplo: a números reales), para buscar que el alumno SOLO use algún concepto a ser evaluado (ejemplo: "while")  y no se disperse con otros temas (ejemplo "try/except").
• Vemos que hay muchas soluciones, para una consigna tan sencilla, no necesariamente infinitas pero probablemente más de 350 soluciones distintas pueden surgir.
• En la materia no tenemos 350 alumnos, por lo que es SUGESTIVO que dos alumnos tengan la misma solución (copiar --> 😡).
• Notar que cambiar el nombre de las variables sería un cambio cosmético y no un programa distinto, esto suelen hacer algunos alumnos que copian para DISFRAZAR el código que hizo otro y hacerlo pasar como propio.
• En este caso es tan culpable el que copia como el que facilita el código para que otro lo copie, en los casos que se detectaron ambos alumnos han sido REPROBADOS 😳.

6.3. Ejercicio propuestos

El docente propone en clase estos ejercicios para fijar conceptos de ;

• acumulado
• contador 
• while.

1) Ingresar números por teclado mientras que el acumulado sea menor o igual a 99

Mostrar al total acumulado.

2) Ingresar números por teclado mientras que el acumulado sea menor o igual a 99, mostrar la cantidad de valores acumulados.

3)Ingresar números por teclado mientras sean menores que 99, cuando ocurra el 1er numero mayor a 99, mostrar el promedio.

4) Ingresar números por teclado mientras que el el ingreso sea mayor o igual a cero. Cuando se ingresa un valor negativo, mostrar el promedio.

7. Sentencias "continue" y "break"

A continuación veremos dos sentencias que pueden ser utilizadas en conjunto con los bucles "while" y "for" para controlar el flujo del programa

7.1. "continue"

La palabra reservada "continue" se utiliza en un bucle para saltar a la siguiente iteración , sin ejecutar el resto del código de la iteración actual.

A continuación, se muestra un ejemplo del uso del "continue" para mostrar por pantalla solamente los números pares:

la salida del programa es:

Como se puede observar, cada vez que el resto es distinto de 0 (cero) se ejecutó la sentencia "continue" pasando a la siguiente iteración del bucle sin ejecutar la sentencia "print(i)" que se encuentra debajo del "continue".

En el bucle "while" el comportamiento de la sentencia "continue" es el mismo, como podemos observar en el siguiente ejemplo, donde se realizó un programa que pide el ingreso de un número mayor a 5 y muestra la secuencia decreciente de números hasta 0 (cero) omitiendo el 5.

Si se ingresa 9 la salida es:

Podemos observar que el 5 no se muestra en la salida, debido a que cuando "var" es igual a 5 se ejecuta la sentencia "continue" pasando a la siguiente iteración sin ejecutar el print() que se encuentra a continuación.

7.2. "break"

La sentencia "break" se utiliza cuando se quiere salir por completo de un bucle. A diferencia de la sentencia "continue" que pasa a la siguiente iteración,  una vez que se ejecuta el "break" se termina completamente el bucle donde se encuentra alojado el "break".

Esto es útil cuando se necesita terminar un bucle de forma prematura cuando se alcanza cierta condición

A continuación se puede ver un ejemplo de la sentencia "break":

La salida del programa es:

Se puede observar que aun cuando la función range() estaba configurada para terminar en 10 (fin - paso) el programa solo mostró hasta el valor 4, debido que cuando "i" tomó el valor 5, se ejecutó la sentencia "break" terminando el bucle "for".

7.3. Observaciones

• Tanto el "continue" como el "break" solo se pueden utilizar dentro de bucle repetitivos ("while" y "for"). En el caso de querer ejecutar algunas de estas sentencias fuera de un bucle repetitivo se producirá un error del tipo de sintaxis.

• Ambas sentencias tienen control sobre el bucle más interno en el cual se encuentran colocadas. Es decir, si se utiliza dos bucles anidados y las sentencias se encuentran dentro del bucle más interno, cuando se ejecuten solo afectarán a ese bucle no al externo. En el caso del "continue" se pasará a la siguiente iteración del bucle más interno y en el caso del "break" se terminará completamente ese bucle.

Caso del "continue":

la salida es:

Como se puede observar, en las dos iteraciones externas se omitió el 5.

Si cambiamos el "continue" por un "break"

y la salida es:

En este caso en las dos iteraciones más externas solo se llegó hasta el valor 4 debido a que el "break" terminó el bucle interno.

Como se puede observar en ambos caso, tanto el "continue" como el "break" no afectaron la ejecución del bucle más externo

8. Fibonacci

8.1. Consigna 1

Mostrar la Sucesión de Fibonacci con bucle while hasta valores menores a un número ingresado por teclado. Para simplificar el ejercicio vamos a asegurar que se ingresa un número entero y no un valor de otro tipo

• Alternativa 1: While sencillo

Figura 2

En este caso a y b son las semillas. Con a y b genero c = a + b.

Pero luego para generar el próximo término debo "correrme" o rotar valores de lugar, esto sería que las variables a y b cambian de valores.

a=b # Roto los valores
b=c # Roto los valores

Figura 3

• Alternativa 2: while pero con código mas elaborado y compacto.
  

Se deja al alumno analizar esta otra solución mas compacta, el desafío es entender el código.

• Alternativa 3: While por evento con if/else
  

1. Vemos que hay en la línea 21 una sentencia llamada break, esta sentencia hace que se rompa o aborte el bucle while, según se explicó previamente.
2. Vemos que hay muchas soluciones, para una consigna tan sencilla, no sabemos si infinitas soluciones pero seguro de que mas de 350 soluciones distintas pueden surgir.
3. Ver que son 340 alumnos (mas de 350), por lo que es SUGESTIVO que dos alumnos tengan la misma solución (=> copiar )
4. Notar que cambiar el nombre de las variables sería un cambio cosmético y no un programa distinto, esto suelen hacer algunos alumnos que copian para DISFRAZAR el código que hizo otro y hacerlo pasar como propio.
5. En este caso es tan culpable el que copia como el que facilita al código para que otro lo copie, en los casos que se detectaron ambos alumnos han sido reprobados.

9. Preguntas

• Dado el siguiente código:

cuenta = 0

resultado = 0

for i in range(10):

cuenta = cuenta + 1

resultado = resultado + i

¿Qué función realiza la variable "resultado"?

1. Cuenta todo los valores generados por la función range().
2. Acumula los valores generados por la función range().
3. Guarda en la variable "cuenta" los valores generados por la función range().
4. Ninguna de las anteriores.

• Dado el siguiente código

cuenta = 0

resultado = 0

for i in range(1000):

    cuenta = cuenta + 1

    if cuenta%2 == 0:

        resultado = resultado + i

print(resultado)

¿Qué hace el código?

1. Suma los números impares.
2. Suma los números pares.
3. Suma los números con posición impar.
4. Suma los números con posición par.

• Dado el siguiente código:

while a < 3:

print(a)

a = a + 1

¿Cuántas iteraciones realiza el código?

1. Una.
2. Dos.
3. Tres.
4. Ninguna.

10. Ejercicios propuestos

1) Implementar un código que presente un menú con diferentes opciones. Cada opción mostrará un mensaje característico. Debe existir una opción que permita finalizar el programa. En el caso de introducir una opción incorrecta, se deberá notificar lo sucedido y pedir reingreso.

**************************************************

2) El cifrado César mueve cada letra un determinado número de espacios en el alfabeto

Realizar un programa que presente un menú con las opciones encriptar, desencriptar una palabra o frase. Decidir la forma conveniente para solicitar los datos al usuario.

**************************************************

3) Escribir un programa que genere y muestre por pantalla los caracteres imprimibles de la tabla ASCII.

Utilizar la función chr( ).

Se debe obtener la siguiente salida:

**************************************************

4) Escribir un programa que, dada una frase ingresada por teclado, imprima una frase describiendo la letra que más se repite y la cantidad de repeticiones.

Ejemplo:

**************************************************

5) Se entiende que una secuencia de caracteres está correctamente equilibrada con respecto a los paréntesis si cada uno de los paréntesis de apertura tiene su paréntesis cerrado.

Escribir un programa que permita ingresar e indicar si una cadena está correctamente balanceada con respecto a paréntesis.

6) Escribir un programa que permita leer un número entero positivo desde teclado e imprima la suma de los dígitos que lo componen.

Si ingresa un cero o un valor negativo mostrar un mensaje con 2 opciones; "Volver a intentarlo" o "Salir".

7) Realizar un programa que permita adivinar un número. Para ello se solicitara el ingreso por teclado del numero a adivinar (entero). Luego se irán solicitando mas números y se deberá ir averiguando si el número a adivinar es mayor o menor que el introducido (ir mostrando carteles indicativos). El programa termina cuando se acierta el número.

**************************************************

8) Escribir un programa que pida al usuario un número entero positivo y muestre por pantalla todos los números impares desde 1 hasta ese número separados por comas.

**************************************************

9) Escribir un programa que lea 10 números enteros y luego muestre cuántos valores ingresados fueron múltiplos de 3 y cuántos de 5. Tener en cuenta que hay números que son múltiplos de 3 y de 5 a la vez

**************************************************

10) Ingresar "N" valores  y mostrar cual es el elemento menor y en que posición se ingreso. El valor de "N" se ingresa por teclado y debe ser mayor o igual a 2. En caso de ser menor se debe pedir reingreso hasta que se ingrese el dato correcto.

**************************************************

11) Modificar el ejercicio anterior para que en caso de ingresar un valor de "N" menor a 2 pida el reingreso como máximo 5 veces, y en el caso de no haber ingresado un dato correcto mostrar un cartel que diga "Programa terminado por muchos intentos erroneos".

**************************************************

12) Escribir un programa que solicite un número entero positivo, si se ingresa otra cosa, se deberá mostrar un mensaje indicando un error. 

A partir del entero válido, por pantalla se mostrarán sus divisores.

NOTA: si el ingreso es erróneo más de 2 veces, se deberá dar una opción para finalizar el programa.

**************************************************

13) Escribir un programa que solicite un número entero mayor que 1, si se ingresa otra cosa, se deberá mostrar un mensaje indicando un error.

A partir del entero válido, por pantalla se mostrará si es o no primo (número natural mayor que 1 que tiene únicamente dos divisores distintos: él mismo y el 1).

NOTA: si el ingreso es erróneo más de 2 veces, se deberá dar una opción para finalizar el programa.

**************************************************

14) Escribir un programa que solicite un número entero positivo, si se ingresa otra cosa, se deberá mostrar un mensaje indicando un error.

A partir del entero válido, por pantalla se mostrará su factorial, considerar el caso del 0 (cero).

NOTA: si el ingreso es erróneo se mostrará un mensaje con 2 opciones; "Volver a intentarlo" o "Salir".

15) Escribir un programa que solicite un número entero positivo, si se ingresa otra cosa (letras por ejemplo), no realizar la operación normal del programa.

A partir del entero válido, por pantalla se mostrará la tabla de multiplicar del mismo, del 1 al 10 como en la escuela.

NOTA: si el ingreso es erróneo, decidir cómo proceder con el programa.

**************************************************

16) Escribir un programa que solicite un número entero para analizarlo, si se ingresa otra cosa, se deberá mostrar un mensaje indicando un error.

A partir del entero, por pantalla se mostrará información al respecto.

Información a mostrar:

• Si es par, impar
• Positivo, negativo (decidir el caso del 0)
• Su factorial, si es posible
• Si es primo
• Sus divisores, si no es primo
• Cantidad de dígitos

17) Escribir un programa que permita validar/catalogar una frase ingresada como posible contraseña. De acuerdo al análisis, se devolverá el nivel de seguridad correspondiente.

Se considerarán las siguiente pautas:

• Longitud menor a 6: No válido como clave. Seguridad 0
• Carácter en minúscula. Seguridad +1
• Carácter en mayúscula. Seguridad +1
• Carácter numérico. Seguridad +1
• Carácter símbolo. Seguridad +1
• Longitud mayor a 10. Seguridad +1

Mostrar al finalizar, la clave ingresada seguida del nivel de seguridad (Seguridad 5 es el máximo, se cumplen todos los requisitos).

18) Escribir un programa que permita ingresar el límite inferior y superior de un intervalo. Si el límite inferior es mayor que el superior, deberá intercambiarlos. A continuación, se van introduciendo números hasta que se ingrese el 0. Cuando termine, el programa deberá mostrar cuantos números de los ingresados están fuera del intervalo, y en qué posición se ingresó el cero.

**************************************************

19) Escribir un programa que permita ingresar el monto de las ventas realizadas por "N" empleados y los nombres de cada empleado. Cada empleado tiene 4 ventas. Cada venta representa la venta de una semana del mes. "N" es un valor positivo ingresado desde el teclado que indica la cantidad de vendedores,  si "N" es negativo el programa finaliza y si "N" es positivo se deberán ingresar las "N" ventas. Al finalizar la carga se deberá indicar el monto de venta mayor, en qué posición se produjo y a quien corresponde.

Alternativa : Modificar el programa anterior para que funcione con un ciclo "while".

**************************************************

20) Realizar un programa que permita hacer distintos cálculos básicos, de la misma manera que una calculadora.

Presentar un menú como el siguiente:

Tanto la opción elegida como el par de números a computar deben ser introducidos por teclado.

Observaciones: Tener en cuenta que no existe la división por cero (x/0 no existe), si el usuario llegara a ingresar cero para el divisor, se deberá mostrar por pantalla el mensaje "Error, denominador incorrecto" y se deberá pedir el reingreso de dicho valor.

**************************************************

21) Realizar un algoritmo que permita determinar el computo y presupuesto de pintura para un edificio: El programa debe permitir que el usuario ingrese por teclado (de a una por vez) las superficies de paredes a pintar. Para el calculo de consumo de pintura asumir que se utilizan 0.3 litros de pintura por metro cuadrado de pared (0.3 litros/m²). La pintura se adquiere en tachos de 20 litros, con un costo de $6300 cada tacho. La pinturería además ofrece un descuento del 10% al costo total a partir del quinto tacho (por ejemplo, 1 tacho $6300; 5 tachos = 5*$6300=$31500 - 10% = $28350).

Realizar un Menú con las siguientes opciones:

    1- Cargar paredes (se deben cargar todas las paredes de una vez)

    2- Mostrar resultados

    f- Finalizar programa

    
Cada punto del menú debe realizar lo siguiente:
    
1- Primeramente se debe pedir el numero de paredes a computar, para luego cargarlas de a una por vez. Se deberán verificar que el dato del numero de paredes sea entero y que los datos ingresados de  superficies sean números reales.

2- Se deberá mostrar por pantalla:
    * Superficie total
    * Cantidad de pintura a utilizar
    * Precio final (mostrar ambos precios, con y sin descuento)

f- Solamente finalizar el programa al ingresar la letra f
    
OBSERVACION: Para poder obtener el numero de tachos a comprar se debe utilizar la función round( ), para conocer como funciona: https://www.programiz.com/python-programming/methods/built-in/round

**************************************************

22) Realice un programa en Python que pida al usuario el termino de la Serie de Fibonacci que quiera y le muestre por pantalla el valor de la misma.

**************************************************

23) Realizar un programa en Python que obtiene los 10 primeros elementos de la serie de Fibonacci que son primos.

**************************************************

24)      Escribir un programa que permita ingresar dos valores por teclado. Al menor de ellos guardarlo en una variable de nombre MIN y al mayor en una variable MAX. Si los valores ingresados son iguales finalizar el programa. Luego, mostrar los números comprendidos dentro del rango [MIN, MAX] contando de 5 en 5. Al finalizar mostrar la suma de todos los valores mostrados.

 **************************************************

25)    Escribir un programa que permita obtener una función exponencial, la cual está dada por:

**************************************************

26)   Realizar un programa que permita ingresar notas de alumnos [0,10] por teclado. La carga finaliza cuando se ingresa una nota no válida. Al finalizar la carga se pide que el programa muestre la cantidad de aprobados, la mayor nota ingresada, y si hubo o no un 0(cero).

 **************************************************

27.      Hacer un programa que muestre el siguiente menú:

a.      Ejercicio 24

b.      Ejercicio 25

c.       Ejercicio 26

f.        Finalizar

El usuario debe poder ingresar la opción que quiere realizar. SOLO podrá Salir del programa si ingresa f. 

Si elige a,b,c  deberá realizar las consignas de los ejercicios 24 al 26.

11. Ejercicios resueltos

A continuación, se desarrollan ejercicios sobre el tema de ciclos repetitivos.

11.1. Tabla de multiplicar

Consigna:

Realizar un programa en Python que muestre por pantalla la tabla de multiplicar (del 0 al 10) del número ingresado por teclado. El valor ingresado por el usuario se debe encontrar dentro del rango [0, 10].

• ¿Qué pasa si se ingresa una letra?.
• ¿Qué pasa si se ingresa una número real?.

Al problema anterior, aplicar una solución en el caso de que el valor ingresado por teclado no sea adecuado (entero).

Podemos ver que la líneas que van desde la 4 a la 10 se encuentran dentro del bloque "try", por lo tanto si ingresamos un valor que no corresponde y tira error, será tratado como una excepción.

En el "except" utilizamos la etiqueta "ValueError", que es lo que se quiere evitar, el ingreso de valores erróneos.

11.2. Secuencia de números múltiplos de 3

Consigna:

Realizar un programa en Python, que muestre por pantalla los números múltiplos de 3 (tres) que hay en el rango [3, "n") donde "n" es un valor ingresado por teclado por el usuario.

• ¿Por qué se coloco la etiqueta "MULTIPLO" en mayúsculas?.
• ¿Qué ventajas tengo al utilizar la etiqueta "MULTIPLO" en lugar de colocar solamente el valor?.
• ¿Qué hace el argumento "end = ", "" en la función print()?.

11.3. Fibonacci

Consigna:

Mostrar la Sucesión de Fibonacci hasta los valores menores a un número ingresado por teclado. Para simplificar, se considera que el número ingresado es entero.

Para empezar es necesario saber como se define la Sucesión o Serie de Fibonacci:

La sucesión empieza con los números 0 y 1, y a partir de estos cada siguiente término es la suma de los dos anteriores. Por lo tanto, la sucesión de Fibonacci tiene los siguientes valores:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ..., ∞

En este caso "a" y "b" son las semillas, y con ellas genero "c = a + b".

Para generar el próximo término, debo rotar los valores de lugar, es decir, "a" y "b" cambien de valores. Esto se realiza en las líneas 19 y 20 con las sentencias "a=b" y "b=c".

A continuación, se muestra otra forma de obtener la serie de  Fibonacci que es más compacta.

Solución alternativa 2:

"while" por evento con "if/else"

• ¿Qué realiza la sentencia "break" dentro del "else"?.
• ¿Cómo evitaría utilizar la sentencia "break"?.

11.4. Sumatoria "n" elementos de Fibonacci

Consigna:

Calcular la sumatoria de los "n" primeros términos de Fibonacci y mostrarlo por pantalla. Para simplificar, se considera que el valor ingresado es un entero.

• ¿Por qué se utiliza el bucle "for" en lugar del "while" utilizado en los problemas anteriores?.

11.5. for vs while

Definir un string y mostrarlo por pantalla.

Se pide al alumno que realice el mismo ejercicio con for y con while y que luego observe la cantidad de línea que utiliza cada ciclo.

Solución: