Sentencias condicionales

Es necesario aclarar que el flujo de ejecución de un programa es el orden que sigue un programa al ejecutar las instrucciones. Normalmente este flujo en los lenguajes de programación es línea por línea desde arriba hacia abajo, como si de leer una carta se refiere. Ahora bien, las sentencias condicionales en un lenguaje de programación son estructuras de control en donde se evalúa la condicion booleana TRUE de una expresión y a continuación ejecuta un bloque de código. En caso de no ser TRUE conduce flujo del programa hacia otra parte del bloque de código dentro de la estructura de control.

Codicional IF

La palabra reservada IF se usa para dar inicio a la estructura de sentencias condicionales. 

La sintaxis de una instrucción condicional IF es de la siguiente manera:

IF <condición a evaluar>:

    <instrucciones en caso de ser TRUE>

    ...

    <última instrucción del bloque IF>

<instrucción fuera del bloque IF>

La estructura básica de una sentencia IF se puede ver en el siguiente ejemplo práctico:

if True: #la evaluación sola de true siempre devuelve true

    print("Esta parte del código sólo se ejecuta en caso de ser TRUE")

El resultado de la ejecución del código anterior es:

Esta parte del código sólo se ejecuta en caso de ser TRUE

De no haber arrojado TRUE la evaluación de la sentencia condicional IF, no se hubiera mostrado por pantalla la frase "Esta parte del código sólo se ejecuta en caso de ser TRUE", ya que el programa nunca hubiera permitido que el flujo de programa hubiera tomado esa dirección.

Es importante destacar que luego de la condición a evaluar se debe colocar dos puntos (:) y el bloque de código. Además el sangrado que se deja luego de los dos puntos le indica al intérprete de Python cual es el bloque de código a ejecutar en caso de que la condición evaluada en la sentencia IF devuelva TRUE. 

Si deseamos realizar otra acción diferente en caso de que la condición a evaluar arroje false se debe usar la sentencia de bifurcación ELSE:. Respetando de igual manera la colocación de los dos puntos (:) y el sangrado del bloque de código correspondiente en la bifurcación ELSE. Veamos un ejemplo donde deseamos evaluar si el usuario ingresa un valor positivo o negativo. Para esto nos valdremos de la función de entrada INPUT() la cual recibe por teclado un valor y lo devuelve. Básicamente su funcionamiento es que la ejecución del código se detiene ante una instrucción INPUT() y queda a la espera de la introducción de un valor por teclado y se presione la tecla enter. Es importante destacar que cualquier valor introducido a través de la instrucción INPUT() es considerado como texto, es por ello que es necesario recurrir a la función INT() para convertir en valor entero la cadena ingresada por teclado. En este caso lo vamos a enviar a una variable llamada n, quedando el código de la siguiente manera:

n=int(input('Ingrese un numero: '))

if n>0:

    print(f"{n} es un valor positivo (mayor que cero)")

else:

    print(f"{n} es un valor negativo (menor que cero)")

El resultado del código anterior si ingresamos el número 4 sería:

Ingrese un numero: 4

4 es un valor positivo (mayor que cero)

Ahora evaluemos el resultado si ingresamos el número -20. El resultado sería:

Ingrese un numero: -20

-20 es un valor negativo (menor que cero)

Como podemos comprobar hasta ahora el código funciona. El flujo del programa toma una ruta u otra dependiendo del valor ingresado por el usuario (si es positivo o negativo).

Como es natural uno podría preguntarse ¿Podría funcionar el programa si en lugar de usar la sentencia de bifurcación ELSE se usara otra sentencia IF separada que evaluara si el valor ingresado fuera negativo?. Pues la respuesta es que en realidad sí, pero hay una razón de peso para usar las sentencias de bifurcación y es por la cual fueron creadas en primer lugar. 

Primero que nada comprobemos si en realidad funcionaría usando 2 sentencias condicionales IF en lugar de una sentencia IF con su bifurcación ELSE:

El código quedaría de la siguiente manera:

if n>0:

    print(f"{n} es un valor positivo (mayor que cero)")

if n<0:

    print(f"{n} es un valor negativo (menor que cero)")

Ingresando el valor 5 da el siguiente resultado:

Ingrese un numero: 5

5 es un valor positivo (mayor que cero)

Ingresando el valor -5 arroja lo siguiente:

Ingrese un numero: -5

-5 es un valor negativo (menor que cero)

Nota importante:

Como podemos ver sí funciona, pero programar de esta manera resulta en una mala práctica ya que en realidad estamos forzando al intérprete de Python a evaluar dos veces la misma condición, mientras que en una sola instrucción condicional IF con su respetiva sentencia de bifurcación ELSE, Python esta evaluando solo 1 vez la condición y tomando una ruta u otra dependiendo del resultado si es TRUE o FALSE. En un programa tan simple como este no se aprecia la diferencia de rendimiento, pero en un programa mucho mas complejo con muchas condiciones a evaluar si que se puede notar la caída de rendimiento y ralentización del programa. A fines de desarrollar buenos hábitos de programación ésta es una práctica que se debe evitar, se deben usar las instrucciones de bifurcación dentro de las sentencias condicionales en todo momento que sea posible por sencilla que sea la tarea que se desee realizar.

Veamos otro ejemplo práctico, en este caso vamos a crear un programa que llame a una función la cual devuelva una cadena indicando si un alumno esta aprobado o reprobado dependiendo de su nota final. El criterio es que la nota por debajo de 10, es decir de 0 a 9 inclusive, equivale a reprobado.

import os

os.system('cls')

print('***** Programa de notas de alumnos *****')

def notas(n):

    status_alumno='Aprobado'

    if n<10:

        status_alumno='Reprobado'

    return status_alumno

print(f'El alumno está {notas(int(input("Introduzca la nota final del alumno: ")))}')

Resultado ingresando 15:

***** Programa de notas de alumnos *****

Introduzca la nota final del alumno: 15

El alumno está Aprobado

Resultado ingresando 9:

***** Programa de notas de alumnos *****

Introduzca la nota final del alumno: 9

El alumno está Reprobado

Como podemos apreciar la estructura de control de flujo condicional IF esta funcionando perfectamente.

Otra forma de evaluar las condiciones: la palabra reservada NOT.

En la vida diaria, uno podría hacerse la mismas pregunta pero de diferentes maneras, por ejemplo para decir si esta lloviendo podría decirse: "Está lloviendo". Con lo cual se está afirmando rotundamente que efectivamente cae agua del cielo. Sin embargo también esta misma afirmación podría hacerse con una negación: "No deja de caer agua" y con esta afirmación categórica efectivamente estamos afirmando que esta lloviendo. Como podemos ver se puede llegar a la misma conclusión lógica tanto afirmando como negando una condición.

En la programación en general y por supuesto también en Python, se puede evaluar la condición negada obteniendo la respuesta booleana contraria a si se hubiera evaluado la condición sin la negación. En todo caso la lógica de programación permitirá conducir el flujo del programa de manera correcta dependiendo de las condiciones evaluadas y las respuestas booleanas obtenidas por el intérprete.

Para negar una condición se utiliza la palabra reservada NOT, simplemente se antepone a la condición a evaluar y ésta devolverá la condición booleana contrariaa la que arrojaría normalmente al evaluarse.

 Veamos un ejemplo práctico para aclarar un poco el panorama:

if not n > 0:

    print(f"{n} es un valor negativo (menor que cero)")

Este código equivaldría a preguntarse en nuestro lenguaje humano Si la variable 'n' no es mayor que cero muestra por pantalla el valor de la variable 'n'  y escribe que es un valor negativo (menorque cero).

El código anterior funcionaría en la mayoría de los casos como podemos ver con las siguientes pruebas introduciendo una variedad de valores:

Prueba con -45

Ingrese un numero: -45

-45 es un valor negativo (menor que cero)

Prueba con -3

Ingrese un numero: -3

-3 es un valor negativo (menor que cero)

Prueba con 12

Ingrese un numero: 12

(al ingresar 12 no hubo resultados ya que luego de la sentecia condicional no hay código sino mas bien termina el programa, y esto es correcto ya que el programa no esta arrojando ninguna información errónea)

Prueba con 0

Ingrese un numero: 0

0 es un valor negativo (menor que cero)

Esto sí es un error, ya que la evaluación de la variable, cuyo valor es cero, no es mayor que cero, sino mas bien igual a cero. Con lo cual la evaluación si cero no es mayor que cero, (cosa que es cierta), llevara el flujo del programa al bloque de código que le indica al computador que muestre el mensaje diciendo que 0 es un valor negativo (cosa que obviamente no es cierta, ya que el cero no es ni positivo ni negativo, sino neutral o simplemente cero). Tampoco sirve evaluar la condición contraria, es decir escribir el código de la siguiente manera:

if  n > 0:

    print(f"{n} es un valor positivo (mayor que cero)")

ya que sí funcionaría para los números diferentes a cero, pero en este caso si es igual a cero el programa no haría nada, tal como si fuera un número negativo. Aunque en este caso el programa al menos no emite un mensaje equivocado, estamos dejando de evaluar algunas condiciones que, dependiendio del uso, aplicación y circunstancia del programa, podrían ser muy utiles o incluso indispensables, haciendo que la omisión de estas condiciones conduzcan a un fallo del sistema o aún peor, a la salida de información errónea.

Veamos esto en la práctica:

Prueba con 4

Ingrese un numero: 4

4 es un valor positivo (mayor que cero)

Prueba con 8

Ingrese un numero: 8

8 es un valor positivo (mayor que cero)

Prueba con 0

Ingrese un numero: 0

(Al ingresar 0 no hubo resultados ya que la condición 0 mayor que 0 arroja FALSE por lo tanto no ejecuta el bloque de código, saltando hasta que al encontrar el final del programa termina sin mas)

Como se dijo antes aunque al menos esta vez el programa no mostró ningún mensaje equivocado, aunque si se omitió la posibilidad que el usuario ingresara 0 que es diferente a un valor positivo o negativo. Cabe preguntarse ¿Cómo direccionar de manera óptima el flujo del programa evaluando una condición con 3 posibles resultados? En este caso evaluar si el usuario ha ingresado un valor mayor a cero, menor a cero o igual a cero. Pues como ya se ha dicho antes, lo más óptimo sería usar la menor cantidad de evaluaciones posibles para hace el mismo trabajo. Para esto nos valdremos de las sentencias de bifurcación ELIF

Sentencia de bifurcación ELIF

La sentencia de bifurcación ELIF permite evaluar una o mas condiciones luego del IF, de la siguiente manera

IF condicion a evaluar:

    este bloque se ejecuta en caso de ser TRUE la condicion del IF

ELIF otra condición a evaluar:

    este bloque se ejecuta si no entró al primero pero si devuelve TRUE en esta sentencia ELIF

ELSE:

    este bloque se ejecuta en caso que no sean TRUE ninguna de las condiciones anteriores

La instrucción ELSE se podría traducir como "y si no es verdad", lo cual hace que se ingrese por esta instrucción de bifurcación si todas las anteriores dieron como resultado FALSE en su evaluación de la condición.

Es importante destacar aunque parezca obvio, que la instrucción IF puede estar sola, pero las instrucciones ELSE y ELIF necesitan una instrucción IF que las anteceda.

Veamos un ejemplo práctico y sencillo:

if  n > 0:

    print(f"{n} es un valor positivo (mayor que cero)")

elif n < 0:

    print(f"{n} es un valor negativo (menor que cero)")

else:

    print(f"{n} es un valor neutral")

Los 3 posibles resultados son:

Prueba con 4

Ingrese un numero: 4

4 es un valor positivo (mayor que cero)

Prueba con -8

Ingrese un numero: -8

-8 es un valor negativo (menor que cero)

Prueba con 0

Ingrese un numero: 0

0 es un valor neutral

Instrucción PASS

Este es un buen momento para introducir la palabra reservada PASS. Su función, aunque parezca extraño es simplemente seguir el flujo del programa sin hacer nada. Resulta muy útil cuando se está programando y aun no se tiene un bloque de código terminado pero se necesita tener listo y operativo una sección de código dentro de otra bifurcación en una sentencia IF ELSE Siguiendo el ejemplo anterior pongamos el caso que vamos a codificar las acciones que hará el programa en caso el usuario ingrese un valor positivo , un valor negativo o cero, pero solamente vamos a codificar de momento el bloque de código en caso de ser positivo y en caso de ser negativo hay que hacer un proceso un poco mas complicado que vamos a codificar otro día, pero queremos dejar la instrucción de bifurcación preparada. Debido a que Python no permite bloques de códigos vacíos siempre hay que escribir algo dentro de una biburcación, caso contrario arroja error al tratar de ejecutar el programa.

El programa quedaría asi:

n=int(input('Ingrese un numero: '))

if  n > 0:

    print(f"{n} es un valor positivo (mayor que cero)")

elif n < 0:

    pass

else:

    print(f"{n} es un valor neutral")

Como se puede ver el bloque de código en caso que el usuario ingrese un valor negativo contiene la instrucción pass, lo cual no hace nada pero permite dejar la posibilidad de ser sustituido por código en un futuro. Como nota adicional no sirve colocar un comentario que sustituya el bloque de código dentro de la bifurcación ELIF, igualmente el intérprete arroja error.

En Python es posible concatenar los operadores de comparación dentro de las instrucciones IF para hacer evaluaciones mas complejas y mas precisas de las condiciones requeridas para entrar o no en un bloque de código determinado. Por ejemplo en el caso que se necesite evaluar si un valor esta dentro de un rango determinado. Supongamos que necesitamos evaluar la edad ingresada por el usuario y necesitamos hacer una acción si la edad esta entre 0 y 18 años, y otra acción si es igual o mayor a 18 años y otra acción si la edad ingresada es igual o mayor a 100. Para ello nos valdremos de los operadores de comparación vistos anteriormente pero con la peculiaridad que van a estar concatenados para evaluar una condición mas compleja y obtener un resultado mas preciso. Por ejemplo evaluaremos si la edad ingresada es mayor o igual a 0 y menor estricto que 18, es decir hasta 17, en cuyo caso se mostrará un mensaje indicando que es menor de edad, y así con los otros rangos de edades entre 18 y 100 años, para indicar que es mayor de edad, arrojando error si la edad ingresada es menor a 0, o sea si es un número negativo o si es mayor a 100. Si bien este ejemplo es poco práctico sirve para ilustrar como usar operadores de comparación concatenados para evaluar 2 condiciones simultaneas. Veamos la práctica:

edad=int(input('Ingrese la edad: '))

if 0<=edad<18:

    print('Menor de edad')

elif 18<=edad<100:

    print('Mayor de edad')

else:

    print('Edad incorrecta')

Resultado ingresando edad -7:

Ingrese la edad: -7

Edad incorrecta

Resultado ingresando edad 0:

Ingrese la edad: 0

Menor de edad

Resultado ingresando edad 4:

Ingrese la edad: 4

Menor de edad

Resultado ingresando edad 17:

Ingrese la edad: 17

Menor de edad

Resultado ingresando edad 23:

Ingrese la edad: 23

Mayor de edad

Resultado ingresando edad 99:

Ingrese la edad: 99

Mayor de edad

Resultado ingresando edad 100:

Ingrese la edad: 100

Edad incorrecta

Resultado ingresando edad 103:

Ingrese la edad: 103

Edad incorrecta

Como se ha podido comprobar ingresando diferentes edades, el código logra canalizar el flujo del programa correctamente dependiendo del valor de la edad ingresada como era el requerimiento inicial. Gracias a la concatenación de los operadores de comparación es posible evaluar varias condiciones en una sola línea de código, como por ejemplo si el valor de la edad esta entre 18 inclusive y 100 exclusivo, es decir que puede tomar un valor entre 18 y 99 para que se imprima el mensaje 'Mayor de edad', para lo cual se concatenan las condiciones 18<=edad con <100 quedando 18<=edad<100, lo cual se lee de izquierda a derecha como "si 18 es menor o igual a la edad y esta a su vez es menor que 100". Y así con el resto de las condiciones requeridas en el planteamiento inicial. Quedando como ultima opción un ELSE que se ejecutaría en caso de que el flujo del programa no haya pasado por las condicionales IF y ELIF que le anteceden.