Tutorial sobre bucles en Python

Bucle «for»

Puedes abordar el bucle «Bucle for» de la misma manera que el bucle «while». Como probablemente habrás imaginado, el componente «for» en «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» de la siguiente manera:

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

A diferencia del bucle while, no hay ninguna condición activa: simplemente ejecutas un fragmento de código repetidamente un número determinado de veces. En otras palabras, mientras que el bucle while sigue ejecutando el bloque de código que contiene solo hasta que la condición es e True e, el bucle for ejecuta el código que contiene solo un número específico de veces. Este «número de veces» viene determinado por una secuencia o una lista ordenada de elementos.

En breve aprenderás más sobre la diferencia entre los bucles while y for, pero por ahora concéntrate en los siguientes elementos 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 integrada en la biblioteca de Python para crear una secuencia de números.
• El código que deseas ejecutar repetidamente

Bucle «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 un bucle «for» en Python: la palabra clave for, la variable number, la palabra clave in, la función range() y el código que deseas ejecutar varias veces, print("Thank you").

No es tan difícil, ¿verdad?

Veamos otro ejemplo de un bucle «for», en el que utilizas dos variables para definir el 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, el bucle comienza con la palabra clave for. A continuación, utilizas las variables index y languages, la palabra clave in y la función range() para crear una secuencia de números. Además, verás 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 deseas ejecutar repetidamente es una instrucción de impresión, es decir, print('Current language :', languages[index]).

En el bucle anterior, quieres expresar que, para cada índice del rango len(languages), deseas imprimir el lenguaje de programación de ciencia de datos. Ahora, 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 te da una vez más el mismo resultado!

While frente a bucle for en Python

Revisemos una vez más el primer ejemplo de bucle while para determinar cuáles son exactamente las diferencias entre los bucles while y bucle for. Ya has leído anteriormente que la diferencia radica en la condición que está o no está involucrada, pero ¿cómo se refleja esto en el código y cómo puedes 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 frase «Gracias» de una 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?, te preguntarás. Bueno, es sencillo.

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

Ten en cuenta que el recuento de la función range() comienza desde 0 y no desde 1. Esto significa que, en el ejemplo anterior, el recuento debería ser 0,1,2 y no 1,2,3. Así es como funciona el recuento numérico en la memoria de un ordenador. Por lo tanto, al diseñar un bucle «for», ten siempre en cuenta que debes considerar el recuento del rango desde 0 y no desde 1.

Consejo: esto es igual para las listas en Python, por ejemplo. Si deseas obtener más información sobre las listas de Python, te recomendamos que consultes el tutorial «Las 18 preguntas más frecuentes sobre listas de Python» de DataCamp.

Ahora bien, hay otra diferencia interesante entre un bucle «Bucle for» y un bucle «while». Un bucle «for» es más rápido que un bucle «while». Para entenderlo, hay que fijarse en el ejemplo siguiente.

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 fragmento de código anterior, tienes dos bucles con alrededor de 10 000 iteraciones. A primera vista, ambos parecen iguales, hasta que miras detrás de las cámaras y comprendes cómo funcionan estos dos bucles. Pista: ¡la función timeit() te da una pista sobre cuál podría 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 primero se descompone en códigos de bytes y luego es procesado por el compilador C subyacente.

Cuando comienza la ejecución del bucle «for» en el ejemplo anterior, el intérprete de Python se comunica con el compilador C subyacente y, a continuación, crea un objeto de lista de tamaño 10 000. A continuación, llama a un iterador para tocar el índice de cada uno de los 10 000 elementos de la lista.

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

Ya te puedes imaginar que iterar sobre un objeto de lista ya creado con 10 000 elementos es más fácil para el compilador que realizar una operación booleana repetidamente 9999 veces, por lo que el rendimiento temporal de un bucle «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 rango de 0 a 11, ya que deseas mostrar solo los números de la secuencia hasta el 55, que es el undécimo número 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 condiciones adicionales en tu código.

¡Espera!

Esta no es la única forma en que puedes personalizar tu bucle. También puedes incluir más bucles while dentro de tu código existente, lo que se conoce como bucle anidado. Puedes modificar el ejemplo anterior para incluir otro bucle while como se muestra a continuación:

# 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 realiza otra comprobación para ver si el valor de number % (mod) 2 es 0.

En otras palabras, comprueba si el número es par y, a continuación, imprime la frase «El número es par».

Pero hay un problema: si observas con atención, verás que, al igual que en el código anterior, esta vez falta la instrucción « number=number+1 ». Dado que no incrementas la variable number en ningún sitio, el valor de la variable permanece igual cada vez y el código entra en un bucle infinito. Esto significa que, una vez que entra en el bucle, nunca sale de él e imprime la instrucción un número infinito de veces, ya que la variable number siempre se establecerá en 2. Este número es, por supuesto, menor que 5 y 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 «Bucle for» dentro del bucle externo.

Adelante, ejecuta el código.

Verás que el control entra en el primer bucle «for» y que el valor de la variable number se inicializa como 0. Se imprime la primera instrucción print y, a continuación, el control entra en el segundo bucle for, donde el valor de la variable another_number se inicializa en 0. La primera instrucción de impresión 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 con el siguiente entero, seguido de la impresión de la instrucción dentro de la función print().

El proceso mencionado anteriormente continúa hasta que el control ha recorrido el final de la función range(), que en este caso es 5, y luego el control vuelve al bucle más externo, inicializa la variable number con el siguiente entero, imprime la instrucción dentro de la función print(), visita el bucle interno y luego repite todos los pasos anteriores hasta que se recorre la función range().

Este recorrido del control, que va desde el bucle más externo, atraviesa el bucle interno y luego vuelve al bucle for, continúa hasta que el control ha cubierto todo el rango, que en tu caso es 3 veces.

Ahora que has leído algunas explicaciones sobre los bucles anidados, ¡es hora de que empieces por ti mismo! Escribe un programa en Python para construir el siguiente patrón, utilizando un bucle for anidado:

break y continue Palabras clave: Creación de 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 precaución. Ambas palabras clave dificultan que otros —incluido tú mismo dentro de unos meses, cuando revises tu código— comprendan el flujo de control en el bucle y dónde termina la condición. Además, no es necesario utilizar las palabras clave break y continue: como has podido comprobar hasta ahora, ¡te ha ido perfectamente bien sin ellas!

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

Interrumpir 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é brujería es esta!», 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 debe salir del bucle (en este caso, el bucle interno) y ejecuta la siguiente línea de código. Por lo tanto, sale del bucle while interno y pasa al bucle externo, donde continúa realizando sus tareas habituales hasta que la condición del bucle while externo se cumple.

Debes tener en cuenta que debe existir una línea de código después de la palabra clave break, ya que, 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, a continuación, ejecuta el código.

¿Qué pasaría si introdujeras la palabra clave continue después de la instrucción break? Puedes seguir el código siguiente:

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.

Al ejecutar el código anterior, volverás a encontrarte con un bucle infinito. Antes de empezar a tirarte de los pelos por la frustración, fíjate bien. Notarás que hay una palabra clave continue después del salto. Lo que hace la palabra clave continue es transferir el control al bucle más externo incluso antes de que se incremente la variable number, y debido a esto, el código entra en un bucle infinito.

Interrumpir y continuar bucles «Bucle for»

¿Qué pasaría si no quisieras ejecutar el bucle for interno del ejemplo anterior para todo el rango? Puedes utilizar una instrucción 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 ejemplo de código:

# 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, solo se ejecuta el bucle más externo y el control ni siquiera toca el bucle interno.

«¿Por qué?», te preguntarás.

Echa un vistazo más de cerca al código. Hay una palabra clave continue justo después de la segunda instrucción «print» en el bucle más externo. Lo que hace es indicar al control que vuelva al Bucle for externo y comience de nuevo, y por eso el control nunca llega al bucle interno.

A diferencia del bucle «while», en el bucle «for» no es necesario incluir código después de la palabra clave break. Un bucle break por sí solo funcionará perfectamente dentro de un bucle for.

range() versus xrange()

Estas dos funciones son similares entre sí, pero si utilizas Python 3, solo 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 un error NameError: name 'xrange' is not defined.

Para comprender en qué se parecen estas dos funciones, consideremos 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 omite por un factor de 2, y eso se debe 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 desde el cual el control comienza a contar. El segundo parámetro es el parámetro de parada, que es el punto en el que el control debe detenerse, y el último parámetro es la función de paso, que define el factor por el que el control debe saltar mientras cuenta.

Por lo tanto, en el caso anterior, el control comienza en 5 y recorre el bucle hasta 9, sumando 2 en cada recuento. 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 debe repetirse. Ahora, en Python 2.x, también encontrarás otra forma de hacerlo, y es con la función xrange(). Ejecuta el siguiente código:

# 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 observaste entre el resultado del código anterior y el resultado del código sin la función xrange()? ¿No hay diferencia?

Así es. No verás ninguna diferencia en el resultado del código.

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

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

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

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

Ahora bien, esta es precisamente 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 todo el rango y se te muestra. Sin embargo, cuando defines la función xrange(), no se almacena ninguna lista en la memoria. En su lugar, la función xrange() genera números enteros en todo el rango cuando lo necesitas. De esta manera, la función xrange() ayuda a conservar memoria en sistemas con recursos limitados.

¡Perfecciona tus habilidades con Python!

Enhorabuena, has llegado al final de este tutorial. Ahora que ya has aprendido a utilizar los bucles en Python, ponte manos a la obra y practica. ¡Cuanto más practiques, mejor!