Sintaxis de la estructura condicional simple
La estructura condicional simple se utiliza para ejecutar un bloque de código solo si la condición es verdadera. Si la condición es falsa, la estructura condicional finaliza sin ejecutar código alguno y el programa continúa con la siguiente instrucción.
De manera generalizada, la sintaxis de esta estructura de control de flujo condicional es si (condición) entonces … fin si.
si (condición) entonces
# El bloque de código que contiene esta rama de la estructura condicional se ejecuta solo si la condición es verdadera
# Aquí se pueden incluir una o más sentencias
imprimir "La condición es verdadera."
fin si
La palabra clave if
Para tomar decisiones en nuestros programas usando operadores de comparación, necesitaremos usar la palabra clave if en Python. La palabra clave if, al igual que en inglés, nos permite formular preguntas condicionales.
Definición:
if es una palabra clave[^1] (keyword en inglés) en Python. No es una función. En el caso de if, se utiliza para introducir una estructura condicional que permite ejecutar un bloque de código solo si una condición específica se evalúa como verdadera.
Así, la palabra clave if se utiliza para tomar decisiones basadas en el resultado de una expresión booleana. Si la expresión booleana es verdadera, el bloque de código dentro del if se ejecutará. Si la expresión booleana es falsa, el bloque de código dentro del if no se ejecutará.
Básicamente, le decimos a Python:
Interpretación natural de la palabra clave if
"Si la respuesta a esta pregunta es verdadera, ejecuta este código por mí".
Veamos cómo funciona esto en la práctica escribiendo algunos ejemplos:
Escribamos el siguiente código en un archivo llamado comparar.py cuyo objetivo es simplemente comparar valores y tomar decisiones basadas en esos valores:
| comparar.py | |
|---|---|
Supongamos que queremos comparar un par de números enteros ingresados por el usuario, para que podamos tomar decisiones basadas en números cuyos valores no conocemos de antemano.
Este código solicita al usuario que ingrese dos números enteros, que serán almacenados en las variables x e y. Luego, compara estos dos números. Si x es menor que y, imprime el mensaje "x es menor que y". Si x no es menor que y, no se imprime nada.
Veamos esto un poco más en detalle:
- Tenemos dos variables,
xey, cada una de las cuales tiene un valor. Supongamos que queremos tomar una decisión basada en los valores de estas variables. Deberíamos poder comparar estos valores. - vamos a utilizar la palabra clave
if. Y vamos a utilizar alguno de los símbolos matemáticos que vimos anteriormente para plantear la pregunta condicional: sixes menor quey - Si la respuesta a esta pregunta es verdadera, es decir, si
xes menor quey, entonces vamos a imprimir un mensaje en la pantalla que diga "x es menor que y".
Expresiones booleanas
El programa que acabamos de ver nos permite introducir una sintaxis nueva. Cuando nos hacemos la pregunata: si x es menor que y, x es una variable a la izquierda, y es una variable a la derecha y el signo menor < expresa la pregunta matemática. x < y representa lo que se llama técnicamente expresión booleana.
Una expresión booleana, que lleva el nombre del matemático George Boole[^2], es simplemente una pregunta que tiene una respuesta de sí o no, o técnicamente, una respuesta verdadera (True) o falsa (False).
Esto es fundamental porque si solo hay dos respuestas posibles, es muy fácil para para la computadora tomar una decisión: hacer esto o no hacer esto.
Sintaxis de la estructura condicional if
Recordemos la estructura generalizada:
si (condición) entonces
# El bloque de código que contiene esta rama de la estructura condicional se ejecuta solo si la condición es verdadera
# Aquí se pueden incluir una o más sentencias
imprimir "La condición es verdadera."
fin si
¡Para recordar!
En algunos lenguajes de programación las palabras clave then y end if de la estructura if (condición) then … end if son necesarias para indicar el inicio y el fin del bloque de código que se ejecutará si la condición es verdadera. En otros lenguajes, estas palabras son reemplazadas por un par de llaves { … } que delimitan dicho bloque de código.
En Python, no es necesario utilizar then, end if ni las llaves { … }. En su lugar, solamente se utiliza la indentación (tabulación o sangría) para delimitar el bloque de código que se ejecutará si la condición es verdadera.
Por lo tanto, la estructura de un bloque if en Python es la siguiente:
if condición: # La condición es una expresión booleana
# Bloque de código que se ejecuta si la expresión booleana es verdadera
# Aquí se pueden incluir una o más sentencias que se ejecutarán si la condición es verdadera.
# Cada sentencia debe estar indentada con respecto a la línea del if.
# La indentación, obligatoria en Python, generalmente es de 4 espacios o un tabulador.
# Esta línea no está indentada y, por lo tanto, no forma parte del bloque de código del if.
# Es una sentencia independiente que se ejecutará siempre, independientemente de si la condición es verdadera o falsa, cuando finalice la ejecución de la estructura condicional if.
print("Sentencia independiente")
Si conoces otros lenguajes de programación, habrás notado que no hemos escrito ningún paréntesis. De hecho, no son necesarios en Python, al menos en este caso. Además, hemos escrito dos puntos al final de la línea.
Y lo que es aún más importante, en la siguiente línea comenzamos la línea con una sangría (tabulado o indentación), presionando la barra espaciadora cuatro veces o simplemente presionando la tecla Tab una vez, lo que se convertirá automáticamente a lo mismo. Esa sangría es lo que le dice a Python que la línea 5 de nuestro programa, arriba escrito, solo debe ejecutarse si la respuesta a la pregunta de la línea 4 es, de hecho, verdadera. Entonces, si x es menor que y, a partir de esa veracidad es que se imprimirá la frase correspondiente.
Ahora vamos a agregar otras preguntas a nuestro programa que nos permitan tomar decisiones más complejas.
x = int(input("¿Cuál es el valor de x? "))
y = int(input("¿Cuál es el valor de y? "))
if x < y:
print("x es menor que y")
if x > y:
print("x es mayor que y")
if x == y:
print("x es igual a y")
En este caso, hemos agregado dos preguntas más. Si x es mayor que y, se imprimirá "x es mayor que y". Si x es igual a y, se imprimirá "x es igual a y".
Ahora tenemos tres condiciones en nuestro código:
- una que pregunta si x es menor que y,
- otra que pregunta si x es mayor que y,
- y una última que pregunta si x es igual a y.
Vamos a ejecutar este código y observar qué sucede.
En este caso, hemos ingresado 1 para x y 2 para y. Como 1 es menor que 2, se imprime "x es menor que y".
Si ejecutamos el programa nuevamente, pero esta vez ingresamos 2 para x y 1 para y, obtendremos el siguiente resultado:
En este caso, 2 es mayor que 1, por lo que se imprime "x es mayor que y".
Finalmente, si ingresamos el mismo valor para x e y, obtendremos el siguiente resultado:
En este caso, 1 es igual a 1, por lo que se imprime "x es igual a y".
¿Son necesarios los dos puntos al final de if?
Los dos puntos (colon en inglés) al final de la línea if son necesarios. Son una parte importante de la sintaxis de Python y le dicen al intérprete de Python que el bloque de código que sigue a continuación es el bloque que se ejecutará si la expresión booleana es verdadera.
De igual manera, como veremos más adelante, los dos puntos son necesarios para definir bloques de código pertenecientes a la estructura elif o else; así como también en otras estructuras de control de flujo, como bucles for y while, y en la definición de funciones y clases.
Podemos generalizar, entonces, que los dos puntos son necesarios para definir bloques de código en Python.
¿Qué pasa si no utilizas la indentación?
Python es diferente a muchos lenguajes de programación respecto de la indentación (llamada también tabulación o sangría).
Si no utilizas la indentación, tu programa no funcionará. Esto es un requisito. Python no utiliza llaves { ... } para delimitar bloques de código, de la misma manera en que lo hacen lenguajes como C, C++ y Java. Python se basa, de hecho, en la indentación para delimitar distintos bloques de código, unos de otros.
Es posible que si programas en otros lenguajes no estés acostumbrado a indentar tu código. En Python será obligatorio que lo hagas. Así que mejor acostúmbrate. No solo es una buena práctica; si no que además, con el tiempo, te darás cuenta que la legibilidad de tus código mejorará increiblemente.
Diagrama de flujo de la estructura condicional if
Para visualizar cómo funciona la estructura condicional if, podemos utilizar un diagrama de flujo (flow chart en inglés) que permite representar la lógica de este programa.
Más técnicamente, muestra el flujo de control del programa. Es decir, la capacidad que tiene el código de controlar el flujo de un programa, que generalmente es desde arriba hacia abajo.
Analicemos ahora como se lee el diagrama del programa comparar.py:
-
Vemos un óvalo en la parte superior que dice, literalmente, "INICIO / START". Independientemente de la forma o el diseño que tenga el diagrama, esta figura se coloca arriba de todo, donde debe comenzar la lógica de la solución del problema, que luego será codificada en un programa. De esta figura sale una flecha que indica la dirección del flujo del programa, denominada "FLECHA DE FLUJO".
-
Observemos que la "FLECHA DE FLUJO" se dirige hasta una figura de diamante. Y dentro de ese diamante hay una pregunta, una expresión booleana:
x < y. -
Esta figura es de "Decisión" y significa que según la respuesta a la pregunta que contiene,
- el flujo del programa se va a bifurcar (dividir) hacia abajo en caso VERDADERO, si la respuesta es verdadera, por la "RAMA VERDADERA";
- o hacia la derecha en caso FALSO, si la respuesta es falsa, por la "RAMA FALSA"; siempre a través de las "FLECHAS DE FLUJO".
-
Por la "RAMA VERDADERA", la "FLECHA DE FLUJO" conecta con una figura de "PROCESO" o "TAREA" que en este caso se encarga de imprimir en pantalla "x es menor que y".
-
Mientras que por la "RAMA FALSA" la "FLECHA DE FLUJO" conduce hasta la intersección con la "RAMA VERDADERA" sin efectuar "PROCESO" alguno.
-
En ese "PUNTO DE INTERSECCIÓN" ambas ramas vuelven a unirse formando nuevamente un único flujo de programa.
-
A continuación se repiten los puntos 2. a 6. dos veces más, donde se ven las preguntas
x > yex == yrespectivamente, y sus respectivas respuestas verdaderas y falsas. -
Al finalizar, la "FLECHA DE FLUJO" se dirige hacia una figura de "FIN / STOP" que indica el final del programa.
Analizado de esta manera, podemos afirmar que la lógica del programa comparar.py es correcta. Y que el diagrama de flujo valida todas las respuestas posibles para todas las posibles preguntas que se pueden hacer en el programa, a partir de las variables x e y y los distintos valores que pueden adoptar y sus relaciones entre sí.
¿Un problema bien resuelto es un problema bien diseñado?
Como vimos anteriormente, nuestro programa hace lo que se supone que debe hacer. Pero, ¿qué problemas tiene su diseño para que se lo considere mal diseñado?
¡Para recordar!
No es suficiente que la lógica de la solución planteada a un problema y el código resultante que escribas sea correcto y haga lo que pretendes. A medida que nuestros programas se vuelvan más largos, más sofisticados y más complicados, también querremos que estén bien diseñados.
Piensa. ¿Por qué podemos decir que este programa no está bien diseñado, aunque sea correcto?
Haz clic aquí para ver la respuesta propuesta
Es cierto que el código parece un poco repetitivo. Estamos preguntando si x < y, si x > y, y si x == y, una tras otra.
Sin embargo, una vez que sabemos la respuesta a una de estas preguntas, lógicamente deberíamos poder evitar alguna de las preguntas subsecuentes.
Observemos el diagrama de flujo: sin importar si tomamos el camino hacia abajo o hacia la derecha, siempre terminamos haciendo las tres preguntas. Cada una de las flechas conduce al primer, segundo y tercer diamante, lo que significa que estamos realizando tres comparaciones, independientemente de si alguna de las respuestas es verdadera o falsa. Esto podría ser un problema si estamos tratando con un gran volumen de datos o si queremos que nuestro programa sea más eficiente. Sobre todo cuando sabemos que una vez que se cumple una condición, las demás no se cumplirán.
¿Cómo podríamos mejorar esto?
Al parecer, nuestra solución es un poco repetitiva.
Estoy preguntando si esto..., si esto..., si esto... Y, sin embargo, lógicamente, debería saber la respuesta a algunas de esas preguntas posteriores una vez que descubra una. Y, en resumen, si miran este diagrama aquí, observen que no importa si voy a la izquierda o a la derecha, siempre hago tres preguntas. Pase lo que pase, todas esas flechas conducen al primer, segundo y tercer diamante. Así que estoy haciendo tres preguntas, sin importar si alguna de esas respuestas es verdadera o falsa. Bueno, ¿cómo podría hacer para mejorar esto?