Capítulo #18 - Condicionales y bucles con Python

Iniciación a las estructuras de control de flujo con Python

Las estructuras de control de flujo son imprescindibles en programación. Estas permiten tomar decisiones en torno a ciertas ocurrencias y automatizar tareas.

Espacio publicitario

¿Qué tipos de estructuras de control de flujo existen en Python?

En Python, existen cuatro estructuras de control de flujo principales:

• Condicional if-else
• Condicional match
• Bucle for
• Bucle while

Además, en programación solemos contar con el bucle do while, elemento que no tiene Python debido a que es una variante del propio bucle while. No obstante, te enseñaré a crearlo al estilo Python.

Estructuras de control de flujo se dice Control flow structures en inglés.

El flujo de ejecución

El intérprete de Python y los lenguajes de programación en general, funcionan con algo llamado “flujo de ejecución”, el cual, dictamina de qué forma se va a ejecutar el código. Es decir, el orden de ejecución.

Flujo de ejecución se dice execution flow en inglés.

Hasta ahora, todo el código que has probado en este curso, ha sido de flujo lineal o secuencial. Se han empezado a ejecutar las líneas una por una, desde la primera, hasta la última.

El flujo de ejecución normal en Python, va leyendo el código y ejecutándolo desde la primera línea hasta la última.

En cambio, mediante las estructuras de control de flujo, podemos aplicar un orden diferente. Es decir, podemos controlar el flujo de ejecución.

Espacio publicitario

Bloques de código

Las estructuras de control de flujo, como los condicionales o los bucles, siempre llevan consigo uno o varios bloques de código. Estos bloques de código son conjuntos de instrucciones que se ejecutan basándose en ciertas normas establecidas. Es decir, se ejecutan de forma controlada.

Las estructuras de control de flujo permiten determinar cuándo se ejecutará un bloque de código asociado a ellas. En algunos casos, el bloque se ejecutará siempre, en otros no se ejecutará nunca, o se ejecutará un número x de veces. Todo esto dependerá de expresiones booleanas.

Con esta información, puedes llegar a la conclusión de que tus programas se volverán dinámicos y tendrán una capacidad de cambiar ante ciertas situaciones. En otras palabras, no van a ser programas que siempre hagan lo mismo.

Condicionales y bucles en programación

Los condicionales son estructuras de control de flujo que permiten tomar decisiones en función del valor de una expresión booleana.

Con los condicionales, podemos tener desde un solo bloque de código hasta tantos como necesitemos. Sin embargo, en una misma ejecución, puede que no se ejecute ningún bloque o, como máximo, se ejecute uno. El que se ejecute un bloque de código o no, dependerá de lo que evalúe cierta expresión booleana asociada al bloque.

Por otro lado, los bucles son estructuras de control de flujo que permiten repetir un bloque de código varias veces. También bajo cierta expresión booleana.

Debes tener en cuenta que los bucles pueden causar problemas de rendimiento por aplicar un mal diseño lógico. Ya verás lo fácil que es dejar colgado (sin responder) un programa, si te equivocas con el diseño de un bucle.

Espacio publicitario

La indentación del código

En Python la indentación es una parte muy importante del código. A diferencia de otros lenguajes de programación como Java, que utilizan llaves para delimitar bloques de código, Python utiliza la indentación para determinar la estructura del mismo.

En este curso, voy a utilizar el término “indentación” para referirme a las sangrías o tabulaciones del código.

El término “indentar” es un anglicismo que proviene de indentation. El término español para referirse a “indentar”, es “sangrar” (acción de aplicar sangría) o “tabular” (aplicar un margen con la tecla tabulador TAB ).

Sin embargo, he decidido utilizar el anglicismo en este curso, debido a lo fuertemente extendido que está. Así, cuando leas otras ayudas y enseñanzas de Python en español, sabrás de qué se está hablando.

La indentación se utiliza para crear bloques de código en Python. Son como las llaves de otros lenguajes de programación.

Una indentación es una tabulación. Pulsas una vez la tecla TAB del teclado, y haces una indentación en el código Python.

Para que lo veas de forma fácil, te voy a poner dos ejemplos. Primero, un ejemplo de un bloque if escrito en el lenguaje de programación Java, el cual utiliza llaves para delimitar los bloques de código. Y luego otro en Python, que utiliza las indentaciones para este propósito.

Ejemplo de bloque de código en Java :

int x = 5;
                      
if (x > 0) {
    System.out.println("x es positivo");
}

Ejemplo de bloque de código en Python :

x = 5

if x > 0:
    print("x es positivo")

El código es equivalente en ambos lenguajes de programación, simplemente cambia la forma de escritura.

En lenguajes como Java, las indentaciones se utilizan para ordenar y hacer el código más legible, pero no son obligatorias para el correcto funcionamiento del programa. En Java, el bloque de código debe estar delimitado por llaves ({ }), una que abre el bloque de código y otra que lo cierra. Sin embargo, en Python, las indentaciones son obligatorias, ya que definen la estructura del código. Sin una correcta indentación, el código Python no funcionará y generará errores por mala indentación.

Vamos a usar las indentaciones en Python, pero donde no se permiten, fuera de algún bloque de código. Aquí tienes un ejemplo:

numero = 10
 resultado = numero * 2
 print(resultado)

Las flechas del código representan una tabulación.

IndentationError: unexpected indent.
Error de indentación: indentación inesperada.

En este ejemplo, no hay ninguna estructura de Python, tan solo unas variables y un print(). El error ocurre por aplicar una indentación en la variable resultado y otra en el print().

Si estamos escribiendo instrucciones fuera de un bloque de código, no se nos permite añadirle la indentación, pero si está dentro, hay que ponerla.

Espacio publicitario

En el siguiente ejemplo, puedes ver un error por indentación inexistente con un condicional if:

x = 5

if x > 0:
print("x es positivo")

IndentationError: expected an indented block after 'if' statement on line X
Error de indentación: se esperaba un bloque indentado después de la declaración 'if' en la línea
X (línea donde se encuentra el error)

El error se produce exactamente en la línea 4, por tener el contenido del if sin indentar.

En cambio, en Java, hacer esto no supone ningún problema a la hora de ejecutar los programas, más allá de la legibilidad del código por parte de las personas:

Código Java

int x = 5;
if (x > 0) {System.out.println("x es positivo");}

Ahora te planteo la siguiente pregunta: ¿Cómo lees más claramente el código? ¿Con indentaciones o sin ellas? ¿Con un salto de línea separando la declaración del if del bloque de código, o sin él?

Creo que estarás de acuerdo conmigo, si te digo que con las indentaciones y saltos de línea se ve todo más claro:

x = 5
if x > 0:
    print("x es positivo")

Pues bien, en programación a nivel general siempre se coloca todo el código siguiendo unas convenciones, para que quede todo más organizado y fácil de leer (principalmente, saltos de línea y tabulaciones). De modo que en el lenguaje de programación Python, como buena práctica, se establecieron como obligatorias. Así, se nos fuerza a aprender a escribir código limpio desde el principio.

Veamos otro ejemplo más. Un bucle for, el cual también tiene su propio bloque de código:

for i in range(1, 11):
    print(i)

Debes fijarte muy bien, que en Python cuando viene un bloque de código siempre tenemos antes dos puntos (:). Con esto sabemos que lo que hay que escribir a continuación son líneas de código indentado, que pertenecen a la propia estructura declarada.

También, ¿cómo sabe el intérprete de Python cuándo terminamos de escribir código dentro de un bloque, y seguimos añadiendo más código fuera de él? Nuevamente, por las indentaciones. A continuación tienes un ejemplo:

a = 3

if a == 10:
    print("Se ejecuta el código del if.")
    print("Esto también es código del bloque if")

print("Este print está fuera del if.")

Los dos primeros print(), están formando parte del código del bloque if. Están ambos indentados. Por otro lado, el tercer print() está fuera del bloque, puesto que este no está indentado.

Así pues, de esta forma, el intérprete de Python puede identificar lo que está dentro y fuera de un bloque de código.

Si recibes un error de tipo IndentationError, es que debes revisar las indentaciones, ya que alguna tienes mal.

En un ejemplo anterior, has podido ver que el intérprete de Python indica incluso qué bloque está mal indentado y en qué línea se encuentra. Con estas ayudas, se facilita mucho la resolución de errores de este tipo.

Espacio publicitario

Instrucciones

Si has programado en otros lenguajes de programación, habrás caído en la cuenta de que en Python no usamos ningún tipo de cierre tras cada instrucción. Al menos, de forma obligatoria.

Recuerda que una instrucción en programación es una línea de código que realiza una acción específica o ejecuta una tarea determinada. Por ejemplo, una línea con un print() representa una instrucción.

La palabra instrucciones, se dice en inglés instructions.

Por ejemplo, en Java para imprimir un mensaje en la consola, como por ejemplo un "¡Hola, mundo!", necesitamos finalizar la línea (instrucción) con un punto y coma. En este lenguaje de programación es completamente obligatorio, pero no lo es en Python.

Mira este ejemplo de instrucción escrita en Java :

System.out.println("¡Hola Mundo!");
                    

En Python, podríamos hacer esto (es el equivalente):

print("¡Hola Mundo!");

Pero como he indicado al principio del curso, en Python no se suele utilizar nunca el punto y coma, y se dejaría así:

print("¡Hola Mundo!")

Entonces, ¿cómo sabe el intérprete de Python cuando finaliza una instrucción? Lo sabe, cuando no encuentra ningún carácter más en la línea, en la que está escrita, y cuando se ha hecho un salto de línea (tecla ENTER ), iniciando una nueva línea.

Carácter de continuación

Partiendo de lo que te acabo de explicar, el intérprete de Python sabe dónde termina cada instrucción gracias al salto de línea. Esto nos lleva a entender que, por este motivo, no podemos cortar una cadena larga en varias líneas utilizando la tecla ENTER en el código. A continuación tienes un ejemplo:

texto = "Este string
está cortado
en varias líneas"

SyntaxError: unterminated string literal (detected at line 1)
Error de sintaxis: literal de cadena sin terminar (detectado en la línea 1)

Python proporciona una solución para hacer esto, ya que quizás no quieras dejar líneas excesivamente largas. Además, por convención, tampoco deberías.

La solución consiste en poner varias cadenas con su apertura y cierre, y utilizar lo que se conoce como caracter de continuación (\). De este modo, las estaremos uniendo como una sola cadena.

El término carácter de continuación de línea, se dice en inglés line continuation character.

En este ejemplo, estoy solucionando el problema del código anterior:

texto = "Este string " \
"está cortado " \
"en varias líneas."

print(texto)

Este string está cortado en varias líneas.

Esto nos ha permitido cortar la cadena de caracteres en varias partes, sin errores al ejecutar. Después, mediante el caracter de continuación, las hemos podido relacionar. Esta acción es solo para organizar la escritura del código, no afecta a la salida del programa.

Espacio publicitario

El condicional if-elif-else

Ha llegado el momento de añadir algo de lógica a tus programas de Python, ya que por el momento, todo lo que hemos hecho ha sido muy básico, y bastante limitado (en cuanto a resultados). Con los condicionales, se abre un nuevo mundo.

La estructura if-elif-else, es una estructura de control de flujo de Python, que permite tomar decisiones basándose en una condición. Esta condición es una expresión booleana como las vistas en el capítulo anterior.

La declaración if

La primera parte que encontramos en la estructura, es if. Esta se declara con la palabra reservada if, y una condición o expresión, seguida de dos puntos. Finalmente, se crea un bloque de código, indentando una serie de instrucciones, las cuales, irán asociadas al if. Aquí tienes un ejemplo de sintaxis en pseudocódigo:

if condición o expresión:
    # bloque de código indentado

El pseudocódigo es una representación informal de un algoritmo que utiliza estructuras similares a las de un lenguaje de programación real, pero con una sintaxis entendible para personas, que no es aplicable a código ejecutable por un compilador o intérprete. Se utiliza para planificar y describir la lógica de un programa antes de ser implementado en un lenguaje de programación específico, o como he hecho yo en el ejemplo anterior, con ese condicional. Este no lleva código que ejecutar, es solo para que entiendas su sintaxis.

La expresión o condición del if se evaluará con un valor booleano. El resultado de tal expresión puede ser True o False. Si la condición es True, se ejecuta el bloque de código asociado al if. Si la condición es False, no se ejecuta. Se ignora por completo. En el caso de que haya más código antes o después de un condicional if, este se ejecutará con normalidad, independientemente de lo que ocurra con esta estructura.

Para que comprendas completamente el flujo de ejecución de las estructuras de control, crearé diagramas de flujo (representaciones gráficas) de cada una de ellas, que ilustren las operaciones realizadas.

Diagrama de flujo del condicional if

Este diagrama de flujo nos muestra un bloque de código bajo una condición (expresión) booleana. Si la condición evalúa como True, se ejecutan las instrucciones del bloque de código. En caso contrario, se ignoran.

Ejemplo práctico con if

Pongamos un ejemplo muy simple. Guardemos un número en una variable llamada edad. Esta servirá para almacenar una edad.

Dependiendo del número que tenga la variable, se cumplirá la condición del if, o no.

En el siguiente ejemplo, pongo un valor en edad, de 25, que hace que la expresión del if sea True:

# Se guarda una edad
edad = 25

# Evaluamos si es mayor de edad
if edad >= 18:
    print("Es mayor de edad.")

Es mayor de edad.

Con los condicionales no vemos si la expresión booleana devuelve un valor True o False, como lo hacíamos con las expresiones guardadas en variables. Esta decisión se toma internamente en el programa.

Ahora ya sabes por qué he dedicado un capítulo completo a las expresiones booleanas, para prepararte para este momento.

Con lo que ya sabes, puedes entender de qué forma funciona la ejecución de un condicional, sin tener que ver explícitamente el valor del resultado booleano.

En el ejemplo anterior, en la condición del if, se ha evaluado si el valor que tiene la variable edad es mayor o igual a 18. Así, el programa sabe calcular si alguien es mayor de edad o no. Funciona a base de lógica booleana. En el caso de que la variable edad tenga un valor mayor o igual a 18, la expresión del if, devuelve True, y se ejecuta su bloque de código.

Dicho bloque, esta vez, lo forma un solo print(), pero podrían ser muchas líneas de código. Las que necesitemos para hacer “cosas” concretas.

En el caso de que la variable edad no tenga un valor mayor o igual a 18, no se ejecutará nada del bloque de código del condicional if.

Si ejecutas el código con un valor menor, como puede ser 16, podrás comprobarlo (no sale nada en la consola):

# Se guarda una edad
edad = 16

# Evaluamos si es mayor de edad
if edad >= 18:
    print("Es mayor de edad.")

La variable edad tiene un valor de 16. En este caso, la condición edad >= 18, evalúa como False, ya que 16, no es mayor, ni es igual a 18. Por ello, el programa ignora la ejecución de este bloque de código if.

Quizás te preguntes, ¿por qué poner mayor o igual, en lugar de simplemente, mayor que 18?

Espacio publicitario

Si aplicamos un poco de lógica, una persona mayor de edad, no es solo aquella que tiene más de 18 años (mayor que), sino que también puede ser alguien que tenga exactamente 18 años (igual que).

Como puedes ver, hay que aplicar una lógica matemática y de sentido común, la cual, se va adquiriendo con la práctica. Parte de esta lógica es lo que habrás escuchado o escucharás como “lógica de programación”.

Estos ejemplos son fáciles, pero a lo largo de tu carrera, te enfrentarás a retos superiores. No te preocupes en absoluto si al principio te cuesta aplicar esta lógica, es completamente normal.

La palabra if se traduce al español como “si”. En este caso, “si”, no indica una afirmación, sino una condición.

Diagrama de flujo del condicional if-else

Este diagrama de flujo nos muestra un bloque de código (if) bajo una condición (expresión) booleana. Si esta evalúa como True, ejecuta el bloque de código if. En cambio, si es False, ejecuta el bloque de código asociado al else.

Solo se puede ejecutar una bloque a la vez o se ejecuta el bloque if, o lo hace el bloque else.

La declaración else

Con la declaración else, podemos disponer de código alternativo que se va a ejecutar en caso de que la condición del if evalúe como False.

La declaración else no tiene condición. Este bloque de código se ejecuta basándose en lo que evalúe la condición del if. Por lo tanto, no puede escribirse suelto en el código.

Sintaxis de la declaración else

Veamos la sintaxis de la declaración else:

if condición:
    # bloque de código indentado
else:
    # bloque de código indentado

Aquí tienes un ejemplo de uso:

# Se guarda una edad
edad = 16

# Evaluamos si es mayor de edad
if edad >= 18:
    print("Es mayor de edad.")
else:
    print("Es menor de edad.")

Es menor de edad.

Si el valor de la variable edad es mayor o igual a 18, se ejecutará el código del bloque if, en cualquier otro caso, se ejecuta el código del bloque else.

Si pongo la siguiente edad, el resultado del programa es otro:

# Se guarda una edad
edad = 32

# Evaluamos si es mayor de edad
if edad >= 18:
    print("Es mayor de edad.")
else:
    print("Es menor de edad.")

Es mayor de edad.

Bien, ahora nuestro programa es más “inteligente” y “sabe” cuándo una edad supera la mayoría de edad, y cuándo no, además de hacer dos cosas diferentes con ello. Esto con solo escribir unas pocas líneas de código.

La palabra else se puede traducir al español, en este contexto, como “de lo contrario o de otro modo”.

Espacio publicitario

Fallos de lógica

¿No sería genial poder hacer este programa más inteligente, y que tuviera la posibilidad de tomar más decisiones?

En un programa se pueden añadir tantos if como desees, así que podemos hacer tantas condiciones como queramos.

No obstante, si no aplicamos la lógica correctamente, nos puede quedar un programa con una inteligencia muy incoherente.

El siguiente ejemplo presenta fallos de diseño y de lógica. Es muy mal código. Ejecuta sin errores de sintaxis en la consola, pero eso no quiere decir que sea correcto, ya que el resultado no es el que seguramente estaríamos esperando.

# Se guarda una edad
edad = 76

# Evaluamos la edad
if edad < 18:
    print("Es menor de edad.")
if edad >= 18:
    print("Es adulto.")
if edad > 65:
    print("Es maduro.")
if edad > 75:
    print("Es anciano.")

Es adulto.
Es maduro.
Es anciano.

El resultado es del todo incoherente, ya que el programa ejecuta los tres if a la vez. Lo normal sería que si la edad es 76, me respondiera solo "Es anciano". Sin embargo, el valor 76 hace que las condiciones de los tres últimos if se cumplan.

¿Cómo hacemos para evitar este comportamiento?

Podríamos hacer uso de los operadores lógicos (and, or y not):

# Se guarda una edad
edad = 76

# Evaluamos la edad
if edad < 18:
    print("Es menor de edad.")
if edad >= 18 and edad <= 65:
    print("Es adulto.")
if edad > 65 and edad <= 75:
    print("Es maduro.")
if edad > 75:
    print("Es anciano.")

Es anciano.

¡Perfecto! Ahora funciona bien. Está funcionando porque he creado dos rangos de edades con el operador and.

Los rangos resultantes de esta lógica son los siguientes:

• Menos de 18
• 18 hasta 65
• 66 hasta 75
• 76 o más

Recuerda que para que las expresiones con and devuelvan True, ambas tienen que ser True.

Por ejemplo, si el valor de edad es 40, el programa hará las siguientes evaluaciones:

• edad < 18 = False
• edad >= 18 and edad <= 65 = True and True = True
• edad > 65 and edad <= 75 = False and True = False
• edad > 75 = False

Según la lógica que he establecido, no es posible que más de una condición evalúe como True a la vez. Ves haciendo pruebas con diferentes valores de edad, y analiza el porqué de cada resultado.

Se trata de ir creando una estructura que aplique la lógica en todo momento, no hay que dejar nada al azar.

El código ya funciona como cabría esperar, pero no es para nada una buena forma de hacer esto. Estos if, no tienen una relación real entre ellos, ninguno depende del otro, como si lo hacía el bloque else con if. En este código funcionan individualmente.

Con el tiempo aprenderás a optimizar tus programas y a hacerlos más eficientes. En este caso, una forma mucho mejor de hacer esto, será añadir un nuevo tipo de bloque. El bloque elif.

Espacio publicitario

La declaración elif

La declaración elif, al igual que else, siempre está sujeta a una declaración if. Esta se va a escribir siempre después de la declaración if, y antes de la declaración else.

Tanto elif como else no son declaraciones obligatorias. Son complementos para la declaración if, y no pueden escribirse solas, sin ella.

La palabra reservada elif, suele escribirse como else if en la mayoría de los lenguajes de programación. Sin embargo, en Python se hizo una nueva palabra formada de estas dos, para que se vea claramente que se trata de un bloque de código diferente a if o a else.

Diagrama de flujo del condicional if-elif-else

El siguiente diagrama de flujo muestra los caminos que se pueden ir tomando según las diferentes declaraciones que tengamos.

La declaración especificada como elif_n, sirve para indicar que puedes poner tantas declaraciones elif como necesites.

Sintaxis de la declaración elif

A continuación te muestro un ejemplo sobre la sintaxis de la declaración elif. Aquí se muestran tres declaraciones elif, pero no hay un límite establecido de las que puedas utilizar:

if condición:
    # bloque de código indentado
elif condición:
    # bloque de código indentado
elif condición:
    # bloque de código indentado
elif condición:
    # bloque de código indentado
...
else:
    # bloque de código indentado

En esta sintaxis podemos ver que las declaraciones elif también cuentan con su propia condición, al igual que la declaración if.

Los tres puntos (...) no representan nada de código Python, los pongo para indicar que se pueden poner tantos elif como necesitemos.

He reescrito el código de los ejemplos anteriores, para formar ya una estructura bien hecha, utilizando las herramientas de Python de la forma correcta. Cada condición contiene un rango estricto, gracias al operador and. Así evitaremos dejar posibles fallos de lógica.

# Se guarda una edad
edad = 32 # Prueba aquí la edad que quieras

# Evaluamos la edad
if edad >= 1 and edad < 18:
    print("Es menor de edad.")
elif edad >= 18 and edad < 65:
    print("Es adulto.")
elif edad >= 65 and edad < 75:
    print("Es maduro.")
elif edad >= 75 and edad < 110:
    print("Es anciano.")
else:
    print("¡No creo que tengas esa edad!")

Es adulto.

Los rangos respectivos de cada bloque son los siguientes:

• edad >= 1 and edad < 18 = entre 1 y 17 años.
• edad >= 18 and edad < 65 = entre 18 y 64 años.
• edad >= 65 and edad < 75 = entre 65 y 74 años.
• edad >= 75 and edad < 110 = entre 75 y 109 años.
• else = mayor que 109 o menor que 1 (incluye números negativos y cero).

Espacio publicitario

Condicional con is type()

Podemos combinar el uso del condicional if, junto a la función predefinida type(), para que nuestros programas puedan evaluar los tipos de datos.

Gracias a esto, podremos hacer que nuestros programas hagan cosas diferentes, basándose en qué tipo de dato se esté manejando. Es decir, que el programa sepa diferenciarlos, para hacer cosas con ellos.

Mira el siguiente ejemplo:

valor = # Escribe un valor aquí

if type(valor) is float:
    print("La variable contiene un número decimal.")
elif type(valor) is int:
    print("La variable contiene un número entero.")
elif type(valor) is str:
    print("La variable contiene una cadena.")
elif type(valor) is bool:
    print("La variable contiene un booleano.")
elif type(valor) is tuple:
    print("La variable contiene una tupla.")
elif type(valor) is list:
    print("La variable contiene una lista.")
elif type(valor) is set:
    print("La variable contiene un set.")
elif type(valor) is dict:
    print("La variable contiene un diccionario.")
else:
    print("Tipo de dato no contemplado.")

En la variable valor, pon cualquier tipo de valor de los que hemos visto hasta ahora.

La expresión a evaluar en las declaraciones, es la siguiente:

type(valor) is tipo de dato

La función type(), con un valor pasado, nos indica de qué tipo de dato es. Por ejemplo, si en la variable valor hay un valor 10.5, type() devuelve un resultado float. Entonces, hará que coincida con el bloque que tiene is float en la expresión.

Por si no lo estás entendiendo, voy a simplificar el código.

He quitado la repetición de type(valor) en cada condición, y lo he puesto en la variable tipo:

valor = # Escribe un valor aquí
tipo = type(valor) # Da el tipo de dato de valor

if tipo is float:
    print("La variable contiene un número decimal.")
elif tipo is int:
    print("La variable contiene un número entero.")
elif tipo is str:
    print("La variable contiene una cadena.")
elif tipo is tuple:
    print("La variable contiene una tupla.")
elif tipo is list:
    print("La variable contiene una lista.")
elif tipo is set:
    print("La variable contiene un set.")
elif tipo is dict:
    print("La variable contiene un diccionario.")
else:
    print("Valor no contemplado.")

Primero, a la variable valor, se le añade un valor del tipo que sea. Después, en la variable tipo, se guarda el tipo de dato que es. En el condicional if-elif-else, se compara con diferentes tipos de datos. Solo coincidirá con el que sea igual.

Para entender estas expresiones, puedes formar frases en español como esta: Si el tipo de dato es float, imprime en la consola “La variable contiene un número decimal”.

Ves probando diferentes posibilidades y verás de qué forma funciona.

El operador is se traduce al español como “es”, del verbo ser/estar (to be).

Combinación is not

El operador is se puede combinar con el operador lógico not, creando una negación. Expresamos todo lo contrario:

valor = 10

if valor is not float:
    print("No es un decimal.")
else:
    print("Es un decimal.")

No es un decimal.

Para entender estas expresiones, puedes formar frases en español como esta: Si el tipo de dato no es float, imprime en la consola “No es un decimal”.

Espacio publicitario

El operador ternario

El operador ternario es una forma de expresar un condicional if-else de una forma concisa, en una sola línea.

Sintaxis del operador ternario

La sintaxis de este operador es la siguiente:

variable = Expresión_True if condición else Expresión_False

Podemos ver tres partes:

• Condición o expresión
• Expresión verdadera (if)
• Expresión falsa (else)

Entonces, en una sola línea tenemos la instrucción que se ejecutará si la condición, también en la misma línea, evalúa como True, y la expresión que se ejecutará si evalúa como False.

Ejemplo de uso práctico del operador ternario

En el siguiente ejemplo tenemos una variable numérica que es evaluada por este condicional de sintaxis reducida.

Si el valor de la evaluación de edad >= 18 es True, guarda en la variable resultado, el valor que hay a la izquierda del if. En cambio, si evalúa como False, guarda el valor que hay a la derecha del else.

edad = int(input("Introduzca su edad: "))

resultado = "Es usted mayor de edad" if edad >= 18 else "Es usted menor de edad"

print(resultado)

Estos son los dos posibles resultados:

Introduzca su edad: 32
Es usted mayor de edad

Introduzca su edad: 17
Es usted menor de edad

El operador ternario nos va muy bien para hacer condiciones muy breves, como la del ejemplo.

El condicional match

El condicional match permite expresar condiciones de manera más simple. Se trata de una estructura muy parecida al condicional if (hablando de funcionamiento), pero está más pensada para escribir muchas condiciones repetitivas.

Si has estudiado antes algún lenguaje de programación, seguramente conozcas el condicional switch. Es lo mismo, solo que en Python se llama match.

Todas las estructuras de Python forman parte de la lista de palabras reservadas. Sin embargo, match es un elemento que lleva relativamente poco tiempo (apareció en la versión 3.10 de Python).

La palabra match no se ha incluido en la lista de palabras reservadas de Python, por temas de retrocompatibilidad.

Se habla de retrocompatibilidad en programación cuando se introduce una nueva funcionalidad o característica en una versión actualizada del software, de forma que no afecte negativamente a programas existentes que fueron escritos bajo versiones anteriores.

Espacio publicitario

En el caso específico de Python, cuando se introdujeron nuevas palabras clave como match, se aseguró de implementarlas de tal forma que no entraran en conflicto con el código existente que pudiera haber utilizado esas palabras como identificadores válidos. Esto garantiza que los programas escritos antes de la introducción de estas palabras clave puedan seguir ejecutándose correctamente en las nuevas versiones del lenguaje, sin necesidad de realizar modificaciones extra.

En el código anterior a la versión 3.10, es muy probable que se utilice la palabra match como identificador en elementos. Elementos como puede ser una variable, ya que se trata de una palabra muy común en inglés.

La palabra match se puede traducir al español como coincidencia.

Esto implica que puedes utilizar la palabra match para nombrar algún elemento, por ejemplo, una variable como esta:

match = 10
print(match)

10

No obstante, evita esta mala práctica. Puede crear confusión en tu código, y futuros errores si se acaba reservando la palabra.

Si tienes que migrar código antiguo de una aplicación hecha con Python, ten en cuenta, que si hay algún elemento nombrado con este nombre, mejor que lo cambies. Por supuesto, siempre que no vayas a comprometer la integridad del programa.

Palabras clave blandas

Desde la versión de inclusión del condicional match (3.10), se añadieron una serie de palabras clave llamadas “blandas” o “suaves”.

Estas palabras se crearon para definir palabras clave más flexibles, que permitan retrocompatibilidad (compatibilidad con versiones anteriores).

De momento el listado es muy corto:

• _
• case
• match
• type

Estas palabras están reservadas por convención, pero no por regla obligatoria. Por eso se denominan palabras clave blandas.

Palabra clave blanda se dice en inglés soft keyword.

Para ver la lista de palabras clave blandas en la consola, solo tienes que utilizar el siguiente código:

import keyword

print(keyword.softkwlist)

['_', 'case', 'match', 'type']

Sintaxis del condicional match

A continuación, puedes ver la sintaxis del condicional match:

match expresión:
    case patrón_1:
        # Código del case
    case patrón_2:
        # Código del case
    case patrón_n:
        # Código del case
    case _:
        # Código alternativo

Fíjate bien en las indentaciones, esta estructura tiene varios niveles de indentación.

La palabra case, tampoco está reservada por Python. Fíjate que es una de las que hay en la lista de palabras clave blandas.

La palabra case se puede traducir al español como “caso”, pero algo más aproximado a su uso en Python, es “opción”.

En el pseudocódigo de sintaxis, expresión representa la expresión o variable que queremos comparar con los diferentes patrones puestos en cada case.

Un patrón, en el contexto de match, es una expresión que se utiliza para hacer coincidir con un valor específico o una estructura de datos. Cuando se encuentra una coincidencia (se hace match) entre el valor a evaluar y el patrón asociado a un bloque case, se ejecuta el código de dicho bloque.

case es una palabra que marca el inicio de un nuevo patrón que queremos evaluar.

patrón_1 y patrón_2, son expresiones que representan los patrones que queremos verificar con respecto a la expresión a evaluar.

patrón_n, representa la posibilidad de añadir un número indeterminado de declaraciones case.

Espacio publicitario

_ (guion bajo), es un comodín especial para cualquier otro valor que no haya coincidido con los case anteriores. Podríamos decir que “es el else del condicional match”. Si no se encuentra una coincidencia en ninguno de los case, se ejecutará el bloque de código correspondiente a este último case.

El guion bajo (_) se puede reemplazar por cualquier nombre válido, no tiene por qué ser ese símbolo. Si pones, por ejemplo, una palabra como defecto, funciona igual. No obstante, por convención, es más claro utilizar el guion bajo, puesto que la mayoría de desarrolladores, siguiendo la referencia de Python, ya lo utilizan así.

Diagrama de flujo del condicional match

El siguiente diagrama muestra el flujo de ejecución del condicional match.

Se trata de una estructura muy lineal, que va leyendo las posibles coincidencias, de arriba a abajo.

Si la expresión no coincide con un patrón, se va pasando al siguiente, así hasta llegar al bloque _.

Ejemplo de uso práctico del condicional match

Veamos de qué forma funciona este condicional en la práctica.

Vamos a recrear un condicional que evaluará números de códigos HTTP, en servidores web.

No hace falta que tengas experiencia en este tema, es tan solo un ejemplo para comparar valores, y que veas como funciona el condicional match.

Recuerda que la función input() recibe la entrada como tipo str. Si no haces ninguna conversión de tipos de datos, los case, para poder coincidir, deberán tener patrones de ese tipo de dato.

match codigo:
    case "200":
        print("Todo ok.")
    case "301":
        print("Movimiento permanente de la página.")
    case "302":
        print("Movimiento temporal de la página.")
    case "404":
        print("Página no encontrada.")
    case "500":
        print("Error interno del servidor.")
    case "503":
        print("Servicio no disponible.")
    case _:
        print("Código no disponible.")

Voy a poner en la consola el código 300. Puesto que no está contemplado en ninguno de los case, lo que se ejecutará, es el código del case _ ("Código no disponible."):

Introduzca un código HTTP: 300
Código no disponible.

Este case sin patrón, se ejecuta siempre que todos los otros case evalúen como False.

Si introducimos un valor que coincide con alguno de los otros case, se va a ejecutar ese bloque de código concreto. El resto se descarta.

Al poner el valor "300" en la consola, se evalúa primero el case con valor "200". Este evalúa como False, por lo que pasa a comparar con el siguiente. Evalúa como False también. Así lo mismo, hasta llegar al último case (case "503"). Puesto que ya no quedan más posibles case, se ejecuta finalmente el bloque por defecto case _.

Ahora, ejecuto de nuevo e introduzco en la consola un valor "404". Se evalúa primero el case con valor "200". Este evalúa como False, por lo que pasa a comparar con el siguiente, que es el case con un patrón "301", este también evalúa como False. El siguiente ("302") también. Llegamos al case "404", el cual coincide y evalúa como True. El resto de case se ignoran.

Introduzca un código HTTP: 404
Página no encontrada.

Funciona como el condicional if-elif-else. Este ejecuta un bloque de código concreto, y el resto se ignora.

La función input(), al entrar los datos como str, nos obliga a tener patrones de ese tipo, pero si quieres utilizar en los patrones de los case, valores numéricos enteros, en lugar de cadenas, tendrás que hacer una conversión de tipos de datos:

codigo = int(input("Introduzca un código HTTP: "))

match codigo:
    case 200:
        print("Todo ok.")
    case 301:
        print("Movimiento permanente de la página.")
    ...

Espacio publicitario

Bloques case con patrones múltiples

El condicional match permite especificar más de un patrón para un mismo bloque de código. Veamos un ejemplo.

Los códigos HTTP, son una serie de códigos con los que informar de errores ocurridos, o informar de situaciones de estado en conexiones web.

Hay muchos códigos HTTP, de forma que se agrupan en cinco categorías:

• Los códigos 1xx son códigos informativos.
• Los códigos 2xx son de éxito (que ha funcionado correctamente).
• Los códigos 3xx son para informar de redirecciones.
• Los códigos 4xx son para informar de errores en el cliente.
• Los códigos 5xx son para informar de errores en el servidor.

Aquí tienes una tabla con los códigos de cada categoría*:

* En esta tabla, solo hay unos pocos códigos HTTP. En realidad hay muchos más.

Entonces, sabemos que cada fila de la tabla contiene varios códigos. Estos códigos están relacionados con los de su misma categoría.

Si queremos crear un condicional match como el de antes, pero para cada uno de estos códigos, podemos hacer dos cosas:

Creamos 17 bloques de código (el total de códigos de la tabla) o bien, creamos 5 bloques, agrupando cada conjunto. Depende de si se quiere hacer algo específico con cada código, o bien, algo con cada conjunto.

En el siguiente ejemplo puedes ver como se hace agrupando por conjuntos:

codigo = int(input("Introduzca un código HTTP: "))

match codigo:
    case 100 | 101 | 102:
        print("Código de tipo informativo.")
    case 200 | 201 | 202 | 203:
        print("Código de éxito")
    case 300 | 301 | 302 | 303:
        print("Código de redirección.")
    case 400 | 404 | 407:
        print("Código de error en el cliente.")
    case 500 | 502 | 599:
        print("Código de error en el servidor.")
    case _:
        print("Código no disponible.")

Ahora, contamos con grupos de patrones en cada case, gracias al uso del carácter pleca (|).

Sin estas agrupaciones, tendríamos que hacer obligatoriamente 17 bloques de código, para crear estas mismas respuestas.

Por ejemplo, para que al introducir en la consola los códigos 100, 101 o 102, nos respondiese siempre "Código de tipo informativo.", tendríamos que repetir tres veces la misma frase, en tres bloques distintos:

codigo = int(input("Introduzca un código HTTP: "))

match codigo:
    case 100:
        print("Código de tipo informativo.")
    case 101:
        print("Código de tipo informativo.")   
    case 102:
        print("Código de tipo informativo.")

También, ten en cuenta que puedes hacer una mezcla entre patrones agrupados y patrones simples. En el siguiente ejemplo, tengo los códigos 100, 101 y 102 con su respuesta específica, y luego tengo agrupaciones generales para el resto:

codigo = int(input("Introduzca un código HTTP: "))

match codigo:
    case 100:
        print("Continuar.")
    case 101:
        print("Cambiando de protocolos.")   
    case 102:
        print("Procesando.")
    case 200 | 201 | 202 | 203:
        print("Código de éxito.")
    case 300 | 301 | 302 | 303:
        print("Código de redirección.")
    case 400 | 404 | 407:
        print("Código de error en el cliente.")
    case 500 | 502 | 599:
        print("Código de error en el servidor.")
    case _:
        print("Código no disponible.")

Todo dependerá de lo que quieras conseguir. Los límites, los estableces tú.

Además, los patrones pueden contener diferentes tipos de datos, no tienen que ser necesariamente los mismos para todos los case.

match con estructuras de datos

Con el condicional match, también podemos evaluar si hay coincidencia con estructuras de datos, como puede ser una lista, una tupla...

El siguiente ejemplo te muestra cómo utilizar este tipo de sintaxis:

lista_numeros = [10, 20, 30]

match lista_numeros:
    case [102, 48]:
        print("Bloque n.º 1.")
    case [10, 20, 30]:
        print("Bloque n.º 2.")   
    case _:
        print("Ninguna coincidencia.")

Bloque n.º 2.

Espacio publicitario

Condicional match vs condicional if

El código de los ejemplos anteriores, escrito con match, es bastante fácil y cómodo de escribir. Sin embargo, si lo hacemos con un if, veremos que se añade complejidad extra:

if codigo == "200":
    print("Todo ok.")
elif codigo == "301":
    print("Movimiento permanente de la página.")
elif codigo == "302":
    print("Movimiento temporal de la página.")
elif codigo == "404":
    print("Página no encontrada.")
elif codigo == "500":
    print("Error interno del servidor.")
elif codigo == "503":
    print("Servicio no disponible.")
else:
    print("Código no disponible.")

Como puedes ver, el condicional if-elif-else, siempre necesita en todos los bloques una expresión (excepto el else). En el match, estamos utilizando sencillos patrones sin operadores. No estamos repitiendo cada vez la expresión "codigo == valor".

Conclusión

En conclusión, no podemos decir que haya un condicional mejor que otro. Son dos herramientas distintas para diferentes situaciones.

Si necesitas evaluar muchas cosas que estén relacionadas, un match podría ser la opción adecuada. En cambio, si necesitas evaluar pocas cosas o bien, expresiones complejas, el if podría ser una buena opción.

El tiempo y la experiencia, te harán ganar seguridad en este tipo de elecciones. Tú ves probando e irás viendo qué estructura se adapta mejor a lo que vas programando.

Cambiemos totalmente de tema. A continuación empezamos con los bucles, las otras estructuras de control de flujo que nos quedan por ver en este capítulo.

¿Qué es un bucle?

Un bucle es una estructura de control de flujo que permite repetir un bloque de código un número determinado o indeterminado de veces.

Bucle en inglés se dice loop.

Los bucles son elementos necesarios en programación, ya que permiten ejecutar una tarea concreta varias veces, sin tener que escribir manualmente el mismo código repetidamente. Esto puede no parecer gran cosa, pero ya verás que con estas estructuras se te está abriendo un mundo nuevo.

Veamos un ejemplo sencillo. Si quieres imprimir en la consola repetidamente el mensaje "Soy una frase repetitiva.", cinco veces, con lo que llevas estudiado en este curso, necesitas poner cinco print():

print("Soy una frase repetitiva.")
print("Soy una frase repetitiva.")
print("Soy una frase repetitiva.")
print("Soy una frase repetitiva.")
print("Soy una frase repetitiva.")

Soy una frase repetitiva.
Soy una frase repetitiva.
Soy una frase repetitiva.
Soy una frase repetitiva.
Soy una frase repetitiva.

O bien, puedes automatizar la tarea con un bucle como este:

for i in range(5):
    print("Soy una frase repetitiva.")

Soy una frase repetitiva.
Soy una frase repetitiva.
Soy una frase repetitiva.
Soy una frase repetitiva.
Soy una frase repetitiva.

Con algo tan simple, puedes repetir la frase cinco veces o las que quieras. Además, los bucles no están limitados a una sola instrucción; puedes incluir tantas como necesites. Esto significa que pueden realizar desde tareas sencillas hasta tareas muy complejas.

Espacio publicitario

Terminología de bucles

Cuando hablamos de bucles, utilizamos una terminología específica para describir sus elementos y acciones:

• Iteración o iterar: Es el proceso de recorrer objetos o elementos de una colección.
• Iterador: Es un objeto que produce valores sucesivos a partir de un objeto iterable.
• Iterable: Es un objeto sobre el que podemos iterar. Por ejemplo, una lista, tupla, secuencia de números con range(), etc.
• Variable iteradora: Es una variable que se utiliza para iterar el objeto iterable. Normalmente, se llama i.
• Expresión del bucle: Es el conjunto que representa las condiciones en las que se debe iterar el bucle. Por ejemplo, i < 5 es una expresión que indica que el bucle se ejecute mientras que el valor de la variable iteradora sea menor que 5. Como toda expresión, genera un resultado booleano: evaluará como True mientras se cumpla y como False cuando ya no se cumpla.
• Break: “Rotura” antes de tiempo de la ejecución del bucle.
• Continue: Omisión de ciertas iteraciones del bucle.
• Bucle: Es la estructura de control completa, que maneja todos estos elementos. Ejemplos de bucle son for y while.
• Secuencia: Se refiere a una serie de pasos que se llevan a cabo para completar una tarea. Por ejemplo, [0, 1, 2, 3, 4] es una secuencia. Ahí tendríamos 5 pasos en la secuencia.

Iterador en inglés se dice iterator. Iterar se dice iterate.

Estas explicaciones son algo técnicas, pero totalmente necesarias. Es probable que aún no las entiendas muy bien, pero no te preocupes, pronto lo harás. Solo necesitas ver más ejemplos y practicar un poco, con el fin de que comprendas toda esta charla teórica y complicada, especialmente si nunca has utilizado un bucle. A continuación, vas a ver ejemplos de todo tipo, paso a paso y con calma.

Operadores de asignación

En Python, los operadores de incremento y decremento son muy útiles para trabajar con bucles, ya que te permiten aumentar o disminuir de forma fácil el valor de una variable, como puede ser la variable iteradora.

Operador de asignación de suma (+=)

El operador de asignación de suma (+=), se utiliza para aumentar el valor de una variable, sumándole una cantidad específica. Es una forma abreviada de realizar una adición y asignación con un solo operador.

a = 4
a += 3

print(a)

7

Sin este operador tendrías que hacer esta operación de una forma menos óptima, utilizando dos operadores sueltos. Primero, asignación y luego adición, obteniendo primero el valor propio de la variable y luego añadiéndole el valor extra.

a = 4
a =  a + 3

print(a)

Operador de asignación de resta (-=)

El operador de asignación de resta (-=), se usa para disminuir el valor de una variable, restando una cantidad específica. Es una forma abreviada de realizar una sustracción (resta), y asignación con un solo operador:

a = 4
a -= 3

print(a)

1

En muchos lenguajes de programación, los operadores de incremento en 1 y decremento en 1, se expresan como variable++ o variable--, respectivamente.

Espacio publicitario

Operador de asignación de multiplicación (*=)

También contamos con el operador de asignación de multiplicación (*=), que sirve para incrementar asignando el resultado de una multiplicación.

Por ejemplo, queremos incrementar con multiplicación el valor 10 por 5 (10 * 5):

a = 10
a *= 5

print(a)

50

Operador de asignación de división (/=)

El operador de asignación de división (/=), sirve para realizar una división y asignación. Todo en uno:

a = 100
a /= 5

print(a)

20.0

Con esto ya tienes todo lo necesario para empezar a manejar los bucles de Python. Empecemos por el bucle for.

El bucle for

Un bucle for en programación es una estructura de control que se utiliza para iterar sobre una secuencia de elementos iterables, como listas, tuplas, rangos de números, etc. Su función es ejecutar un bloque de código repetidamente con cada elemento de la secuencia.

En un bucle for, la variable iteradora recibe un valor diferente de la secuencia en cada paso. Dentro del bucle, puedes usar esta variable para hacer algo con ese valor específico.

El bucle for continúa ejecutándose hasta que se han recorrido todos los elementos de la secuencia.

La palabra for significa en español “para”.

Diagrama de flujo del bucle for

El siguiente diagrama de flujo muestra, de forma muy simplificada, cómo funciona la ejecución de un bucle for. Mientras la secuencia tenga elementos, el bucle for sigue ejecutándose. Una vez que ya no quedan más elementos, el bucle se detiene.

Traduciendo esto a valores booleanos, mientras el iterable tiene elementos por recorrer, la evaluación es True. Finalmente, cuando no queden elementos que recorrer, evaluará como False y finalizará su ejecución.

Espacio publicitario

Sintaxis del bucle for

for variable_iteradora in iterable:
    # Código a ejecutar en cada iteración

Por un lado, contamos con una variable_iteradora, que suele ser una variable llamada i. Esta se denomina variable de control, variable del bucle, variable iteradora, etc.

Después encontramos el operador in, que servirá para indicarle al intérprete de Python, qué iterable queremos iterar, con la variable iteradora.

La parte de iterable, es el elemento (objeto) que queremos iterar un número x de veces, con la variable_iteradora.

El número de veces que se ejecute un bucle, dependerá de la longitud del elemento iterado. Por ejemplo, hacemos un bucle para recorrer una lista y hacer algo con ella. El bucle se ejecutará el mismo número de veces que elementos contenga la lista.

Bucle for con range()

El siguiente ejemplo es un bucle for que se ejecuta 5 veces:

for i in range(5):
    print(f"El valor del bucle es: {i}.")

El valor del bucle es: 0.
El valor del bucle es: 1.
El valor del bucle es: 2.
El valor del bucle es: 3.
El valor del bucle es: 4.

La explicación sencilla es que le decimos al intérprete de Python: “Ejecuta este print() un total de 5 veces”.

La explicación más técnica es la siguiente:

La función predefinida range(), con un valor de 5, crea una secuencia iterable: [0,1,2,3,4]. Puedes imaginar esta secuencia como una lista o una tupla, que tienen esos números. Algo parecido a esto:

lista = [0,1,2,3,4]

for i in lista:
    print(f"El valor del bucle es: {i}.")

De hecho, este código es perfectamente válido, ya que una lista es un objeto iterable, al igual que ocurre con range(). La función range() nos produce el iterable con la secuencia que queramos, no tenemos que escribir nosotros mismos los números, como en la lista del ejemplo anterior.

Volvamos al ejemplo anterior:

for i in range(5):
    print(f"El valor del bucle es: {i}.")

Cuando se ejecuta el bucle, se hace lo siguiente:

1. Creación de la secuencia: Se crea la secuencia [0, 1, 2, 3, 4] con la función range(5).
2. Iteración inicial: Se pasa el primer elemento (0) de la secuencia a la variable iteradora i.
3. Ejecución del código: Se ejecuta el bloque de código. En este caso, es solo el print(), pero podemos escribir todo el código que queramos, al igual que con los condicionales. Este print() te muestra además el valor de la variable para que lo veas, pero no es obligatorio usar su valor dentro del bloque de código.
4. Finalización de la primera iteración: Cuando no hay más instrucciones en el bloque de código del bucle, se termina la primera iteración o ejecución del bucle.
5. Siguiente iteración: La variable iteradora (i) obtiene el segundo valor de la secuencia.
6. Repetición: Se ejecuta el bloque de código de nuevo.
7. Finalización del bucle: Así hasta que llegamos al último valor de la secuencia (4). En ese momento finaliza la ejecución del bucle.

Sintaxis de la función range()

Aquí tienes la sintaxis y el uso de parámetros en la función range():

range(inicio, final, paso)

Obtener la secuencia de range()

Si alguna vez tienes dudas sobre la secuencia que produce range(), imprímela. Tan solo debes saber cómo hacerlo. Si imprimimos directamente un range(), nos aparece esto en la consola:

print(range(5))

range(0, 5)

Esto no quiere decir que la secuencia sea esta. Aquí estás viendo los valores de inicio y final del range().

Si solo le pasas un valor al range(), por defecto añade 0 como parámetro de inicio y el valor pasado entre los paréntesis como parámetro final, que en este ejemplo es 5. Este último valor se excluye de la secuencia, es decir, se genera un rango del 0 al 4.

Es decir, si haces esto:

range(5)

En realidad, se ejecuta implícitamente esto:

range(0,5)

Recuerda esta sintaxis:

range(inicio, final)

Esto lo hace el intérprete de Python de forma interna, al solo poner un valor de final, nos “rellena” la parte de inicio del range() con un 0. Ese es el valor de inicio por defecto de esta función.

Ahora ya sabes por qué la secuencia del range() empieza en 0 si solo le ponemos un valor en los paréntesis.

Ten presente, que todo lo que ocurre en programación, ocurre por algo, nada ocurre porque sí.

Finalmente, si deseas ver la secuencia del range(), puedes convertir su llamada con las funciones predefinidas list() o tuple(), entre otras, que lo que hacen es convertir tipos de datos a listas, tuplas, etc. Con esto, estoy convirtiendo la secuencia del range() a lista:

print(list(range(5)))

[0, 1, 2, 3, 4]

Así es como podemos revelar la secuencia en la consola.

Con esto, no solo puedes aprender con mayor profundidad sobre la función range(), sino que es posible utilizar la secuencia para otros propósitos en el código. No obstante, ya estamos hablando de cosas más avanzadas que no vienen al caso en este momento.

Espacio publicitario

Expresión en los bucles

Los bucles, al igual que los condicionales, trabajan de forma implícita con expresiones booleanas. Con esto quiero decir, que tienen una condición que evalúa como True o False, para decidir si se siguen ejecutando. Si esta evalúa como True, el bucle se ejecuta. Comprueba de nuevo, tras ejecutarse, y si es True, se vuelve a ejecutar de nuevo. Hasta que la expresión produzca un resultado False, y ya no se ejecute más.

Por ejemplo, tenemos un iterable como el de los ejemplos anteriores:

range(5)

[0,1,2,3,4]

Entonces, la evaluación booleana, la hace así:

• ¿Está 0 en la secuencia [0, 1, 2, 3, 4]? - True
• ¿Está 1 en la secuencia [0, 1, 2, 3, 4]? - True
• ¿Está 2 en la secuencia [0, 1, 2, 3, 4]? - True
• ¿Está 3 en la secuencia [0, 1, 2, 3, 4]? - True
• ¿Está 4 en la secuencia [0, 1, 2, 3, 4]? - True
• ¿Está 5 en la secuencia [0, 1, 2, 3, 4]? - False

Rangos con range()

Podemos hacer rangos diferentes, especificando manualmente dos valores numéricos en la función predefinida range():

range(inicio, final)

En el siguiente ejemplo, el primer valor del range() indica el inicio del rango, y el segundo, el final. Esta vez, estamos manejando el valor inicio de forma explícita:

for i in range(3,7):
    print(f"El valor del bucle es: {i}.")

El valor del bucle es: 3.
El valor del bucle es: 4.
El valor del bucle es: 5.
El valor del bucle es: 6.

En este ejemplo, el iterador empieza con el valor 3 y termina en el 7.

Cuando el valor de i llega a 7, este ya no se ejecuta, por lo tanto, no sale el print() con ese valor.

El motivo de este funcionamiento es que al escribir range(3,7), estamos generando internamente una secuencia de valores del 3 al 6, ([3, 4, 5, 6]).

Mientras el bucle esté iterando sobre la secuencia, seguirá ejecutándose cada vez que la evaluación sea True. Una vez que se ha completado la secuencia, antes de llegar al 7, que no está en la secuencia, el bucle evalúa como False y deja de ejecutarse. Por lo tanto, no imprime el valor 7.

A continuación tienes un listado con las iteraciones que haría un bucle con range(5):

• Iteración 1:
  • El valor de la variable iteradora (i) es 0.
  • Se comprueba si el valor 0 está en la secuencia generada por la función range() (0 in [0, 1, 2, 3, 4]).
  • Puesto que sí lo está, el valor devuelto es True.
  • Se incrementa en 1 el valor de la variable iteradora.
• Iteración 2:
  • El valor de la variable iteradora (i) es 1.
  • Se comprueba si el valor 1 está en la secuencia generada por la función range() (1 in [0, 1, 2, 3, 4]).
  • Puesto que sí lo está, el valor devuelto es True.
  • Se incrementa en 1 el valor de la variable iteradora.
• Iteración 3:
  • El valor de la variable iteradora (i) es 2.
  • Se comprueba si el valor 2 está en la secuencia generada por la función range() (2 in [0, 1, 2, 3, 4]).
  • Puesto que sí lo está, el valor devuelto es True.
  • Se incrementa en 1 el valor de la variable iteradora.
• Iteración 4:
  • El valor de la variable iteradora (i) es 3.
  • Se comprueba si el valor 3 está en la secuencia generada por la función range() (3 in [0, 1, 2, 3, 4]).
  • Puesto que sí lo está, el valor devuelto es True.
  • Se incrementa en 1 el valor de la variable iteradora.
• Iteración 5:
  • El valor de la variable iteradora (i) es 4.
  • Se comprueba si el valor 4 está en la secuencia generada por la función range() (4 in [0, 1, 2, 3, 4]).
  • Puesto que sí lo está, el valor devuelto es True.
  • Se incrementa en 1 el valor de la variable iteradora.
• Iteración 6 (no procede):
  • El valor de la variable iteradora (i) es 5.
  • Se comprueba si el valor 5 está en la secuencia generada por la función range() (5 in [0, 1, 2, 3, 4]).
  • Puesto que no lo está, el valor devuelto es False. Esta iteración no ocurre.
  • No se incrementa más el valor de la variable iteradora.
• El bucle ha finalizado.

Modificar el incremento o decremento de range()

Se puede añadir otro parámetro más a la función range(), para que los incrementos o decrementos sean mayores. Esta es la sintaxis:

range(inicio, final, paso)

El incremento o decremento del range(), también llamado paso, va de uno en uno, si no se especifica un valor concreto. Por ejemplo, para incrementar de 4 en 4, lo haremos poniendo un tercer valor (4) de forma explícita a los paréntesis de la función range():

for i in range(3, 12, 4):
    print(f"El valor del bucle es: {i}.")

El valor del bucle es: 3.
El valor del bucle es: 7.
El valor del bucle es: 11.

En este ejemplo, el bucle se ejecuta desde que el iterador vale 3, hasta que vale 12, con saltos de 4 en 4. El 12, no se ejecuta, puesto que el incremento de 4, no cabe en el rango después del valor 11.

La secuencia generada esta vez ha sido la siguiente:

[3, 7, 11]

También se puede especificar un decremento utilizando valores negativos:

for i in range(3, -12, -4):
    print(f"El valor del bucle es: {i}.")

El valor del bucle es: 3.
El valor del bucle es: -1.
El valor del bucle es: -5.
El valor del bucle es: -9.

Espacio publicitario

Secuencia vacía

Si el valor de inicio del range() es mayor que el de final, se genera una secuencia vacía, y no hay nada que iterar. Evalúa False desde un principio. Aquí tienes un ejemplo:

for i in range(10, 0):
    print(f"El valor del bucle es: {i}.")

Este bucle no se ejecuta ni una sola vez.

Podemos comprobar lo que digo de la siguiente forma:

print(list(range(10, 0)))

[]

Lo que ves en la consola, es una secuencia vacía.

El operador in

El operador in de Python es un elemento frecuentemente utilizado en bucles, aunque también se utiliza mucho en condicionales, para comprobar si hay coincidencias.

El operador in pertenece a la lista de palabras reservadas de Python.

La palabra in, en español, se traduce como “en”.

Si el elemento está en la secuencia, evalúa como True, y si no lo está, como False.

Sintaxis del operador in

El operador in utiliza dos valores para operar: el valor que se desea comprobar (a la izquierda del operador) y la secuencia en la que se desea buscarlo (a la derecha del operador). El operador va a devolver un valor booleano True, si el valor se encuentra dentro de la secuencia, o False si no se encuentra en ella.

valor_a_comprobar in secuencia

La secuencia de las cadenas

Las cadenas de caracteres también cuentan con una secuencia. Es decir, tienen índice de posición como las listas o las tuplas. Esto quiere decir, que podemos utilizar el operador in con ellas.

Cada caracter de una cadena, ocupa una posición de índice. Esto se puede comprobar muy fácilmente convirtiendo un str a list:

cadena = "Hola, mundo!"

# Se hace una lista con los valores de cada posición
lista_caracteres = list(cadena)

print(lista_caracteres)

['H', 'o', 'l', 'a', ',', ' ', 'm', 'u', 'n', 'd', 'o', '!']

Esto nos indica que en Python, cada caracter puede ser tratado individualmente.

Acceder a una posición concreta de una cadena

Para acceder a una posición concreta de una cadena, lo haremos de la misma forma que con las listas. Cada carácter de esta ocupa una posición de índice, que se cuenta desde el 0, hasta el número de posiciones que ocupe.

Para entenderlo mejor, observa el siguiente ejemplo:

saludo = "Hola"

print(saludo[0])
print(saludo[1])
print(saludo[2])
print(saludo[3])

H
o
l
a

Espacio publicitario

Ejemplos de uso del operador in

El operador in con cadenas

Empecemos probando este operador con una simple cadena de caracteres.

En el siguiente código, voy a comprobar si una palabra está dentro de una cadena:

# Elemento con secuencia
texto = "La programación es el arte de crear algo de la nada."

# Variable para buscar una coincidencia
buscar = "arte" in texto
print(buscar)

True

El valor True de la consola indica que ha habido una coincidencia de la palabra "arte", en la cadena texto.

Si el valor a buscar no se encuentra literalmente en la cadena, obtendrás un valor False.

Por ejemplo, si buscas "a", te va a dar un resultado True, ya que hay varios caracteres que coinciden. Si buscas "crear algo", te va a dar un resultado True, también. Eso es por qué literalmente, se encuentra dentro de la cadena de caracteres. En cambio, si buscas algo como "ae", te va a dar un resultado False. En la cadena, hay caracteres a, y hay caracteres e, pero nunca se encuentra uno junto al otro, no existe literalmente una parte que contenga "ae".

El operador in con listas, tuplas o conjuntos

En el siguiente ejemplo, se está utilizando una lista (lo mismo se aplicará a una tupla o a un conjunto) para buscar un elemento dentro de ella.

# Elemento con secuencia
colores = ["rojo", "verde", "azul", "amarillo"]

# Variable para buscar una coincidencia
buscar = "rojo" in colores
print(buscar)

True

La pregunta que realizamos al intérprete al utilizar este operador, es: ¿Está este valor en este elemento?

Bucle para iterar listas, tuplas, etc.

Con los bucles podemos hacer infinidad de cosas. Una de las muchas que podemos llevar a cabo, es iterar elementos iterables como son las listas o las tuplas. Es decir, recorrer sus elementos de uno en uno, para utilizarlos y no tener que escribir código repetitivo.

Aquí tienes un ejemplo:

colores = ["rojo", "azul", "verde", "amarillo"]

print("---LISTADO DE COLORES---")

for color in colores:
    print(f"-{color}.")

---LISTADO DE COLORES---
-rojo.
-azul.
-verde.
-amarillo.

Para empezar, he cambiado el típico nombre de la variable iteradora con i, por el nombre color. Esto para que aprecies que es posible darle un valor semántico, con el fin de mejorar el entendimiento del código por parte de las personas.

Con color in colores, se indica que se quiere iterar con la variable color, la lista llamada colores. Eso es todo.

El operador in, itera el elemento hasta que no le quedan más. Devuelve True cada vez que le queda algún elemento que recorrer, y cuando no tiene más, evalúa como False. Haciendo que termine el bucle.

Es lo mismo que con range(), solo que esta vez utilizamos un elemento diferente, una lista.

Cuando empieces a automatizar tareas, ya verás qué útil es el operador in, para hacer todo tipo de cosas con secuencias de datos.

El operador in en condicionales

Otro lugar muy frecuente donde utilizar el operador in, es en los condicionales.

Con los condicionales podemos buscar un valor en una secuencia o comparar una secuencia con otra, y que el programa actúe de una forma u otra, según los resultados de las coincidencias.

En el siguiente ejemplo, estoy evaluando si el valor "azul" está en la lista:

colores = ["rojo", "azul", "verde", "amarillo"]
color_buscado = "azul"

if color_buscado in colores:
    print(f"El color {color_buscado} está en la lista.")
else:
    print(f"El color {color_buscado} no está en la lista.")

El color azul está en la lista.

Si hay una coincidencia, devolverá True. Eso hace que se ejecute el bloque de código del if. En caso contrario, como bien sabes, se ejecuta el bloque de código else:

color_buscado = "magenta"

El color magenta no está en la lista.

Espacio publicitario

Elementos anidados

Los elementos anidados son aquellos que están contenidos dentro de otros elementos; por ejemplo, podemos poner un condicional dentro de un bucle. Esto va a añadir mayor complejidad al código, pero también muchas más posibilidades, ya que se pueden anidar más y más estructuras dentro de otras.

No te excedas empleando la anidación. Por norma general, utiliza la estrictamente necesaria. No añadas niveles de anidación, si se puede hacer lo mismo sin ellos. Recuerda siempre “Simple mejor que complejo”.

¿Cómo anidamos estructuras de control dentro de otras?

Para anidar estructuras de control de flujo dentro de otras, deberás aplicar diferentes niveles de indentación.

•          NIVEL 1
•                  NIVEL 2
•                          NIVEL 3

Se pueden añadir tantos niveles de indentación como sea necesario. Estos tres niveles son de referencia sobre los niveles que vas a utilizar en este curso.

Las indentaciones en Python deben aplicarse a la perfección, ya que no son solo una cuestión de organización del código. Una mala indentación provocará errores, generalmente de tipo IndentationError. Estos errores significan que el programa no se iniciará o que puede que no funcione correctamente en ciertas ocasiones.

En el siguiente ejemplo está anidado un condicional if, dentro de un bucle for:

for expresión:
    # Bloque de código del bucle for
    if expresión:
        # Bloque de código del condicional if

La declaración del for no está indentada; está en nivel 0 de indentación.

El bloque de código del bucle for, lleva una indentación de nivel 1. Esta indentación, especifica el bloque del propio bucle:

    # Bloque de código del bucle for

Dentro de este bloque, podemos ver que está el condicional if declarado en ese nivel 1 de indentación:

    if expresión:

El condicional if, tiene su propio bloque de código. Este estará en nivel 2 de indentación:

        # Bloque de código del condicional if

Para aplicar esto a la perfección, simplemente fíjate bien en los tonos de color que utilizo en los niveles; cada uno es una tabulación.

Si tenemos otra estructura dentro del condicional if del ejemplo anterior, esta también llevará una indentación más para su bloque de código (nivel 3 de indentación):

for expresión:
# Bloque de código del bucle for
    if expresión:
        # Bloque de código del condicional if
        for expresión:
            # Bloque de código del bucle for

Así sucesivamente, con tantos elementos anidados como necesitemos.

Como puedes ver, aplicando anidación de elementos, el código se va complicando más y más; por eso es importante utilizarla solo cuando es necesario.

If anidados

En muchas ocasiones, verás que es útil añadir condicionales if-elif-else, dentro de otros. Esto es lo que se conoce como if anidados.

if anidado se conoce en inglés como nested if.

Anidar condicionales es muy útil cuando se quiere añadir una regla sobre otra regla. A continuación tienes un ejemplo (te he marcado los if-else anidados):

numero = float(input("Introduzca un número: "))

# if principal
if numero >= 0:
    # ifs anidados
    if numero == 0: 
        print("El número es cero.")
    else: 
        print("El número es positivo.")
    
    if numero > 10:
        print("El número es mayor que 10.")
    else:
        print("El número no es mayor que 10.")
# else del if principal
else: 
    print("El número es negativo.")
    # otro if anidado
    if numero < -10:
        print("El número es menor que -10.")
    else:
        print("El número no es menor que -10.")

Fíjate muy bien, en que cada nivel de if, aplica un nuevo nivel de indentación. Esto quiere decir que uno está dentro de otro.

Puedes hacer más niveles de anidación, pero cuantos más hagas, más complejo, difícil de leer y depurar (solucionar errores) será tu código.

Estas son las posibles salidas en la consola:

Introduzca un número: -25
El número es negativo.
El número es menor que -10.

Introduzca un número: -1
El número es negativo.
El número no es menor que -10.

Introduzca un número: 0
El número es cero.
El número no es mayor que 10.

Introduzca un número: 1
El número es positivo.
El número no es mayor que 10.

Introduzca un número: 25
El número es positivo.
El número es mayor que 10.

Esta estructura nos está permitiendo añadir reglas, y luego, reglas más específicas basadas en las primeras.

Espacio publicitario

Funcionamiento del código

Primero nos encontramos con un if-else principal. Este es el que contiene la regla principal.

if numero >= 0:
    . . . 
else: 
    . . .

¿Es numero mayor o igual a 0?

Si lo es (True), entra en la estructura con los dos primeros if anidados:

    if numero == 0: 
    print("El número es cero.")
else: 
    print("El número es positivo.")

if numero > 10:
    print("El número es mayor de 10.")
else:
    print("El número no es mayor de 10."

En caso contrario, entra a evaluar el if-else que tiene anidado el else principal:

    if numero < -10:
        print("El número es menor que -10.")
    else:
        print("El número no es menor que -10.")

Ahora, concretemos un poco más en cada if anidado, de forma individual. Empecemos analizando un valor True para el if principal. En ese caso, llegaríamos a evaluar este if anidado:

    if numero == 0:
        print("El número es cero.")
    else: 
        print("El número es positivo.")

Si numero es igual a 0, se imprime "El número es cero.".

Si no lo es, dice que el número es positivo. Si no es 0 y es mayor que 0, no puede ser otra cosa; aquí aplicamos lógica de descarte.

Independientemente de lo que haya salido en el primer if anidado, entramos en la segunda regla anidada. El número positivo o 0, puede ser mayor que 10, o no serlo:

    if numero > 10:
        print("El número es mayor de 10.")
    else:
        print("El número no es mayor de 10.")

Si el número es cero o positivo, también puede ser mayor o menor que 10, pero no ambos a la vez.

Finalmente, analicemos el else principal. En el caso de que numero no sea mayor o igual a cero, nos queda por descarte un valor negativo. Eso es lo que contempla el else principal:

else: 
    print("El número es negativo.")
    # otro if anidado
    if numero < -10:
        print("El número es menor que -10.")
    else:
        print("El número no es menor que -10.")

Si entra en el else principal, el valor es negativo; por lo tanto, se imprime "El número es negativo.".

Por otro lado, con el if anidado se evalúa si el valor negativo es menor que -10 o no.

Si no has entendido todos los pasos de este ejemplo, analízalo con calma y dibuja un diagrama que muestre los posibles caminos de cada condicional.

Bucles con continue

Con continue, vamos a omitir ciertas iteraciones del bucle, basándonos cierta condición. Esto quiere decir, que vamos a tener que utilizar condicionales dentro de los bucles.

continue es una de las palabras reservadas de Python.

La palabra continue significa en español continuar.

El siguiente código muestra un ejemplo del uso de continue:

colores = ["rojo", "azul", "verde", "amarillo"]
print("---LISTADO DE COLORES---")

for color in colores:
    if color == "azul" or color == "verde":
        continue # omite una iteración

    # Si no entra en el if, se imprime el valor iterado
    print(f"-Color {color}.")

---LISTADO DE COLORES---
-Color rojo.
-Color amarillo.

Espacio publicitario

En este caso, según una condición con un condicional if, estoy haciendo que el bucle omita ciertas iteraciones:

• Iteración 1: - Color rojo.
• Iteración 2 (se omite): - Color azul.
• Iteración 3 (se omite): - Color verde.
• Iteración 4: - Color amarillo.

El condicional if se ejecuta solo si se cumple su expresión. Entonces, eso quiere decir que este continue, solo se va a ejecutar si el valor del iterador color es igual a "azul" o es igual a "verde", según la condición especificada.

Si se ejecuta el continue, finaliza la iteración actual del bucle, pero no su ejecución completa. Es decir, omite la iteración actual.

Por este motivo, el print() del final, ya no se ejecuta en dicha iteración, puesto que está después del condicional.

El resto de veces, cuando no se cumple la expresión del if, este continue es ignorado, ya que está dentro del if.

En esos casos, sencillamente ejecuta el código de esa iteración (print() del bucle), y vuelve a empezar.

Fíjate bien en el print(). Este está indentado dentro del bloque del bucle for y no pertenece al bloque de código del if.

En resumen, el bucle for del ejemplo está diseñado para que itere todos los elementos de la lista y muestre una frase con ellos. Sin embargo, con el condicional if, controlamos qué iteraciones queremos que se ejecuten y cuáles no, todo basándose en una regla.

Fallo de flujo de ejecución

En estos casos, es muy fácil que cometas un fallo con el flujo de ejecución. Mira lo que pasa por cambiar el orden de los elementos en el bucle:

colores = ["rojo", "azul", "verde", "amarillo"]
print("---LISTADO DE COLORES---")

for color in colores:
    print(f"-Color {color}.")
    
    if color == "azul" or color == "verde":
        continue # omite una iteración

---LISTADO DE COLORES---
-Color rojo.
-Color azul.
-Color verde.
-Color amarillo.

Por escribir el print() antes de la regla del if, estoy haciendo que el continue, aunque se ejecute ciertas veces, no tenga el efecto esperado. Estamos ante otro fallo de lógica de programación:

• Al empezar el bucle imprime el valor rojo.
• Después de imprimir, comprueba si el valor es igual a azul o a verde. No lo es, así que el continue no se ejecuta.
• Se imprime el color azul.
• Se comprueba si se cumple la expresión del if. Se cumple. Se ejecuta el continue y finaliza la iteración actual.
• Se imprime el valor verde.
• Se comprueba la condición del if. Se vuelve a cumplir. Finaliza la iteración actual.
• Se imprime el valor amarillo.
• La condición del if no se cumple, así que no se ejecuta.

Como puedes ver, el problema está en que con este orden, se ejecuta primero el código del bucle, y después se aplica la regla. Esta regla ya no sirve, puesto que para cuando se aplica, ya es tarde, la tarea que no se debía ejecutar (print() en este ejemplo), se ha ejecutado antes de poder aplicar la acción de la regla establecida (continue en este ejemplo).

Bucles con break

Con break, cuando se ejecuta dentro de un bucle, se rompe la ejecución completa de este, y salimos de él. No se ejecutarán el resto de iteraciones que pudiera haber.

break es una de las palabras reservadas de Python.

La palabra break significa romper en español.

Con el uso de continue, se “saltaba” solo una iteración. En cambio, en el momento en el que se ejecuta la sentencia break, se “rompen” todas las iteraciones restantes.

Espacio publicitario

A continuación, tienes un ejemplo de uso:

colores = ["rojo", "azul", "verde", "amarillo"]

print("---LISTADO DE COLORES---")

for color in colores:
    # Condición para romper la ejecución
    if color == "azul":
        break # Finaliza el bucle antes de tiempo

    # Si no entra en el if, se imprime el valor iterado
    print(f"-Color {color}.")

---LISTADO DE COLORES---
-Color rojo.

El bucle de este ejemplo, está diseñado para ejecutar cuatro iteraciones, las de la lista colores. Sin embargo, se ejecuta solo hasta la segunda, debido al uso de break.

La segunda iteración, no llega a terminar completamente (no se ejecuta el print()), debido a la ejecución del break, que está antes en el flujo de ejecución.

En este ejemplo, las iteraciones ocurren de la siguiente manera:

• Iteración 1: - Color rojo.
• Iteración 2: Se finaliza el bucle (no llega al print() para imprimir la frase “- Color azul.”). Esto debido a que se cumple la condición del if, ejecutando la sentencia break.

Utilizar continue y break, depende de las necesidades de cada caso.

Imagina que tienes una lista con miles de datos, y quieres hacer algo con ellos. Gracias a continue, puedes omitir procesar algunos de estos, y con break, hacer que dejen de procesarse basándose en ciertas condiciones.

A medida que avances en tu aprendizaje, podrás ver muchos usos prácticos para estas dos palabras reservadas de Python.

El bucle while

El bucle while es una estructura de control de flujo, que permite repetir una serie de instrucciones mientras se cumpla determinada condición.

Este bucle cuenta con una sintaxis bastante diferente a la del bucle for.

La palabra while significa en español mientras.

Diagrama de flujo del bucle while

Este diagrama, muestra de forma simplificada la forma en que funciona el bucle while.

Se evalúa una expresión. Mientras (while) esta sea verdadera, se ejecuta su bloque de código. Una vez deje de cumplirse, se termina su ejecución, continuando con el resto del programa (si lo hubiera).

Sintaxis del bucle while

A continuación, tienes la sintaxis del bucle while:

variable_iteradora = valor_inicial

while expresión_de_salida(condición):
    # Bloque de código

    # Paso (incremento/decremento)

En el bucle for, normalmente lo tenemos todo “recogido” dentro del propio bucle. En cambio, en el bucle while, la variable iteradora está fuera de él. Además, hay algo conocido como “paso”, dentro del bucle.

En la parte del paso utilizaremos los operadores de incremento o decremento que vimos anteriormente, con el fin de variar el valor de la variable iteradora, y no crear bucles infinitos por accidente.

Espacio publicitario

¿Cuándo usar for y cuándo while?

En general, se recomienda usar el bucle for cuando la secuencia de iteración es conocida de antemano (bucle determinado). Por ejemplo, si queremos crear un rango de números del 0 al 9, sabemos cuántas veces se va a ejecutar el bucle antes de ejecutar el programa.

El bucle while, normalmente se utiliza cuando la secuencia de iteración no es conocida de antemano (bucle indeterminado). Por ejemplo, si queremos iterar sobre un conjunto de datos hasta que encontremos un valor concreto.

A continuación, tienes algunos ejemplos específicos de cuándo podrías usar cada bucle:

Bucle for:

• Imprimir los números del 1 al 5.
• Recorrer una lista o tupla desde el primer elemento, hasta el último.
• Iterar sobre un archivo.

Bucle while:

• Verificar si un usuario ha ingresado una contraseña correcta.
• Buscar un elemento concreto en una lista.
• Repetir una acción hasta que se cumpla una condición.
• Crear un bucle while True.

Bucle while con incremento y decremento

Empecemos con un bucle while con incremento.

# Variable para el bucle
i = 1

# Bucle while
while i < 5:
    print(f"El valor del bucle es: {i}.")
    i += 1

El valor del bucle es: 1.
El valor del bucle es: 2.
El valor del bucle es: 3.
El valor del bucle es: 4.

En este caso, la inicialización de la variable de control o iteradora va fuera del bucle (i). Le damos el valor de inicio que queramos. Por ejemplo 1.

i = 1

En la declaración del bucle se pone la condición de salida:

i < 5

La condición de salida es simplemente una expresión booleana, que hace que finalice o se salga del bucle cuando esta no se cumple.

Podríamos describir este funcionamiento en la siguiente frase: “Ejecuta este bucle mientras esta condición de salida sea verdadera (True)”. De ahí viene el nombre de “mientras” (while).

Finalmente, cuando la condición de salida sea False, se detiene la ejecución del bucle.

En la condición de salida, se especifica que se ejecute el bucle mientras el valor de la variable iteradora sea menor que 5, o lo que es lo mismo, hasta que valga 4.

Para hacer que la condición de salida se convierta en False en algún momento y el bucle deje de ejecutarse, necesitamos tener un sistema de variación del valor de la variable iteradora. Este sistema no es más que un simple incremento o un decremento. El denominado como “paso”.

El incremento o decremento, se especificará en cualquier parte del bloque de código. Puedes ponerlo en su primera línea o en cualquier otra. Dependiendo de donde lo pongas, va a cambiar la forma en que el bucle se ejecuta.

En el código del ejemplo, se utiliza un incremento de 1 con el operador de asignación de suma: i += 1.

Con el fin de que puedas analizar con detenimiento la forma en que funcionan sus iteraciones, te dejo un listado completo con las que se corresponden a la ejecución del código del ejemplo anterior:

1. Iteración:
1. Valor del iterador 'i': 1
2. Comprueba la condición: 1 < 5 (True)
3. Imprime: "El valor del bucle es: 1."
4. Incrementa el iterador 'i': i += 1 = 2
2. Iteración:
1. Valor del iterador 'i': 2
2. Comprueba la condición: 2 < 5 (True)
3. Imprime: "El valor del bucle es: 2."
4. Incrementa el iterador 'i': i += 1 = 3
3. Iteración:
1. Valor del iterador 'i': 3
2. Comprueba la condición: 3 < 5 (True)
3. Imprime: "El valor del bucle es: 3."
4. Incrementa el iterador 'i': i += 1 = 4
4. Iteración:
1. Valor del iterador 'i': 4
2. Comprueba la condición: 4 < 5 (True)
3. Imprime: "El valor del bucle es: 4."
4. Incrementa el iterador 'i': i += 1 = 5
5. Iteración:
1. Valor del iterador 'i': 5
2. Comprueba la condición: 5 < 5 (False)
3. Sale del bucle while True, ya que la condición es False.

A continuación prueba el mismo código, pero con un decremento. En este caso, la expresión de salida tiene que ir al revés. En el siguiente ejemplo, el iterador empieza por 10 y la expresión de salida indica que se ejecute el bucle mientras que i siga siendo mayor que 6.

# Iterador
i = 10

# Bucle while
while i > 6:
    print(f"El valor del bucle es: {i}.")
    i -= 1

El valor del bucle es: 10.
El valor del bucle es: 9.
El valor del bucle es: 8.
El valor del bucle es: 7.

Espacio publicitario

Posición del paso en el bucle

La posición del incremento o decremento del bucle es importante. Para demostrártelo, veamos el siguiente ejemplo:

i = 1

while i < 5:
    print(f"El valor del bucle es: {i}.")
    i += 1

El valor del bucle es: 1.
El valor del bucle es: 2.
El valor del bucle es: 3.
El valor del bucle es: 4.

En este ejemplo, el incremento está después del código (print() en el ejemplo).

Al empezar con el bucle, se comprueba primero que el valor del iterador sea menor que 5. Si esto evalúa como True, se ejecuta el bloque de código, imprime la frase, y luego incrementa el iterador en 1. Ahí es donde quiero que prestes atención, en “luego incrementa el iterador en 1”.

Si colocamos el incremento antes del código, la cosa cambia:

i = 1

while i < 5:
    i += 1
    print(f"El valor del bucle es: {i}.")

El valor del bucle es: 2.
El valor del bucle es: 3.
El valor del bucle es: 4.
El valor del bucle es: 5.

Se imprime desde el valor 2 hasta el 5.

¿Por qué se ejecuta diferente?

Con el incremento al final del código, el bucle imprimía los valores del 1 al 4. Esta vez, hace las mismas iteraciones, pero del 2 al 5.

Inicialmente, el iterador vale 1. Se comprueba la condición del bucle (i < 5(True)). Esta se cumple. Luego, lo primero que hace, es incrementar el valor en 1, antes de imprimir el mensaje. Por eso, para cuando se imprime, ya vale 2.

En la última iteración, cuando i vale 4, se incrementa su valor en 1, y para cuando se imprime, ya vale 5. La próxima vez que compruebe la expresión de salida, no se va a cumplir, puesto que el iterador ya vale 5.

Bucles infinitos

También es importante destacar, que es posible hacer por error un bucle “infinito”. Esto significa, que el bucle se repetirá una y otra vez, y nunca se detendrá.

El que ocurra esto, puede ser un problema grave, ya que puede causar que el programa se bloquee, o utilice en exceso recursos del sistema.

Es necesario tener cuidado al escribir bucles. Hay que asegurarse de que siempre se cumple la condición de finalización del bucle, y que lo hace de forma apropiada.

No obstante, también hay que decir que muchas veces necesitarás crear bucles infinitos a propósito, por ejemplo, para mantener la ventana de un programa con interfaz gráfica activa (en ejecución indefinida). Este bucle infinito deberá estar controlado en todo momento, si no lo controlas correctamente, harás que tu programa funcione mal o no funcione directamente. Obtendrás resultados inesperados.

El bucle While True

Python, al menos de momento (seguramente nunca se incluya), no tiene bucle do while (un tipo de bucle que hay en la mayoría de lenguajes de programación). Sin embargo, es posible emular su comportamiento.

Esta emulación la vamos a realizar con un bucle while, dándole una condición de salida True.

Mediante el valor booleano True en la condición del bucle while, estaremos generando una condición “infinita”, ya que si siempre es True, siempre se ejecutará.

while True:

Ejecuta el siguiente código, e introduce en la consola el número que quieras:

numero = int(input("Ingrese un número: "))

while True:
    print(f"El número ingresado es: {numero}.")
    numero += 1

Ejecución infinita...

Por supuesto, no te va a salir ese mensaje en la consola. Solo lo pongo para representar una ejecución infinita, sin crear una página infinita.

Si dejamos el bucle así, va a empezar a imprimir desde el valor que pongas en la consola, y lo irá incrementando infinitamente de 1 en 1.

Tendrás que cerrar la consola para parar su ejecución, o bien, pulsar la combinación de teclas CTRL + C.

Por lo tanto, necesitamos un elemento que “rompa” la ejecución del bucle en algún momento.

Pues bien, es aquí donde el bucle va a llevar realmente la condición de salida. Lo haremos con un condicional if dentro del bloque de código del propio bucle.

Espacio publicitario

Diagrama de flujo del bucle while True

En el siguiente diagrama de flujo, puedes apreciar de qué forma funciona el flujo de ejecución de un bucle While True, con una condición de salida (if).

Primero, se ejecuta el bucle sí o sí. Esto hace que se ejecute el código al menos una vez, dado que inicialmente, no se encuentra sujeto a una condición.

Después, puedes apreciar que se ejecuta el condicional if, con una condición: si la condición no se cumple, el bucle se sigue ejecutando. En cambio, si la condición se cumple, se termina la ejecución del bucle, gracias a incluir una sentencia break en su bloque de código.

Veamos un ejemplo práctico:

numero = int(input("Ingrese un número: "))

while True:
    # Mostramos el valor de numero
    print(f"El número ingresado es: {numero}.")

    # Incrementa el iterador numero en 1
    numero += 1

    # Condición de salida
    if numero >= 5:
        print("Bucle finalizado.")
        break # Detiene el bucle

Por ejemplo, pongo un 3 en la consola:

Ingrese un número: 3
El número ingresado es: 3.
El número ingresado es: 4.
Bucle finalizado.

Y ahora, ¿qué ocurre si escribo un valor que desde el principio hace que no se cumpla la condición del if?

Con el valor anterior, la condición del bucle, se cumplía y se ejecutaba con normalidad, pero si le pongo un valor que no la cumpla desde el principio, me da un resultado como este:

Ingrese un número: 7
El número ingresado es: 7.
Bucle finalizado.

Lo que está ocurriendo, es lo siguiente:

1. Se introduce el valor para la variable numero.
2. Se entra en el bucle “infinito” con ese valor True, que tiene el while.
3. Se imprime el valor de numero (7 en el ejemplo).
4. Se evalúa la expresión del if.
5. Puesto que esta se cumple (numero >= 5), se ejecuta el break, que lo que hace es detener el bucle inmediatamente.

Con todo esto, con los ejemplos del bucle while True, hemos emulado el comportamiento de un bucle do while.

El término do while, se puede traducir al español como hacer mientras.

Bloque else con bucles

En los bucles, al igual que con el condicional if, también podemos hacer uso de un bloque else. Este se va a ejecutar en el momento en el que el bloque del bucle, evalúe como False.

En el siguiente código, puedes ver un ejemplo de uso:

for i in range(5):
    print(f"El valor del bucle es: {i}.")
else:
    print("Frase del bloque else.")

El valor del bucle es: 0.
El valor del bucle es: 1.
El valor del bucle es: 2.
El valor del bucle es: 3.
El valor del bucle es: 4.
Frase del bloque else.

En este ejemplo, se ejecuta el bloque del bucle for con normalidad, pero luego también se ejecuta el bloque else, que no lo hace hasta que la expresión del for se vuelve False. Es decir, cuando el bucle ya no se va a ejecutar más.

Espacio publicitario

En el bucle while, también es posible usar el bloque else. El funcionamiento es el mismo que con for:

numero = int(input("Ingrese un número: "))

while numero < 5:
    print(f"El número ingresado es: {numero}.")
    numero += 1
else:
    print("Código desde el bloque else.")

Si el usuario pone un 2 en la consola, se ejecuta con normalidad, y al acabar ejecuta el else:

Ingrese un número: 2
El número ingresado es: 2.
El número ingresado es: 3.
El número ingresado es: 4.
Código desde el bloque else.

En cambio, si escribe un valor que no cumple la condición desde el principio, no se ejecuta el código del while, pero se ejecuta el bloque else:

Ingrese un número: 7
Código desde el bloque else.

Iterando sobre múltiples secuencias

Con los bucles es posible iterar sobre más de una secuencia en cada paso de ejecución del bucle. Esto es posible gracias a poder especificar más de una variable iteradora a la vez. La sintaxis es la siguiente:

for variable_a, variable_b, variable_n in iterable:
    #Código del bucle

Esto se puede utilizar para muchas cosas, por ejemplo, para iterar un diccionario con sus claves y valores.

Iterar un diccionario

Gracias al método de diccionario llamado items(), podemos obtener un objeto de tipo dict_items, con una lista con tuplas dentro.

Estas tuplas llevan cada par de clave-valor del diccionario:

camiseta = {
    "color" : "rojo",
    "talla" : "L",
    "precio" : 100,
    "unidades" : 10
}

print(camiseta.items())

dict_items([('color', 'rojo'), ('talla', 'L'), ('precio', 100), ('unidades', 10)])

La lista que contiene todas estas tuplas es un iterable de Python, por lo tanto, podemos iterarla:

for i in camiseta.items():
    print(i)

('color', 'rojo')
('talla', 'L')
('precio', 100)
('unidades', 10)

Con esto, recibimos cada tupla con el par clave-valor.

Si quieres iterar a la vez, estos pares, puedes utilizar un segundo nivel de iteración, con una segunda variable iteradora:

for i, j in camiseta.items():
    print(i, j)

color rojo
talla L
precio 100
unidades 10

Con esto, obtenemos con la variable i las claves (color, talla, precio, unidades), y con la variable j, los valores ("rojo", "L", 100, 10).

Entonces, podemos hacer esto más semántico:

for clave, valor in camiseta.items():
    print(f"- {clave.capitalize()}: {valor}.")

- Color: rojo.
- Talla: L.
- Precio: 100.
- Unidades: 10.

Ejemplos de uso, hay una infinidad, los irás viendo con el tiempo.

Elementos se dice en inglés items. keys significa en español, claves. values significa valores.

Espacio publicitario

Espacio publicitario

Ejercicios de Python para resolver

59. ¿Puedes encontrar algún fallo en la indentación del siguiente código? Si es así, arréglalo.

edad = 18

if edad >= 18:
print("Eres mayor de edad.")

edad = 18

if edad >= 18:
    print("Eres mayor de edad.")

El operador módulo nos permite devolver como resultado, el resto de una división. Entre las muchas posibilidades que tiene dicho operador, podemos crear un pequeño programa que calcule si un número introducido en la consola, es par o impar; eso es lo que vamos a construir en los siguientes ejercicios.

60. Crea una variable llamada numero, que permita introducir un valor en la consola.

numero = input("Introduzca un número entero:")

61. Haz que la entrada de datos creada en la variable numero, se convierta automáticamente a tipo de dato int.

numero = int(input("Introduzca un número entero:"))
                        

62. Ahora, aplica el siguiente cálculo a un condicional, mediante los bloques if-else (no pongas ningún elif):

numero % 2 == 0

Para que la respuesta en la consola sea coherente, en los bloques if y else, pon estos dos print(), cada uno donde le corresponda:

print("El número es par.")
print("El número es impar.")

El cálculo de este ejercicio divide por dos el valor introducido en la consola. Si el valor del resto de esa división, hecha con el operador módulo, es igual a 0, se cumple la condición, si no, es False.

Para los siguientes ejercicios, crea varios bucles for.

Se te indicarán los valores para los parámetros de la función range() de cada bucle. Con esos valores, tendrás que construirlos.

La sintaxis de range() es la siguiente:

	range(start, stop, step)

El parámetro start representa el valor de inicio, stop el de final y step el paso (incremento/decremento).

En cada iteración, utiliza este print(), para ver el valor en la consola:

print(f"El valor del bucle es: {i}.")

Te pongo un ejercicio resuelto como pista de lo que tienes que hacer:

Crea un bucle con un inicio de 20, y con final de 25:

for i in range(20, 25):
    print(f"El valor del bucle es: {i}.")

numero = int(input("Introduzca un número entero:"))

if numero % 2 == 0:
    print("El número es par.")
else:
    print("El número es impar.")

2 2 2 2 2 = 10
resto = 0

2 2 2 = 6
resto = 1

numero = int(input("Introduzca un número entero:"))

resto = numero % 2

if resto == 0:
    print("El número es par.")
    print(f"Resto: {resto}.")
else:
    print("El número es impar.")
    print(f"Resto: {resto}.")

Espacio publicitario

63. El primer bucle solo especifica el valor del parámetro final. El valor es 7.

for i in range(7):
    print(f"El valor del bucle es: {i}.")

El valor del bucle es: 0.
El valor del bucle es: 1.
El valor del bucle es: 2.
El valor del bucle es: 3.
El valor del bucle es: 4.
El valor del bucle es: 5.
El valor del bucle es: 6.

64. Crea un bucle for, que ejecute esto en la consola:

El valor del bucle es: 0.
El valor del bucle es: 10.
El valor del bucle es: 20.
El valor del bucle es: 30.
El valor del bucle es: 40.
El valor del bucle es: 50.
El valor del bucle es: 60.
El valor del bucle es: 70.
El valor del bucle es: 80.
El valor del bucle es: 90.

Si utilizas el parámetro de paso, el argumento para el parámetro de inicio, es obligatorio.

for i in range(0,100,10):
    print(f"El valor del bucle es: {i}.")

El valor del bucle es: 0.
El valor del bucle es: 10.
El valor del bucle es: 20.
El valor del bucle es: 30.
El valor del bucle es: 40.
El valor del bucle es: 50.
El valor del bucle es: 60.
El valor del bucle es: 70.
El valor del bucle es: 80.
El valor del bucle es: 90.

65. Los valores del rango van desde el valor 50 (inicio), hasta el -10 (final). El bucle se tiene que decrementar en -5.

for i in range(50,-10,-5):
    print(f"El valor del bucle es: {i}.")

El valor del bucle es: 50.
El valor del bucle es: 45.
El valor del bucle es: 40.
El valor del bucle es: 35.
El valor del bucle es: 30.
El valor del bucle es: 25.
El valor del bucle es: 20.
El valor del bucle es: 15.
El valor del bucle es: 10.
El valor del bucle es: 5.
El valor del bucle es: 0.
El valor del bucle es: -5.

66. Sin ejecutar el siguiente bucle. ¿Cuántas veces crees que se va a iterar?

for i in range(50,-150):
    print(f"El valor del bucle es: {i}.")

67. Vamos a crear un pequeño buscador con el operador in. Para ello, tendrás que ir siguiendo los pasos que verás a continuación:

1. Lista de animales:
   1. Elefante
   2. Ballena
   3. Cebra
   4. Serpiente
   5. Rana
   6. Perro
   7. Caballo
   8. Vaca
   9. Oso
2. Crea una entrada de datos en la consola, para poder buscar lo que te pida.
3. Crea un condicional que evalúe si el valor está en la lista.
   • Si está, que diga en la consola, que el animal está en la lista.
   • Si no, que diga que no está.

Recuerda, que el operador in, devuelve un valor booleano. Utiliza los bloques correctos del condicional if, para tratar estos datos.

# Secuencia sobre la que buscar
animales = ["Elefante", "Ballena", "Cebra", "Serpiente", "Rana", "Perro", "Caballo", "Vaca", "Oso"]

# Entrada-buscador en la consola
buscar = input("Escribe un animal y te diré si está en la lista: ")

# Condicional para tomar una decisión lógica
if buscar in animales:
    print(f"{buscar} está en la lista.")
else:
    print(f"{buscar} no está en la lista.")

68. Continúa con el código del ejercicio anterior. Si no lo has conseguido solucionar, utiliza el de las soluciones.

Hay que mejorar el buscador, hacer que independientemente de lo que busque el usuario, si lo hace en mayúsculas o en minúsculas, la búsqueda siempre se realice con todos los elementos, con la primera letra en mayúscula.

Por ejemplo, en la consola escribo “ELEFANTE” o “elefante”, que se procese en el programa como “Elefante”.

Recuerda, los métodos de las cadenas de caracteres. Intenta aplicar uno de ellos en el lugar correcto. Si no lo consigues, ves a ver cómo se hace en las soluciones.

Estos métodos se pueden aplicar a str con un punto: str.método().

# Secuencia sobre la que buscar
animales = ["Elefante", "Ballena", "Cebra", "Serpiente", "Rana", "Perro", "Caballo", "Vaca", "Oso"]

# Entrada para el buscador
buscar = input("Escribe un animal y te diré si está en la lista: ").capitalize()

# Condicional para tomar una decisión lógica
if buscar in animales:
    print(f"{buscar} está en la lista.")
else:
    print(f"{buscar} no está en la lista.")

# Secuencia sobre la que buscar
animales = ["Elefante", "Ballena", "Cebra", "Serpiente", "Rana", "Perro", "Caballo", "Vaca", "Oso"]

# Entrada para el buscador
buscar = input("Escribe un animal y te diré si está en la lista: ").capitalize()

print(buscar)

Escribe un animal y te diré si está en la lista: ELEFANTE
Elefante

Espacio publicitario

69. Itera con un bucle for el siguiente conjunto (set):

animales = {"Elefante", "Ballena", "Cebra", "Serpiente", "Rana", "Perro", "Caballo", "Vaca", "Oso"}

Observa lo que ocurre cada vez que vuelves a ejecutar el código.

animales = {"Elefante", "Ballena", "Cebra", "Serpiente", "Rana", "Perro", "Caballo", "Vaca", "Oso"}

for animal in animales:
    print(f"Esta vez el animal es {animal}.")

Esta vez el animal es Rana.
Esta vez el animal es Perro.
Esta vez el animal es Serpiente.
Esta vez el animal es Caballo.
Esta vez el animal es Cebra.
Esta vez el animal es Vaca.
Esta vez el animal es Oso.
Esta vez el animal es Ballena.
Esta vez el animal es Elefante.

70. Los valores de los animales del ejercicio anterior, salen con la primera letra en mayúscula. Esto hace que la frase creada sea incorrecta.

Por ejemplo:

Esta vez el animal es Perro.

Haz que el bucle procese así las frases en la consola:

Esta vez el animal es perro.

Una vez más utiliza en el lugar adecuado, el método de cadena adecuado. Piensa sobre qué aplicarlo. Ves haciendo pruebas.

animales = {"Elefante", "Ballena", "Cebra", "Serpiente", "Rana", "Perro", "Caballo", "Vaca", "Oso"}

for animal in animales:
    print(f"Esta vez el animal es {animal.lower()}.")

Esta vez el animal es ballena.
Esta vez el animal es serpiente.
Esta vez el animal es oso.
Esta vez el animal es elefante.
Esta vez el animal es cebra.
Esta vez el animal es caballo.
Esta vez el animal es rana.
Esta vez el animal es vaca.
Esta vez el animal es perro.

Utiliza esta lista para realizar los siguientes ejercicios:

numeros = [5, 12, 34, 7, 19, 25, 8, 3, 16, 22, 100]

71. Crea un bucle for que itere la lista. Se tienen que imprimir todos los valores en la consola, excepto el valor 19, el 3 y el 22.

numeros = [5, 12, 34, 7, 19, 25, 8, 3, 16, 22, 100]

for numero in numeros:
    if numero == 19 or numero == 3 or numero == 22:
        continue
    else:
        print(numero)

5
12
34
7
25
8
16
100

numeros = [5, 12, 34, 7, 19, 25, 8, 3, 16, 22, 100]

for numero in numeros:
    if numero not in [19, 3, 22]:
        print(numero)

72. Crea un bucle for que itere la lista. Se tienen que imprimir todos los valores en la consola, excepto los valores superiores a 15.

numeros = [5, 12, 34, 7, 19, 25, 8, 3, 16, 22, 100]

for numero in numeros:
    if numero > 15:
        continue
    else:
        print(numero)

numeros = [5, 12, 34, 7, 19, 25, 8, 3, 16, 22, 100]

for numero in numeros:
    if numero < 15:
        print(numero)

5
12
7
8
3

73. Crea un bucle for que itere la lista. Se tienen que imprimir todos los valores en la consola, excepto los valores inferiores o iguales a 16.

Deberás avisar con un mensaje en la consola, cada vez que se omita un valor.

Utiliza el formateo de cadenas (f"") para mostrar el valor omitido, con un mensaje como este:

Número 5 omitido.

numeros = [5, 12, 34, 7, 19, 25, 8, 3, 16, 22, 100]

for numero in numeros:
    if numero <= 16:
        print(f"Número {numero} omitido.")
        continue
    else:
        print(numero)

Número 5 omitido.
Número 12 omitido.
34
Número 7 omitido.
19
25
Número 8 omitido.
Número 3 omitido.
Número 16 omitido.
22
100

74. Crea un bucle for que itere la lista. Se tiene que terminar de ejecutar, cuando se encuentre un valor inferior a 5.

numeros = [5, 12, 34, 7, 19, 25, 8, 3, 16, 22, 100]

for numero in numeros:
    if numero < 5:
        break
    else:
        print(numero)

5
12
34
7
19
25
8

75. Crea un bucle for que itere la lista. Se tiene que terminar de ejecutar cuando se encuentre un valor igual a 25. Además, tendrás que avisar en la consola, de que el bucle se ha terminado de ejecutar antes de tiempo.

numeros = [5, 12, 34, 7, 19, 25, 8, 3, 16, 22, 100]

for numero in numeros:
    if numero == 25:
        print("El bucle se ha terminado de ejecutar antes de tiempo.")
        break
    else:
        print(numero)

5
12
34
7
19
El bucle se ha terminado de ejecutar antes de tiempo.

Espacio publicitario

76. ¿Puedes hacer que este bucle deje de ejecutarse infinitamente? No importa cómo, ni bajo qué reglas. Lo importante es que se termine en algún momento. Tú decides cómo y cuándo.

while True:
    print("Se ejecuta.")

contador = 0

while True:
    print("Se ejecuta.")
    contador += 1
    if contador == 4:
        break

Se ejecuta.
Se ejecuta.
Se ejecuta.
Se ejecuta.

Mini proyecto - Adivina el número

En este pequeño proyecto, vas a crear un pequeño programa que sea capaz de generar números aleatorios, y que además, puedas jugar a adivinarlos.

Lo he dividido en varios ejercicios para que te sea más fácil de resolver.

77. Crea un bucle while True, que sirva para adivinar un número secreto.

Para hacer esto, primero deberás crear una variable numérica entera (int) y darle un valor cualquiera. Ese será el número secreto.

Dentro del bucle, solicita al usuario que introduzca un valor numérico.

Utiliza un condicional if, para indicar al usuario si ha acertado el número o no.

Si el usuario ha acertado el número, que se le felicite, y se finalice el bucle.

En caso contrario, que se le indique que no es el número correcto, y le vuelva a solicitar el número. Esto lo hará indefinidamente, hasta que lo acierte.

Puede parecer muy complicado, pero es más sencillo de lo que crees.

No te compliques en exceso. Hazlo lo más simple posible. Estos son los elementos que debe tener el programa:

• Una variable con el número secreto.
• Un bucle while True.
• Una variable con un input() dentro del bucle.
• Un condicional if para informar al usuario en cada intento.
• Algo que rompa la ejecución del bucle cuando se adivine el número.

# Número secreto
numero_secreto = 91

while True:
    # Se solicita un número
    intento = int(input("Intenta adivinar el número secreto: (1-100): "))
    
    # Se comprueba si hay acierto
    if intento == numero_secreto:
        print("¡Felicidades! ¡Has adivinado el número secreto!")
        break # Se sale del bucle si hay acierto
    else:
        print("Ese no es el número secreto.")

78. Mejora el código del ejercicio anterior, añadiendo aleatoriedad al número secreto. Para ello, deberás utilizar la función randint().

Esta función forma parte de un módulo de Python llamado random. Para importarlo, deberás añadir este código al principio de tu hoja de código:

from random import randint

Teniendo la línea anterior, puedes utilizar en tu código la función randint(), como cualquier otra.

Esta función tiene la siguiente sintaxis:

randint(a, b)

Los dos valores pasados (a, b) serán valores numéricos enteros. El primero especifica el inicio de un rango, y el segundo, el final.

Intenta aplicar esta solución a tu código. Solo tendrás que modificar el valor fijo de numero_secreto, por la llamada a esta función.

Con esto, consigues un número secreto, que ni tú sabes cuál va a ser, y que siempre será diferente.

from random import randint

# Número secreto aleatorio
numero_secreto = randint(1,100)

while True:
    # Se solicita un número
    intento = int(input("Intenta adivinar el número secreto: (1-100): "))
    
    # Se comprueba si hay acierto
    if intento == numero_secreto:
        print("¡Felicidades! ¡Has adivinado el número secreto!")
        break # Se sale del bucle si hay acierto
    else:
        print("Ese no es el número secreto.")

79. El programa anterior, genera un número aleatorio, pero es muy complicado que un jugador lo acierte si no le damos pistas.

Con el código del ejercicio anterior, crea una forma de avisar al usuario si el valor que acaba de probar en la consola, es mayor o menor que el número aleatorio.

Por supuesto, cuando lo acierte, le dirá que lo ha acertado.

from random import randint

# Número secreto aleatorio
numero_secreto = randint(1,100)

while True:
    # Se solicita un número
    intento = int(input("Intenta adivinar el número secreto: (1-100): "))
    
    # Se comprueba si hay acierto
    if intento == numero_secreto:
        print("¡Felicidades! ¡Has adivinado el número secreto!")
        break # Se sale del bucle si hay acierto
    elif intento > numero_secreto:
        print("El número secreto es menor.")
    elif intento < numero_secreto:
        print("El número secreto es mayor.")

Intenta adivinar el número secreto: (1-100): 10
El número secreto es menor.
Intenta adivinar el número secreto: (1-100): 7
El número secreto es mayor.
Intenta adivinar el número secreto: (1-100): 8
El número secreto es mayor.
Intenta adivinar el número secreto: (1-100): 9
¡Felicidades! ¡Has adivinado el número secreto!

80. Mejora el código anterior añadiendo la siguiente lógica:

Crea en las condiciones de los elif, con operadores lógicos, rangos que limiten el alcance de los números posibles en la expresión.

Por ejemplo:

intento > numero_secreto

Esta expresión contempla cualquier número que sea mayor que el valor puesto en la variable intento.

Entonces, deberías limitar el rango posible, para que la expresión sea verdadera, solo si el valor de intento es mayor que numero_secreto, y que también no sea mayor de 100, o el rango máximo que hayas establecido para el usuario.

Lo mismo con la otra expresión:

intento < numero_secreto

Además, ahora tiene sentido poner un bloque else, que se ejecute en caso de que el valor puesto en la consola, sea mayor o menor que el rango establecido en el juego.

from random import randint

# Número secreto aleatorio
numero_secreto = randint(1,100)

while True:
    # Se solicita un número
    intento = int(input("Intenta adivinar el número secreto: (1-100): "))
    
    # Se comprueba si hay acierto
    if intento == numero_secreto:
        print("¡Felicidades! ¡Has adivinado el número secreto!")
        break # Se sale del bucle si hay acierto
    elif intento > numero_secreto and intento <= 100:
        print("El número secreto es menor.")
    elif intento < numero_secreto and intento >= 1:
        print("El número secreto es mayor.")
    else:
        print("Ese número se sale del rango.")

Intenta adivinar el número secreto: (1-100): 10
El número secreto es mayor.
Intenta adivinar el número secreto: (1-100): 1900
Ese número se sale del rango.
Intenta adivinar el número secreto: (1-100): 80
El número secreto es menor.
Intenta adivinar el número secreto: (1-100): 70
¡Felicidades! ¡Has adivinado el número secreto!

81. Ahora, ¿qué te parece si le añadimos un contador que vaya acumulando todos los intentos del usuario?

Crea un contador en una variable, y utiliza un incremento en el momento adecuado.

Además, quiero que avises después de cada acción, cuantos intentos se han realizado.

El contador empezará con el valor 0:

contador = 0

from random import randint

# Número secreto aleatorio
numero_secreto = randint(1,100)

# Contador de intentos
contador = 0

while True:
    # Se solicita un número
    intento = int(input("Intenta adivinar el número secreto: (1-100): "))
    
    # Se comprueba si hay acierto
    if intento == numero_secreto:
        print("¡Felicidades! ¡Has adivinado el número secreto!")
        contador += 1
        print(f"Has utilizado {contador} intento/s.")
        break # Se sale del bucle si hay acierto
    elif intento > numero_secreto and intento <= 100:
        print("El número secreto es menor.")
        contador += 1
        print(f"Has utilizado {contador} intento/s.")
    elif intento < numero_secreto and intento >= 1:
        print("El número secreto es mayor.")
        contador += 1
        print(f"Has utilizado {contador} intento/s.")
    else:
        print("Ese número se sale del rango.")
        contador += 1
        print(f"Has utilizado {contador} intento/s.")

82. Para terminar, hagamos el juego más desafiante todavía. Haz que termine si llegamos a utilizar 7 intentos.

La variable contador será la clave para “romper” el juego, llegados al séptimo intento.

Además, quiero que en caso de que el jugador pierda (agote los intentos), se le indique en la consola cuál era el número secreto.

La salida te tiene que quedar algo como esto:

Intenta adivinar el número secreto: (1-100): 1500
Ese número se sale del rango.
Has utilizado 1 intento/s.
Intenta adivinar el número secreto: (1-100): 75
El número secreto es menor.
Has utilizado 2 intento/s.
Intenta adivinar el número secreto: (1-100): 60
El número secreto es menor.
Has utilizado 3 intento/s.
Intenta adivinar el número secreto: (1-100): 55
El número secreto es menor.
Has utilizado 4 intento/s.
Intenta adivinar el número secreto: (1-100): 52
El número secreto es menor.
Has utilizado 5 intento/s.
Intenta adivinar el número secreto: (1-100): 50
El número secreto es menor.
Has utilizado 6 intento/s.
Intenta adivinar el número secreto: (1-100): 30
El número secreto es mayor.
Has utilizado 7 intento/s.
Fin del juego. Intentos agotados.
El número secreto era: 43.

from random import randint

# Número secreto aleatorio
numero_secreto = randint(1,100)

# Contador de intentos
contador = 0

while True:
    # Si se agotan los intentos:
    if contador == 7: # Juego configurado con 7 intentos
        print("Fin del juego. Intentos agotados.")
        print(f"El número secreto era: {numero_secreto}.")
        break
    # Mientras te queden intentos:
    else:
        # Se solicita un número
        intento = int(input("Intenta adivinar el número secreto: (1-100): "))
        # Se comprueba si hay acierto
        if intento == numero_secreto:
            print("¡Felicidades! ¡Has adivinado el número secreto!")
            contador += 1
            print(f"Has utilizado {contador} intento/s.")
            break # Se sale del bucle si hay acierto
        elif intento > numero_secreto and intento <= 100:
            print("El número secreto es menor.")
            contador += 1
            print(f"Has utilizado {contador} intento/s.")
        elif intento < numero_secreto and intento >= 1:
            print("El número secreto es mayor.")
            contador += 1
            print(f"Has utilizado {contador} intento/s.")
        else:
            print("Ese número se sale del rango.")
            contador += 1
            print(f"Has utilizado {contador} intento/s.")

Espacio publicitario

Mini proyecto - Calculadora de tablas de multiplicar

El siguiente mini proyecto trata de crear una calculadora de tablas de multiplicar. En esta calculadora, podrás introducir un número por la consola, y ella sola te calculará e imprimirá toda la tabla completa del número correspondiente, del 0 al 10.

Por ejemplo, si pones un 7, esta será la salida:

7 X 1 = 7
7 X 2 = 14
. . .
7 X 10 = 70

Parte 1: Entrada de valores numéricos

83. Utiliza la función input() para obtener un número de tipo int, introducido por el usuario. Este se almacenará en una variable llamada numero. Dicho número servirá para calcular la tabla de multiplicar.

# Entrada
numero = int(input("Introduce un número entero para ver su tabla de multiplicar: "))

Parte 2: Inicialización de la variable iteradora

84. Establece un valor inicial para la variable iteradora en 1. La variable iteradora se usará para recorrer los números del 1 al 10. Para generar la tabla de multiplicar.

# Variable iteradora
i = 1

Parte 3: Bucle while para generar la tabla de multiplicar

85. Crea un bucle while que se ejecutará mientras el valor de la variable iteradora sea menor o igual a 10.

# Generador de tablas de multiplicar
while i <= 10:
    pass

86. Multiplica el número introducido (variable numero) por el valor actual de la variable iteradora (el valor que dé en cada iteración), para obtener el resultado de la multiplicación, y guárdalo en una variable llamada resultado.

Es decir, tienes que hacer la multiplicación de numero * i, dentro de una variable, en el bucle.

resultado = numero * i

87. Imprime en la consola, la expresión de la tabla de multiplicar, incluyendo el número introducido, el valor actual de la variable iteradora y el resultado de la multiplicación; con una salida como esta:

7 X 1 = 7

 print(numero, "x", i, "=", resultado)

88. Incrementa el valor de la variable iteradora en 1, para pasar al siguiente número en la tabla de multiplicar.

i += 1

# Entrada
numero = int(input("Introduce un número entero para ver su tabla de multiplicar: "))

# Variable iteradora
i = 1

# Generador de tablas de multiplicar
while i <= 10:
    resultado = numero * i
    print(numero, "x", i, "=", resultado)
    i += 1

Introduce un número para calcular su tabla de multiplicar: 7
7 X 1 = 7
7 X 2 = 14
7 X 3 = 21
7 X 4 = 28
7 X 5 = 35
7 X 6 = 42
7 X 7 = 49
7 X 8 = 56
7 X 9 = 63
7 X 10 = 70

Espacio publicitario