Universidad de Pamplona

Programación 2
Taller o guía Estructuras de Control Repetitivas
Elaboró: Docentes Programación II
----------------------------------------------------------------------------------------------------------------------------- ------------------------

Estructuras de control repetitivas e iterativas (Bucles)

Son las estructuras que nos permiten crear ciclos dentro de los programas o funciones. Este tipo
de estructuras controlan el número de veces que se debe ejecutar una o varias instrucciones
(bloque). A la repetición de cada una de las instrucciones se denomina iteración. Al conjunto de
instrucciones que se repite se denomina bucle.

En conclusión, controla la ejecución de las asignaciones, cuando se necesita repetir muchas veces
un mismo grupo de asignaciones. Se puede visualizar en las siguientes figuras como sería la
realización de las instrucciones rojas y azules, utilizando o no estructura de control repetitiva.

En programación es usual encontrar estructuras repetitivas como el do … while, For y el while, sin
embargo, en Python estudiaremos el while y el for que en su traducción se conoce como el mientras
y para.

La estructura for en Python es usada para iterar sobre una secuencia (list, tuple, string) o cualquier
otro objeto iterable.

Estructura de control repetitiva while

En Python tiene una palabra reservada llamada while que nos permite ejecutar ciclos, o bien
secuencias periódicas que nos permiten ejecutar código múltiples veces. El ciclo while nos permite
realizar múltiples iteraciones basándonos en el resultado de una expresión lógica que puede tener
como resultado un valor True o False. Python interpreta cualquier valor diferente de cero como
True. None y 0 son interpretados como False.
 Universidad de Pamplona
Programación 2
Taller o guía Estructuras de Control Repetitivas
Elaboró: Docentes Programación II
----------------------------------------------------------------------------------------------------------------------------- ------------------------

En el while se evalúa la expresión booleana y, si es cierta, se ejecuta la instrucción especificada,

llamada el cuerpo del bucle. En este momento es necesario actualizar la condición a evaluar, pues
sino el ciclo se repetirá indefinidamente; actualizada la condición, se evalúa nuevamente hasta
que la evaluación de la condición arroje un valor falso.

En la estructura mientras, primero se evalúa la condición antes de ejecutar el bloque de

instrucciones, haciendo esto que el bloque se ejecuté o no. A este tipo de instrucciones se les
denomina repetitivas y se utilizan cuando no se conoce previamente el número de veces que se
tiene que ejecutar un bucle.

La sintaxis de esta estructura es:

While (condición bucle) :

Sentencia 1
Sentencia 2
... Cuerpo
Sentencia n

Actualizar condición

A continuación, se muestra la representación gráfica de este tipo de estructura

Condición
Bucle

Verdadera

Sentencias

En conclusión, la variable de control del bucle (condición del bucle) debe ser inicializada, evaluada
y actualizada en la ejecución del programa para que el cuerpo del bucle se ejecute adecuadamente.

Ejemplo de Bucle ‘while’ controlado por Conteo. Función que suma los números anteriores a n (n es un
número entero positivo)

#FUNCIÓN QUE REALIZA LA SUMA DE LOS NÚMEROS ANTERIORES A n

def sumar_n(n):
total = 0
i=1
while (i <= n):
total = total + i
i = i+1
return total

#CODIGO DE PRUEBA
a=8
print(sumar_n(a))
 Universidad de Pamplona
Programación 2
Taller o guía Estructuras de Control Repetitivas
Elaboró: Docentes Programación II
----------------------------------------------------------------------------------------------------------------------------- ------------------------

En este ejemplo tiene un contador con un valor inicial de 1, cada iteración del while manipula esta
variable de manera que incremente su valor en 1, por lo que después de su primera iteración el
contador tendrá un valor de 2, luego 3, y así sucesivamente.

Eventualmente cuando el contador llegue a tener un valor de n, la condición del ciclo i <= n será
False, por lo que el ciclo terminará retornando el valor de la variable total.

Ejemplo Bucle ‘while’ controlado por Evento

# Función que realiza la solicitud de notas hasta que el usuario digite -1 para salir

def promedio_notas():
promedio, total, contar = 0.0, 0, 0
print ("Introduzca la nota de un estudiante (-1 para salir): ")
grado = int(input())
while grado != -1:
total = total + grado
contar = contar + 1
print ("Introduzca la nota de un estudiante (-1 para salir): ")
grado = int(input())
promedio = total / contar
return(promedio)

# Código de Prueba

prome=promedio_notas()
print ("Promedio de notas del grado escolar es: " + prome)

En este casi el evento que se dispara cuando el usuario ingresa el valor -1, causando que el bucle
while se interrumpo o no se inicie.

Los ciclos mientras pueden ser controlados por tipos de variables que se denominan banderas,
conocidas también como interruptores, switch, flags o conmutadores. Las banderas son variables
que pueden tomar solamente dos valores durante la ejecución del programa, los cuales pueden
ser 0 ó 1, o bien los valores booleanos True o False. Se les suele llamar interruptores porque
cuando toman los valores 0 ó 1 están simulando un interruptor abierto/cerrado o
encendido/apagado. Se usan para controlar la ejecución de la iteración.

Sentencias utilitarias

A continuación, se presentan algunos ejemplos del uso de sentencias utilitarias usadas en el bucle
while o for:

Sentencia break

A continuación, se presenta un ejemplo del uso del bucle while controlado la sentencia break:

Ejemplo:

variable = 10
while variable > 0 :
print (“Actual valor de variable:”, variable)
variable = variable -1
if variable == 5:
break
 Universidad de Pamplona
Programación 2
Taller o guía Estructuras de Control Repetitivas
Elaboró: Docentes Programación II
----------------------------------------------------------------------------------------------------------------------------- ------------------------

Adicionalmente existe una forma alternativa de interrumpir o cortar los ciclos utilizando la palabra
reservada break.

Esta nos permite salir del ciclo incluso si la expresión evaluada en while (o en otro ciclo como for)
permanece siendo True. Para comprender mejor use el mismo ejemplo anterior donde se usa el for y
la función range() pero se interrumpe el ciclo usando la sentencia break.

Sentencia continue

A continuación, se presenta un ejemplo del uso del bucle while controlado la sentencia continue:

Ejemplo:

variable = 10
while variable > 0:
variable = variable -1
if variable == 5:
continue
print (“Actual valor de variable:”, variable)

La sentencia continue hace que pase de nuevo al principio del bucle aunque no se haya terminado
de ejecutar el ciclo anterior.

Ejercicios

1. Utilizando sentencia while, realizar una función en Python que calcule la suma de los cuadrados
de los primeros diez números enteros positivos, imprimiendo el resultado.
2. Realizar una función en Python que indique si el número dado es un número primo.