Tutorial de bucles en Python

Bucle Forzado

Puedes abordar el bucle for del mismo modo que el bucle while. Como probablemente habrías esperado, el componente "for" de "bucle for" se refiere a algo que haces un determinado número de veces.

Si tienes en cuenta todo lo anterior, puedes definir fácilmente el bucle for como sigue:

Un bucle for es un concepto de programación que, cuando se implementa, ejecuta un fragmento de código una y otra vez "para" un determinado número de veces, basándose en una secuencia.

A diferencia del bucle while, no interviene activamente ninguna condición: sólo ejecutas un fragmento de código repetidamente durante un número de veces. En otras palabras, mientras que el bucle while sigue ejecutando el bloque de código que contiene sólo hasta que la condición es True, el bucle for ejecuta el código que contiene sólo durante un número determinado de veces. Este "número de veces" viene determinado por una secuencia o lista ordenada de cosas.

Dentro de un rato aprenderás más sobre la diferencia entre los bucles while y for, pero por ahora concéntrate en las siguientes piezas que necesitas para crear un bucle for:

• La palabra clave for
• Una variable
• La palabra clave in
• La función range(), que es una función incorporada en la biblioteca de Python para crear una secuencia de números
• El código que quieres ejecutar repetidamente

Bucles For en Python

# Print "Thank you" 5 times
for number in range(5):
    print("Thank you")

Thank you
Thank you
Thank you
Thank you
Thank you

Como puedes ver, los componentes que has visto en la sección anterior vuelven a aparecer en este pequeño ejemplo de bucle for en Python: la palabra clave for, la variable number, la palabra clave in, la función range() y el código que quieres ejecutar varias veces, print("Thank you").

No es tan difícil, ¿verdad?

Consideremos otro ejemplo de bucle for, en el que utilizas dos variables para definir tu flujo de control:

languages = ['R', 'Python',  'Scala', 'Java', 'Julia']

for index in range(len(languages)):
   print('Current language:', languages[index])

Current language: R
Current language: Python
Current language: Scala
Current language: Java
Current language: Julia

Como puedes ver, inicias el bucle con la palabra clave for. A continuación, utiliza las variables index y languages, la palabra clave in y la función range() para crear una secuencia de números. Además, ves que en este caso también utilizas la función len(), ya que la lista languages no es numérica. El fragmento de código que quieres ejecutar repetidamente es una sentencia print, es decir, print('Current language :', languages[index]).

En el bucle anterior, quieres expresar que por cada índice del rango len(languages), quieres imprimir el lenguaje de programación de la ciencia de datos. Ahora bien, len(languages) es 5, por lo que la afirmación también podría reescribirse como:

for index in range(5):
    print('Current language:', languages[index])

Current language: R
Current language: Python
Current language: Scala
Current language: Java
Current language: Julia

Y esto, una vez más, ¡te da el mismo resultado!

Bucles While frente a For en Python

Volvamos una vez más al primer ejemplo de bucle while para determinar cuáles son exactamente las diferencias entre los bucles while y for. Ya has leído más arriba que la diferencia radica en la condición que interviene o no, pero ¿cómo se refleja esto en el código y cómo puedes tal vez cambiar entre las dos?

# Take user input
number = 2  

while number < 5 :
    print("Thank you")
    # Increment `number` by 1
    number = number+1

Thank you
Thank you
Thank you

Puedes utilizar el bucle for para imprimir la declaración "Gracias" de forma más controlada:

# Print "Thank you" 3 times
for number in range(3) :  
    print("Thank you")

Thank you
Thank you
Thank you

¿Ves lo fácil que ha sido convertir el bucle while en un bucle for equivalente?

¿Cómo funciona? Pues es muy sencillo.

En un bucle for, el número entero mencionado dentro de la función rango es el rango o el número de veces que el control necesita hacer un bucle y ejecutar el código de la cláusula del bucle for.

Ten en cuenta que la cuenta de la función range() empieza en 0 y no en 1. Eso significa que, en el ejemplo anterior, la cuenta debería ser como 0,1,2 y no 1,2,3. Así funciona el recuento de números en la memoria de un ordenador. Por tanto, al diseñar un bucle for, ten siempre en cuenta que tienes que considerar la cuenta de rango desde 0 y no desde 1.

Consejo: esto es lo mismo que ocurre con las listas en Python, por ejemplo. Si quieres saber más sobre las listas en Python, échale un vistazo al tutorial 18 preguntas más frecuentes sobre listas en Python de DataCamp.

Ahora bien, hay otra diferencia interesante entre un bucle for y un bucle while. Un bucle for es más rápido que un bucle while. Para entenderlo, tienes que ver el siguiente ejemplo.

import timeit

# A for loop example
def for_loop():
    for number in range(10000) :  
        # Execute the below code 10000 times
        sum = 3+4
        #print(sum)

timeit.timeit(for_loop)

267.0804728891719

import timeit

# A while loop example
def while_loop():
    i =0
    while i<10000:
        sum = 3+4
        #print(sum)
        i+=1

timeit.timeit(while_loop)

884.9233417965908

En el trozo de código anterior, tienes dos bucles con unas 10000 iteraciones. Ambos parecen iguales a primera vista, hasta que miras entre bastidores y comprendes cómo funcionan estos dos bucles. Pista: ¡la función timeit() te da una pista de cuál puede ser la diferencia!

Recuerda: todo el código Python se compila con un compilador C, lo que significa que el código que ves arriba se descompone primero en códigos de bytes y luego lo procesa el compilador C subyacente.

Cuando comienza la ejecución del bucle for del ejemplo anterior, el intérprete de Python habla con el compilador de C subyacente y crea un objeto lista de tamaño 10000. A continuación, llama a un iterador para que toque el índice de cada uno de los 10000 elementos de la lista.

En cambio, la ejecución del bucle while no crea ningún objeto lista. De hecho, el compilador C subyacente llama al operador booleano de comparación para la condición i<10000 9999 veces.

Ya te puedes imaginar que iterar sobre un objeto lista ya creado con 10000 elementos es más fácil para el compilador que realizar una operación booleana repetidamente durante 9999 veces, el rendimiento temporal de un bucle for es mejor que el de un bucle while. Esto se refleja claramente en el tiempo de ejecución: el tiempo que tarda en completarse el bucle for es mucho menor que el tiempo que necesita el bucle while para completarse.

¡Ahora prueba el bucle for! Ten en cuenta que debes especificar el intervalo de 0 a 11, ya que sólo quieres mostrar los números de la secuencia hasta el 55, que es el número 11 de la secuencia.

Bucles anidados

Como puedes observar en el ejemplo anterior, hay una condición if-else dentro del bucle while que te permite introducir más condiciones en tu código.

¡Aguanta!

Ésta no es la única forma en que puedes personalizar tu bucle. También puedes incluir algún bucle while más dentro de tu código existente y esto se conoce como bucle anidado. Puedes modificar el ejemplo anterior para incluir otro bucle while como el siguiente:

# Take user input
number = 2 

# condition of the while loop
while number < 5 :  
    # condition of the nested while loop    
    while number % 2 == 0: 
        print("The number "+ str(number)+" is even")

En el ejemplo anterior hay otro bucle while que está "anidado" dentro del bucle exterior, este bucle interior pone otra comprobación para ver si el number % (mod) 2 es 0.

En otras palabras, comprueba si el número es par e imprime la afirmación "El número es par".

Pero hay un truco: si te fijas bien, puedes ver que, al igual que en el código anterior, esta vez falta la declaración number=number+1. Como no estás incrementando el número de la variable en ningún sitio, el valor de la variable sigue siendo el mismo cada vez y el código entra en un bucle infinito. Eso significa que, una vez que entra en el bucle, nunca sale e imprime la declaración un número infinito de veces porque la variable number siempre se pondrá a 2. Este número es, por supuesto, menor que 5 y un número par.

Veamos ahora cómo sería un bucle for anidado:

# Print the below statement 3 times
for number in range(3) :  
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    # Inner loop
    for another_number in range(5):  
        print("****************************")
        print("I am inner loop iteration "+str(another_number))

-------------------------------------------
I am outer loop iteration 0
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4
-------------------------------------------
I am outer loop iteration 1
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4
-------------------------------------------
I am outer loop iteration 2
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4

El código anterior es una versión modificada del primer ejemplo de bucle for. Observa cómo se utiliza un segundo bucle for dentro del bucle exterior.

Sigue adelante y ejecuta el código.

Verás que el control entra en el primer bucle for y el valor de la variable number se inicializa como 0. Se imprime la primera sentencia print, y luego el control entra en el segundo bucle for, donde el valor de la variable another_number se inicializa a 0. La primera sentencia print del segundo bucle for se imprime una vez.

Ahora, el control vuelve al bucle for interno una vez más y el valor de another_number se inicializa de nuevo al siguiente número entero, seguido de la impresión de la declaración dentro de la función print().

El proceso anterior continúa hasta que el control ha atravesado el final de la función range(), que en este caso es 5, y entonces el control vuelve al bucle exterior, inicializa la variable number con el siguiente número entero, imprime la sentencia dentro de la función print(), visita el bucle interior y repite todos los pasos anteriores hasta atravesar la función range().

Este viaje del control desde el bucle exterior, pasando por el bucle interior y volviendo al bucle for exterior continúa hasta que el control ha recorrido todo el rango, que en tu caso es 3 veces.

Ahora que ya has leído algunas explicaciones sobre los bucles anidados, ¡es hora de que empieces tú también! Escribe un programaaltPythonalt para construir el siguiente patrón, utilizando un bucle for anidado:

break y continue Keywords: Crear bucles infinitos

Puedes utilizar break y continue en cualquier bucle que crees. Estas palabras clave no se limitan a romper bucles infinitos intencionados, pero deben utilizarse con cuidado. Ambas palabras clave hacen que sea más difícil para los demás -incluido tú mismo dentro de un par de meses cuando vuelvas a mirar tu código- comprender el flujo de control en el bucle y dónde termina la condición. Además, no necesitas utilizar las palabras clave break y continue: como has visto hasta ahora, ¡lo hacías perfectamente sin ellas!

Sin embargo, en algunos casos, puede ser más claro escribir bucles infinitos intencionados en lugar de los tradicionales bucles for y while que has visto hasta ahora. Por supuesto, ¡en esos casos se fomenta el uso de estas palabras clave!

Romper y continuar bucles While en Python

Afortunadamente, hay una forma de salir de la situación anterior de bucle infinito y es utilizando la palabra clave break.

# Take user input
number = 2 

# Condition of the while loop
while number < 5 :  
    # condition of the nested while loop
    while number % 2 == 0:  
        print("The number "+str(number)+" is even")
        break

    number+=1

Cuando ejecutas el código anterior ya no entra en un bucle infinito.

"¡Qué es esta brujería!", gritas. - Yo te digo que te relajes, que no es brujería.

Lo que ocurre es que cuando el control encuentra la palabra clave break entiende que tiene que salir del bucle (bucle interno en este caso) y ejecuta la siguiente línea de código. Por lo tanto, sale del bucle while interno y pasa al bucle externo y sigue haciendo lo de siempre hasta que se cumpla la condición del bucle while externo.

Debes tener en cuenta que debe existir una línea de código después de la palabra clave break o, de lo contrario, no tendrá ningún efecto. Intenta eliminar la línea de código después de la palabra clave break en el ejemplo anterior y luego ejecuta el código.

¿Y si introduces a hurtadillas la palabra clave continue después de la declaración break? Puedes seguir el código que aparece a continuación:

# Take user input
number = 2 

while number < 5 :
    while number % 2 == 0: 
        print("The number "+str(number)+" is even")
        break

    continue

    number+=1

El código anterior es una versión ligeramente modificada del ejemplo de la palabra clave break.

Cuando ejecutes el código anterior, volverás a encontrarte con un bucle infinito. Antes de que empieces a tirarte de los pelos por la frustración, míralo más de cerca. Verás que hay una palabra clave continue después de la pausa. Lo que hace la palabra clave continue es que transfiere el control de nuevo al bucle más externo incluso antes de que se incremente la variable number y por eso el código entra en un bucle infinito.

Romper y continuar bucles For

¿Y si no quisieras ejecutar el bucle for interno del ejemplo anterior para todo el rango? Puedes utilizar una sentencia break de forma similar a como lo has hecho en el caso del bucle while.

# Print the below statement 3 times
for number in range(3) : 
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    for another_number in range(3):
        print("****************************")
        print("I am inner loop iteration "+str(another_number))
        break

En el ejemplo anterior, la palabra clave break después del bucle interno indica al control que salga del bucle interno, tras lo cual el control vuelve al bucle externo.

Ejecuta el siguiente código de ejemplo:

# Print the below statement 3 times
for number in range(3) :  
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    continue
    for another_number in range(3):
        print("****************************")
        print("I am inner loop iteration "+str(another_number))
        break

En el código anterior sólo se ejecuta el bucle exterior y el control ni siquiera toca el bucle interior.

"¿Por qué?", preguntas.

Echa un vistazo más de cerca al código. Hay una palabra clave continue justo después de la segunda sentencia print en el bucle exterior. Lo que hace es que indica al control que salte de nuevo al bucle for exterior y empiece de nuevo y por eso el control nunca toca el bucle interior.

A diferencia del bucle while, no necesitas un trozo de código después de la palabra clave break en el bucle for. Un bucle break solo funcionará bien dentro de un bucle for.

range() frente a xrange()

Estas dos funciones son similares entre sí, pero si utilizas Python 3, sólo tendrás disponible la función range(). En Python 3.x, la función xrange() pasa a llamarse range(). Esto significa que si intentas utilizar la función xrange() con Python 3, obtendrás el error NameError: name 'xrange' is not defined.

Para entender en qué se parecen estas dos funciones, considera el siguiente ejemplo:

# Print the below statement 3 times
for number in range(5,10,2) :  
    print("I am number : "+str(number))

I am number : 5
I am number : 7
I am number : 9

Al ejecutar el código anterior, verás cómo el valor de la variable number se salta por un factor de 2, y eso es debido a los parámetros de la función range().

El primer parámetro de esta función es el parámetro de inicio. Ese es el punto a partir del cual el control empieza a contar. El segundo parámetro es el parámetro de parada, que es el punto en el que debe detenerse el control, y el último parámetro es la función de paso, que define el factor por el que debe saltar el control mientras cuenta.

Así, en el caso anterior, el control empieza en 5 y luego recorre el bucle hasta 9, añadiendo 2 en cada cuenta. Esto significa 5, 5+2=7, 7+2=9.

Has aprendido cómo se utiliza la función range() para definir el número de veces que tu código tiene que hacer un bucle. Ahora, en Python 2.x, también encontrarás otra forma de hacerlo y es con la función xrange(). Ejecuta el código siguiente:

# Print the below statement 3 times
for number in xrange(10) :  
    print("I am number : "+str(number))

I am number : 0
I am number : 1
I am number : 2
I am number : 3
I am number : 4
I am number : 5
I am number : 6
I am number : 7
I am number : 8
I am number : 9

¿Qué diferencia has visto en la salida del código anterior frente a la salida del código sin la función xrange()? ¿No hay diferencia?

Así es. No verás ninguna diferencia en la salida del código.

Entonces, ¿por qué deberías utilizar la función xrange()? Llegarás a esto un poco más adelante en el tutorial. Primero ejecuta el código siguiente:

print(xrange(10))
print(range(10))

xrange(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Puedes ver que en la salida del código anterior, hay una diferencia en la salida de ambas sentencias de impresión. En la sentencia print, que contiene la función xrange(), se imprime el objeto de la función xrange(). Esto es diferente en la sentencia print que tiene la función range(): allí, obtienes una lista de enteros del 0 al 9.

En esto consiste exactamente la diferencia entre la función range() y la función xrange().

Cuando defines la función range(), se almacena en la RAM una lista de toda la gama y se te presenta. Sin embargo, cuando defines la función xrange(), no se almacena una lista en la memoria. En su lugar, la función xrange() genera enteros en todo el rango cuando lo necesitas. De este modo, la función xrange() ayuda a conservar la memoria en sistemas con escasez de recursos.

Perfecciona tus habilidades con Python

Enhorabuena, has llegado al final de este tutorial. Ahora que has aprendido a utilizar bucles en Python, vete a practicar. Cuanto más practiques, ¡mejor!