Bucles for, while en Python: Sintaxis, Ejemplos de su uso

Bucles en python

Para comenzar vamos a ver que son y para que nos sirven en programación:

A veces voy por la vida pensando que tal vez estemos atrapados en un bucle infinito producto de un ordenador gigante!

-Basta ya de filosofía!! Este es un blog de programación!

-Ho cierto!!

Un bucle o ciclo en programación es la ejecución  continua de un determinado bloque de código mientras una condición asignada se cumple..

Es decir por ejemplo que un bucle es una parte de nuestro programa que se ejecuta continuamente mientras se cumpla determinada condición. Existen también los bucles infinitos en python que son aquellos en los cuales la condición nunca se cumple.

Para recordar y ejemplificar en la vida real un bucle supongamos que tu debes viajar de un punto «a» a un punto «b» de tu ciudad y lo debes hacer en bicicleta. Obviamente tu vas a pedalear desde el punto «a» al punto «b» repitiendo este proceso como un bucle hasta que se cumplan algunas condiciones:

-Que llegues a destino («Punto b»)

-Que te canses

-O debas parar de pedalear por algún problema externo, como el tráfico.

Si estas condiciones no se cumplieran tu deberías pedalear infinitamente. Aunque en la vida real esto es obviamente «imposible» resulta clara la ejemplificación de un bucle.

Existen diferentes tipos de Ciclos en python y nos van a servir para ejecutar nuestro código hasta obtener determinado resultado.

Bucles For

En python iteran sobre los ítem de cualquier secuencia (lista, cadena, diccionario) en el orden en que aparecen en la secuencia.

Iterar: significa realizar cierta acción repetidas veces y en el caso de for hace referencia a recorrer elementos iterables, como puede ser un diccionario en búsqueda de un elemento en particular.

Este bloque de código en el bucle se suele llamar «cuerpo del bucle» y cada repetición se suele llamar iteración.

Para no complicarnos tanto podemos entender al bucle for como el encargado de recorrer una secuencia buscando esos elementos que cumplen determinada condición y realizando alguna instrucción según sea especificada. Es importante recalcar que dichos elementos deben ser «iterables» es decir recorribles.

Un bucle for podría verse como hojear un libro pagina por pagina y extraer solo las imágenes. El hecho de extraer solo las imágenes sería la condición y una vez extraídas todas se habría cumplido por lo que el bucle se detendría.

Si has comprendido el uso del ciclo for, es hora de ver su sintaxis. Venga que es muy sencillo!

Sintaxis

En el caso de un bucle for se debe especificar la variable donde se alojarán los ítem del elemento iterable (lista, diccionario, cadena, etc.)

Se coloca la sentencia for seguida de la variable donde se almacenarán los ítem y luego del operador «in» el elemento a iterar:

for variable in elemento_iterable:
    cuerpo de la repetición

Una vez que se termina de iterar el elemento el bucle se detiene, es decir que se ejecutará mientras se cumpla la condición, veamos algunos ejemplos.

Ejemplos

En este ejemplo vamos a iterar una lista de números y vamos a extraer solo aquellos que son pares:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  sin título.py
#  
#  Copyright https://pythones.net

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9
,10, 11, 12, 13, 14] #Creamos la lista con números
for num in numeros: #En la variable "num" almacenamos los ítem de la lista
    if num % 2 == 0: #Condición: Si el resto de la división por dos es cero entonces:
        print (num) # Imprimimos la variable num

Resultado: 2, 4, 6, 8, 10, 12, 14

Aquí estamos creando un bucle que itera sobre la lista números almacenando los ítem de ella en la variable «num» e imprimiendo aquellos que cumplen la condición de «al dividirlos por 2, da resto cero». Esto lo hacemos utilizando el operador aritmético «%» y el de comparación «==» que vimos anteriormente.

Si tu ejecutas este código verás que solo ha de imprimir los números pares, pero si cambiáramos el operador de comparación «==» (exactamente igual) por «!=» (diferente) a cero, nos imprimiría los impares. Prueba lo siguiente:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  sin título.py
#  
#  Copyright https://pythones.net

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9
,10, 11, 12, 13, 14] #Creamos la lista con números
for num in numeros: #En la variable "num" almacenamos los ítem de la lista
    if num % 2 != 0: #Condición: Si el resto de la división por dos es cero entonces:
        print (num) # Imprimimos la variable num

Resultado: 1, 3, 5, 7, 9, 11, 13

El bucle es el mismo, pero solo hemos cambiado la condición y en este caso nos imprimirá los números impares de la lista «números».

Usos comunes del bucle for:

Iterar Listas

Como vimos anteriormente es útil para iterar en listas, pero venga veamos otro ejemplo (que para eso estamos). En este caso vamos a iterar esta lista para contar los caracteres de cada palabra que contiene utilizando la función interna de cadenas len():

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  sin título.py
#  
#  Copyright https://pythones.net

Palabras = ['Peine', 'Pelo', 'Ventana', 'Refrigerador', 'Adolescente', 'Dentista', 'Asesino'] 
#Lista de palabras
for caracteres in Palabras: #Creamos el bucle para iterar Palabras y almacenar en caracteres
    print ((caracteres), ('###Longitud:'), (len(caracteres))) 
#Aquí imprimimos la variable caracteres
# y luego la cadena "###Longitud:" y seguido utilizando la
#Función predefinida "Len()" la longitud de cada palabra

Resultado:

Peine ###Longitud: 5
Pelo ###Longitud: 4
Ventana ###Longitud: 7
Refrigerador ###Longitud: 12
Adolescente ###Longitud: 11
Dentista ###Longitud: 8
Asesino ###Longitud: 7

Iterar Diccionarios

El ciclo for nos permite iterar diccionarios operando con clave y valor, en este ejemplo supongamos que tenemos una agenda telefónica en forma de diccionario y queremos imprimirla completa:

Agenda = {
'Marcelo' : '3443456993',
'Gaston' : '3443456992',
'Lucas' : '3443456991',
'Angela' : '3443456990',
'Lucio' : '3443456989'
} #Aqui hemos creado nuestra agenda como un diccionario
#Ahora creamos el bucle definiendo las variables k y v 
#para Key y Value (clave y valor)
for (k, v) in Agenda.items():
    print (k, v)
#Utilizamos el método .items() en python 3 para evitar errores.
#Imprimimos el resultado de las variables

Resultado:

Marcelo 3443456993
Lucio 3443456989
Lucas 3443456991
Gaston 3443456992
Angela 3443456990

Iterar cadena string

Utilizando el bucle for podemos iterar cadenas de texto, en este ejemplo vamos a iterar una cadena para contar una letra predeterminada:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  sin título.py
#  
#  Copyright https://pythones.net
#  
entrada = "hola estoy programando en python" #Cadena de texto a analizar
contador = 0
cuentalaletra = 'a' #Almacenamos en la variable la letra que queremos contar

for letra in entrada: #Almacenamos en letra cada ítem de la cadena
    if letra == cuentalaletra: #Si el ítem es igual a la letra a contar
        contador =contador + 1 #Sumamos uno al contador
    
print ((cuentalaletra), (':'), (contador)) #Imprimimos la letra a contar 
                                            #y el número del contador

Resultado: a : 3

Como podemos ver el código nos permite contar la cantidad de veces que se repite una letra dentro de una secuencia de texto, ya sea cambiemos la cadena o la letra, siempre nos va a permitir contarla.

Primeramente declaramos la variable entrada para la cadena a almacenar, seguido un contador que establecemos en cero por defecto y la variable cuentalaletra que almacena la letra que vamos a contar!

Después mediante un bucle for iteramos la cadena almacenando los ítems en la variable letras y mediante un condicional comprobamos que la letra sea igual a la variable cuentaletra. Si lo es, sumamos uno al contador y finalmente imprimimos los resultados.

Bucles While

El bucle while nos permite ejecutar un bloque de código continuamente mientras la condición sea verdadera e incluso podemos crear bucles infinitos.

Estos se ejecutan mientras la condición sea verdadera, es decir, si la condición se cumple se ejecutara el cuerpo de dicho bucle y al finalizar se volverá a comprobar la condición, si continua siendo verdadera pues se ejecutara nuevamente. En caso contrario omitirá el mismo y continuará la ejecución normal del programa. Venga veamos como crear un bucle while y para que nos ha de servir.

Sintaxis

Es realmente muy sencilla, escribimos la palabra reservada While seguida de la condición y dos puntos, debajo de esta se encontrara el cuerpo del mismo.

while (condición):
    Cuerpo de la repetición

Veamos algunos ejemplos desde el mas sencillo para entender el funcionamiento y uso de un bucle while:

Ejemplos

Contador usando while

Vamos a ver un ejemplo clásico de bucle while donde creamos un contador e imprimimos el resultado hasta que la condición deje de cumplirse, en este caso contaremos del 1 al 10.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
i = 0 #Declaramos el valor de la variable "i"
while (i <= 9): #Creamos el bucle con la condición de ejecutarse mientras "i"
              #sea menor o igual a "9"
    i +=1     #Cuerpo de la repetición = sumamos uno a i (i es igual a i mas uno)
    print (i) #Imprimimos "i"

Resultado:

1
2
3
4
5
6
7
8
9
10

Menú usando while infinito

Anteriormente en la entrada dedicada a las funciones internas y propias habíamos visto un ejemplo de una calculadora sencilla utilizando funciones donde precisamente usamos el bucle while. Lo recuerdas? Aquí está el código:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  calc.py
#  
#  Copyright https://pythones.net
#
############################################-1-##################################################

def sumar(): #Definimos la función sumar
    x = a + b
    print (("Resultado"), (x))
def restar():#Definimos la función restar
    x = a - b
    print (("Resultado"), (x))
def multiplicar():#Definimos la función multiplicar
    x = a * b
    print (("Resultado"), (x))
def dividir():#Definimos la función dividir
    x = a / b
    print (("Resultado"), (x))

##########################################-2-###################################################
while True: #Creamos un bucle
    try: #Intentamos obtener los datos de entrada
        a = int(input("Ingresa el primer numero: \n")) #Solicitamos el 1er numero al usuario
        b = int(input("Ingresa el segundo numero: \n"))#Solicitamos el 2do numero al usuario
        print (("Que calculo quieres realizar entre"), (a), ("y"), (b), ("?\n")) #Preguntamos el calc
        op = str(input(""" #Ofrecemos las opciones de calculo las cuales van a llamar a las funciones
        1- Sumar
        2- Restar
        3- Multiplicar
        4- Dividir \n"""))
    except: #En caso de error:
        print ("Error")
        op = '?'
##########################################-3-##################################################
    if op == '1':#Si el usuario elige opción 1 llamamos a sumar
        sumar()
        break
    elif op == '2':#Si el usuario elige opción 1 llamamos a restar
        restar()
        break
    elif op == '3':#Si el usuario elige opción 1 llamamos a multiplicar
        multiplicar()
        break
    elif op == '4':#Si el usuario elige opción 1 llamamos a dividir
        dividir()
        break
    else:
        print ("""Has ingresado un numero de opcion erroneo""") #En caso que el numero no
                                                                            #se encuentre

Presta especial atención al código resaltado de while, en este caso es un bucle infinito porque seguido del while colocamos un «True» por ende la condición siempre se cumplirá. Y lo hice así a propósito para que el usuario nunca pueda salir de este bucle, es decir, que el programa nunca finaliza hasta que el usuario ingrese los números y elija una opción para obtener un resultado correcto.

Veamos cómo crear un menú sencillo utilizando la repetición infinita (While True) en este caso para obligarlo al usuario a elegir una opción, si no lo hace se lo volverá a solicitar:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  bucles.py
#  
#  Copyright https://pythones.net
#
############################################-1-##################################################

while True: #Creamos el ciclo infinito
    opcion = (input("""Elige una fruta para tu desayuno: 
    1- Manzanas
    2- Bananas
    3- Nada
    """))#Creamos un input para
        #que el usuario ingrese su opción y la almacenamos en "opcion"
        
############################################-2-##################################################       
    if opcion == '1': #Condicionales según la opción que eligió!
        print ("Has seleccionado manzanas")
    elif opcion == '2':
        print ("Has seleccionado bananas")
    elif opcion == '3':
        print ("Has seleccionado nada")
    else:
        print ("Debes seleccionar una opcion (1, 2 o 3)")

En la parte 1 de este código puedes ver que creamos el ciclo infinito y luego debajo, en el cuerpo del mismo colocamos un input para mostrarle al usuario las opciones y permitirle elegir una para almacenarla en la variable «Opcion».

En la parte 2 de nuestro código continuamos dentro del cuerpo pero agregando condicionales para que dependiendo la opción que el usuario elija suceda una cosa u otra.

Si prestas atención vas a ver que las lineas siguientes al while están todas identadas por lo tanto están dentro del ciclo infinito.

Y esto hace que una vez que el usuario elige una opción siga quedando estancado dentro de este bucle.. Y se le vuelve a preguntar lo mismo… ¿Cómo solucionamos esto? Vamos a eso chango!!

Control de bucles, break, continue y pass en python

A veces podemos no querer que un bucle se continué repitiendo infinitamente cuando ya ha cumplido su función, para esto existe el control de bucles mediante estas tres instrucciones!

Break

Esta instrucción se utiliza para finalizar un bucle, es decir, salir de el y continuar con la ejecución del resto de instrucciones del programa. Justamente esta es la instrucción que estamos necesitando para resolver el problema de nuestro menú:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#  bucles.py
#  
#  Copyright https://pythones.net
#
############################################-1-##################################################

while True: #Creamos el ciclo infinito
    opcion = (input("""Elige una fruta para tu desayuno: 
    1- Manzanas
    2- Bananas
    3- Nada
    """))#Creamos un input para
        #que el usuario ingrese su opción y la almacenamos en "opcion"
        
############################################-2-##################################################       
    if opcion == '1': #Condicionales según la opción que eligió!
        print ("Has seleccionado manzanas")
        break #Rompemos el bucle
    elif opcion == '2':
        print ("Has seleccionado bananas")
        break #Rompemos el bucle
    elif opcion == '3':
        print ("Has seleccionado nada")
        break #Rompemos el bucle
    else:
        print ("Debes seleccionar una opcion (1, 2 o 3)")

print("Programa terminado, que disfrutes tu desayuno") #Agregamos un print FUERA DEL BUCLE dar fin

El break lo colocamos al final del bloque que queremos que de la salida, en este caso luego de que el usuario elija la cualquiera de las opciones. Pero no colocamos un break en el else porque de esa forma si el usuario eligiera un numero de opción inexistente volvería a comenzar el bucle. «El usuario solo podrá salir de la repetición eligiendo la opción correcta»

Continue

La instrucción continue dentro de un bucle obliga al interprete a volver al inicio del bucle obviando todas las instrucciones o iteraciones debajo de el.

Si en vez de colocar un break, colocáramos en su lugar un continue, al seleccionar una opción nos devolvería al inicio, volviéndonos a preguntar. Haz la prueba 😉

Pass

La instrucción Pass es como lo indica su nombre una expresión nula, no hace nada.. Es casi como si no existiera, pero nos permite crear un bucle sin colocar código en su cuerpo para añadirlo mas tarde utilizándolo como un relleno temporal.

La diferencia con continue es que este termina la iteracion actual pero continua con la siguiente instrucción o iteracion del bucle, volviendo al inicio. En cambio pass no hace nada y continua con las siguientes instrucciones de este sin volver al inicio.

Diferencias entre For y While en python

Destacamos las diferencias en el uso de bucles en python:

El bucle For podría traducirse como «para» y el While como «mientras». En el caso de for no nos permite realizar un ciclo infinito. A diferencia de while que si nos brinda esa posibilidad, a la vez que desde el comienzo no están declaradas al cantidad de iteraciones a realizar.

Esto ha sido todo sobre los bucles espero lo hallas comprendido al 100% y sino vuelve al inicio 8) Cualquier duda puedes dejar un comentario! Gracias por visitar mi blog y no olvides suscribirte!! Nos vemos a la siguiente!!