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 variableresultado
y otra en elprint()
.
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
hasta65
66
hasta75
76
o más
Recuerda que para que las expresiones con and devuelvan
True
, ambas tienen que serTrue
.
Por ejemplo, si el valor de edad
es
40
, el programa hará las siguientes
evaluaciones:
-
edad < 18
= False -
edad >= 18 and edad <= 65
= Trueand
True = True -
edad > 65 and edad <= 75
= Falseand
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 elseif
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 aif
o aelse
.
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 llamamatch
.
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 comodefecto
, 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 tipostr
. 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*:
Códigos HTTP | Categoría |
---|---|
100, 101, 102 | 1xx |
200, 201, 202, 203 | 2xx |
300, 301, 302, 303 | 3xx |
400, 404, 407 | 4xx |
500, 502, 599 | 5xx |
* 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 llamai
. -
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á comoTrue
mientras se cumpla y comoFalse
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
ywhile
. -
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++
ovariable--
, 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:
-
Creación de la secuencia: Se crea la secuencia
[0, 1, 2, 3, 4]
con la funciónrange(5)
. -
Iteración inicial: Se pasa el primer elemento
(
0
) de la secuencia a la variable iteradorai
. -
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. Esteprint()
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. - 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.
-
Siguiente iteración: La variable iteradora
(
i
) obtiene el segundo valor de la secuencia. - Repetición: Se ejecuta el bloque de código de nuevo.
-
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)
Parámetro | Descripción |
---|---|
inicio (start ) |
Valor opcional. Se
trata de un número entero, que especifica la
posición de inicio. Por defecto, si no se
especifica un valor, es 0 .
|
final /stop
(parada )
|
Valor obligatorio. Se trata de un número entero, que especifica la posición final del rango. |
paso
(incremento-decremento )
(step )
|
Valor opcional. Se
trata de un número entero, que especifica la
cantidad de incremento o decremento. Por defecto,
si no se especifica un valor, es 1 .
|
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
) es0
. -
Se comprueba si el valor
0
está en la secuencia generada por la funciónrange()
(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.
-
El valor de la variable iteradora (
-
Iteración 2:
-
El valor de la variable iteradora (
i
) es1
. -
Se comprueba si el valor
1
está en la secuencia generada por la funciónrange()
(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.
-
El valor de la variable iteradora (
-
Iteración 3:
-
El valor de la variable iteradora (
i
) es2
. -
Se comprueba si el valor
2
está en la secuencia generada por la funciónrange()
(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.
-
El valor de la variable iteradora (
-
Iteración 4:
-
El valor de la variable iteradora (
i
) es3
. -
Se comprueba si el valor
3
está en la secuencia generada por la funciónrange()
(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.
-
El valor de la variable iteradora (
-
Iteración 5:
-
El valor de la variable iteradora (
i
) es4
. -
Se comprueba si el valor
4
está en la secuencia generada por la funciónrange()
(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.
-
El valor de la variable iteradora (
-
Iteración 6 (no procede):
-
El valor de la variable iteradora (
i
) es5
. -
Se comprueba si el valor
5
está en la secuencia generada por la funciónrange()
(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 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 buclefor
y no pertenece al bloque de código delif
.
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 averde
. No lo es, así que elcontinue
no se ejecuta. - Se imprime el color
azul
. -
Se comprueba si se cumple la expresión del
if
. Se cumple. Se ejecuta elcontinue
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 delif
, ejecutando la sentenciabreak
.
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:
- Iteración:
-
Valor del iterador
'i'
:1
-
Comprueba la condición:
1 < 5
(True) -
Imprime:
"El valor del bucle es: 1."
-
Incrementa el iterador
'i'
:i += 1
=2
- Iteración:
-
Valor del iterador
'i'
:2
-
Comprueba la condición:
2 < 5
(True) -
Imprime:
"El valor del bucle es: 2."
-
Incrementa el iterador
'i'
:i += 1
=3
- Iteración:
-
Valor del iterador
'i'
:3
-
Comprueba la condición:
3 < 5
(True) -
Imprime:
"El valor del bucle es: 3."
-
Incrementa el iterador
'i'
:i += 1
=4
- Iteración:
-
Valor del iterador
'i'
:4
-
Comprueba la condición:
4 < 5
(True) -
Imprime:
"El valor del bucle es: 4."
-
Incrementa el iterador
'i'
:i += 1
=5
- Iteración:
-
Valor del iterador
'i'
:5
-
Comprueba la condición:
5 < 5
(False) -
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:
-
Se introduce el valor para la variable
numero
. -
Se entra en el bucle “infinito” con ese valor
True
, que tiene elwhile
. -
Se imprime el valor de
numero
(7
en el ejemplo). - Se evalúa la expresión del
if
. -
Puesto que esta se cumple (
numero >= 5
), se ejecuta elbreak
, 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.")
El único fallo de indentación está en el
print()
, el cual, pertenece al bloque de
código del if
.
Debe quedar así:
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.
Creamos un input()
con una pequeña frase:
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
.
Envolvemos el input()
en la función
predefinida int()
, para que se convierta
el valor introducido a tipo 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, esFalse
.
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 ystep
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 de25
: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.")
Ahora, prueba si funciona poniendo algunos números en la consola.
La explicación es realmente sencilla, sin embargo, requiere de algo de lógica matemática.
Cualquier número entero dividido entre 2
,
solo puede dar de resto, o un 0
, o un
1
.
Si el resto es 0
, quiere decir que el
número es par.
Si el resto es 1
, quiere decir que el
número es impar.
El bloque de código if
evalúa esto mismo.
El resultado de utilizar el operador módulo dividiendo
entre 2
, será uno de esos posibles
valores.
Si el resto de dicha operación es igual a
0
, el if
evalúa como
True
y se ejecuta.
En caso contrario, se ejecutará el código del
else
.
Veamos un ejemplo práctico:
El valor introducido en la consola es 10
.
Con módulo, se divide 10
entre
2
y nos deja el resto. En este caso,
10
se puede fraccionar 5 veces en partes
de 2, por lo que no sobra nada. El resto es
0
.
2 2 2 2 2 = 10
resto = 0
Si el resto es 0
, quiere decir que el
número es par.
Veamos otro ejemplo:
El valor introducido en la consola es 7
.
Con módulo, se divide 7
entre
2
y nos deja el resto. En este caso,
7
se puede fraccionar 3 veces en partes
de 2, por lo que sobra 1
de resto.
2 2 2 = 6
resto = 1
Si el resto es 1
, quiere decir que el
número es impar.
En resumen, si el número introducido es par, se
ejecuta el bloque de código del if
, en
caso contrario, el bloque de código else
.
Por si aun así te cuesta entender la operación, la voy a escribir de otra forma:
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}.")
En este código, se obtiene primero el resto de la
división entre 2
y luego se aplica la
expresión comparativa, para ver si el valor de
resto
es igual a 0
.
Además, aunque es innecesario, te he puesto un par de
print()
extra, para que veas lo que da de
resto en cada caso. Digo innecesario, porqué con
números enteros, la división entre
2
siempre da un resultado de
0
, si es par, y 1
si es
impar.
Espacio publicitario
63. El primer bucle solo especifica el valor del parámetro
final
. El valor es 7
.
Si solo especificamos un valor para el parámetro
final
, el valor de inicio
se
queda por defecto en 0
. Su especificación
es opcional.
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 deinicio
, 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}.")
El bucle no llega a iterarse ninguna vez.
El motivo es que el valor de inicio 50
,
es superior al valor de final -150
.
Entonces, se crea una secuencia vacía, que hace que el
estado del bucle sea False
desde el
principio.
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:
-
Lista de animales:
- Elefante
- Ballena
- Cebra
- Serpiente
- Rana
- Perro
- Caballo
- Vaca
- Oso
- Crea una entrada de datos en la consola, para poder buscar lo que te pida.
-
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 condicionalif
, para tratar estos datos.
- Creamos la lista de animales:
- Creamos la entrada de datos para la consola:
-
Si el valor que tiene la variable
buscar
está en la listaanimales
(True
), que diga que está en la lista, si no (False
), que diga que no lo está:
animales = ["Elefante", "Ballena", "Cebra", "Serpiente", "Rana", "Perro", "Caballo", "Vaca", "Oso"]
buscar = input("Escribe un animal y te diré si está en la lista: ")
if buscar in animales:
print(f"{buscar} está en la lista.")
else:
print(f"{buscar} no está en la lista.")
Aquí tienes el código completo, de las tres partes:
# 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()
.
Se trata de añadirle un capitalize()
al
resultado del input()
, el cual, almacena
un str
en la variable.
Esto hace que aunque le pase un texto, con las mayúsculas o minúsculas, de la forma que sea, siempre se procese el resultado con la primera letra en mayúscula.
# 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.")
Puedes comprobar que funciona, añadiendo un
print()
después de la variable
buscar
:
# 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
Pese a que lo escribo todo en mayúsculas, el método
capitalize()
, lo transforma a como están
los valores literalmente en la lista. Así, en el
buscador (if-else
), los valores coinciden
literalmente, y hace que no le afecte la diferencia de
mayúsculas o minúsculas.
Si en otra situación tienes todos los valores de una
lista completamente en minúsculas, utiliza el método
lower()
, en lugar de
capitalize()
. Usa cada cosa para el
propósito adecuado.
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.
La variable iteradora animal
obtiene,
gracias al operador in
, un valor del
conjunto animales
, cada vez. Eso es lo
que imprime en la consola.
Fíjate en que cada vez que ejecutas el conjunto, el orden de las iteraciones varía, esto es por qué el conjunto no tiene un índice de posiciones. Por ende, el resultado final es aleatorio.
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.
La variable iteradora animal
, obtiene
cada vez un elemento de la lista. Estos elementos son
str
, por lo tanto, a la variable
iteradora se le puede aplicar un método de cadena de
caracteres.
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.
Esto es algo de lógica, pero sé que en ocasiones, es difícil llegar a esa conclusión, u otras sobre programación.
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
.
Este ejercicio se puede hacer de varias formas. Puede ser que lo hayas resuelto de forma parecida a esto:
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)
O quizás ni se parezca a esta forma. Lo importante, es que en la consola se impriman todos los valores no excluidos:
5
12
34
7
25
8
16
100
No obstante, hay formas más “elegantes” de hacer esto,
y ni siquiera necesitaríamos utilizar
continue
:
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)
Por supuesto, no pretendo decirte que deberías haberlo hecho así. Esto te lo pongo para que aprendas nuevas formas de llegar a Roma (de la frase hecha todos los caminos llegan a Roma).
El bucle for
, está igual que en el primer
ejemplo. Preparado para iterar toda la lista.
Dentro, indico en la condición del if
,
que si el valor de numero
(la variable
iteradora) no está en la lista
[19, 3, 22]
, que imprima el valor de la
variable iteradora.
Si el valor está en la lista (False
), no
hace nada, por lo que no hace falta ni usar un
else
, ni un continue
.
Esta es una técnica algo avanzada para el nivel que llevas en este curso. Lo importante es que lo hayas resuelto a tu manera. Ya irás mejorando; tiempo al tiempo.
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
.
Una forma de hacer esto, sería así:
numeros = [5, 12, 34, 7, 19, 25, 8, 3, 16, 22, 100]
for numero in numeros:
if numero > 15:
continue
else:
print(numero)
Otra forma de hacerlo, sin utilizar continue, es la siguiente:
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
En ambos casos, el resultado es el mismo.
En el primer código, se evalúa si el valor es superior
a 15
. Si es así, se salta la iteración
con continue
, en caso contrario, se
imprime el número con el bloque else
.
En el segundo código, se invierte la expresión del
if
. Aquí se dice que si el valor de la
variable iteradora numero
es menor que
15
, que se imprima el valor. Si no, no se
hace nada.
Son formas de lógica perfectamente válidas. Incluso, puede que ingenies otras.
En el primer ejemplo, el código es más explícito. Bajo mi punto de vista, es mejor en cuanto a legibilidad por parte de las personas, ya que especifica de forma explícita si se salta el valor o no.
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.
Una forma de resolverlo, es la siguiente:
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
.
Una posible solución es esta:
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
El bloque if
, no se cumple (su condición)
hasta que se encuentra con un valor inferior a
5
en la lista. En este caso, es cuando
encuentra el valor 3
.
Cada vez que eso no pasa, se sigue imprimiendo el número.
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.
Esta es una posible solución:
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.
En cuanto la expresión del if
evalúa como
True
, se imprime primero la frase
avisando de que se ha terminado de ejecutar el bucle,
y luego se finaliza inmediatamente, con
break
.
Es importante que el print()
venga antes,
ya que si lo pones después, no llegará a ejecutarse.
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.")
Yo lo he hecho de la siguiente forma. Seguramente tu solución sea muy diferente a la mía, debido a la flexibilidad del enunciado.
Gracias al uso de break
, he conseguido
detener el bucle:
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.
Primero creo una variable para almacenar el número secreto.
Después, le doy un valor cualquiera, comprendido entre el rango que le vaya a indicar al usuario en la consola.
A continuación, creo un bucle “infinito”.
Dentro de este, una variable llamada
intento
, para almacenar el valor de cada
intento del usuario.
# 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.")
La expresión del if
es que si coincide el
numero_secreto
con el número del
intento
, que felicite al jugador, y que
rompa la ejecución del bucle.
Mientras no haya una coincidencia, seguirá dejando hacer nuevos intentos, hasta que se acierte el número.
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.
He establecido el rango entre 1
y
100
:
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.")
Ahora, cada vez que se ejecuta tu programa, genera un valor numérico entero en el rango establecido. No sabemos cuál va a ser.
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.
Esta es una posible solución.
He contemplado con condiciones extra, valores mayores o menores en base al número secreto.
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.")
En este caso se puede prescindir de la parte
else
, puesto que mayor o menor,
comprendería cualquier número, y nunca se llegaría a
ejecutar.
Un posible resultado en la consola, puede ser este:
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.
Puedes mejorar el código de esta forma:
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.")
Ahora, nuestro programa es capaz de detectar si el número es mayor o es menor, según el rango establecido, o si el usuario se está saliendo del rango.
Una posible salida en la consola es esta:
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
Gracias a la variable contador
, se hace
posible ir incrementando en cada bloque de código un
valor de conteo.
Con esto, hacemos que el juego sea un poco más desafiante, al evaluar la destreza del jugador, encontrando el número secreto.
En cada bloque de código que se ejecute, se va a sumar
1
al valor de la variable
contador
.
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.
Una posible solución se basa en utilizar una regla
general con un if-else
, la cual, limite
el número de intentos de la siguiente forma:
¿Le quedan intentos al jugador?
-
Sí. Puede seguir intentándolo (
else
). - No. Fin del juego (
if
).
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.")
Por supuesto, puedes configurar en el
if
principal, el número de intentos que
quieres que tenga el jugador, y en
numero_secreto
, el rango de números
posibles.
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.
Simplemente, pedimos en un input()
, que
se introduzca un valor entero, y lo transformamos de
str
a int
:
# 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
Sencillamente, añadimos un valor inicial para la variable iteradora. Este va a servir para empezar a multiplicar por 1 el valor de la entrada del usuario, luego se incrementará y multiplicará por 2, así hasta el 10.
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
Creamos el bucle while
, y le ponemos la
expresión de i <= 10
. Con esto,
haremos que se ejecute hasta que la variable iteradora
valga 10
.
Si quieres que los cálculos se hagan más grandes, por
ejemplo, hasta el 20
. Sin problema.
Hazlo.
Ten en cuenta, que aún no tenemos nada de código en el
while
, así que te saldrá un error en el
programa que utilices para escribir código. Por eso,
he puesto la palabra reservada pass de Python, que
evita esto mismo. En el siguiente ejercicio, la puedes
borrar.
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
Se crea una variable para almacenar los cálculos. Esta
llevará el valor del usuario en la consola (variable
numero
), multiplicado por el valor que
vaya obteniendo la variable iteradora en cada
ejecución.
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)
Si ejecutas esto ahora, te va a salir solo una multiplicación de forma infinita.
Para solucionar esto, hay que actualizar la variable iteradora. Esto lo harás en el siguiente ejercicio.
88. Incrementa el valor de la variable iteradora en
1
, para pasar al siguiente número en la tabla
de multiplicar.
Se incrementa la variable iteradora en uno:
i += 1
Con todo esto, el código completo es el siguiente:
# 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
Voy a poner una tabla cualquiera para darte una posible salida en la consola. Ves probando los resultados introduciendo varios números.
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