>Nota: Antes de leer este post, se recomienda leer la [cuarta parte](https://steemit.com/spanish/@juancrdrums/aprender-a-programar-desde-cero-parte-4-leyendo-datos-por-teclado) de este tutorial. >ACLARACIONES IMPORTANTES: >1. En estos tutoriales no se abordan temáticas excesivamente profundas y no se hace énfasis en aprender muchos lenguajes de programación ni muchos frameworks. El objetivo es entender qué es programar y cuál es la lógica necesaria para hacerlo. >2. No utilizo ningún libro o fuente externa para hacer estos tutoriales. Soy estudiante de cuarto año de Ingeniería en Sistemas, por lo que toda la información que doy acá ha sido extraída de mis clases en la universidad y de lo que he consultado por mis propios medios en ocasiones anteriores. En caso de utilizar conocimiento sacado de otras fuentes, haré claridad. Así mismo, para el caso de las imágenes, citaré la fuente en el caso de que no sean mías. Las imágenes que no aparecen con su fuente abajo son hechas por mí. >3. Todos los códigos trabajados en este tutorial pueden ser consultados y descargados en el [repositorio de GitHub](https://github.com/JuanCRdrums/CursoSteemit) creado para este fin. ¡Hola, gente de Steemit! Hoy continuamos con este tutorial BÁSICO de programación, en el que pretendo proveer herramientas para los lectores que les permitan adentrarse en el mundo del desarrollo de software a través de elementos lógicos que son fundamentales para cualquier proyecto que involucre la realización de código útil. En el [capítulo anterior](https://steemit.com/spanish/@juancrdrums/aprender-a-programar-desde-cero-parte-4-leyendo-datos-por-teclado) aprendimos cómo leer datos en Python, tanto numéricos como de caracteres. El día de hoy vamos a ver un tema sumamente importante para los programadores, una herramienta que seguramente tendremos que usar siempre que vayamos a hacer un programa: **LOS CONDICIONALES**. Bienvenidos; como siempre, espero ser claro en mis explicaciones. ![](https://cdn.steemitimages.com/DQmY4PwYs3Vqw8awvrAFibhjgqstxzJwp3VvCSfQz3FewWn/imagen.png) [Fuente](https://www.importancia.org/wp-content/uploads/lenguajesdeprogramacion-370x277.jpg) ## Tomando decisiones La programación de computadores se parece al mundo real en muchos casos. De hecho, uno de los principales objetivos de los lenguajes de programación de alto nivel (como Python) es hacer un poco más sencilla la lógica computacional para el ser humano, de modo que las instrucciones que se le dan a la máquina se parezcan de alguna forma a la abstracción que normalmente hacemos en nuestro cerebro. Una de las mejores herramientas provistas por estos lenguajes es aquella que nos permite efectuar una acción que realizamos a diario: La toma de decisiones. Cada vez que vamos a tomar una decisión en nuestra vida cotidiana es indispensable analizar el contexto, es decir, las circunstancias que rodean esta decisión. Por ejemplo, si quiero determinar en qué lugar pasaré mis próximas vacaciones, de forma inevitable tendré que analizar cuánto dinero tengo en este momento en mi cuenta bancaria, qué tipo de turismo es el que quiero hacer, si me gusta el clima caliente o frío, si hay disponibilidad de vuelos o buses, entre muchas otras **CONDICIONES**. Este es, a grandes rasgos, el proceso que se realiza en la programación de computadores para tomar decisiones, efectuándose esta acción a través de los **CONDICIONALES**. ## Condicionales La lógica de los condicionales en cualquier lenguaje de programación es la misma: Se valida el cumplimiento de una condición (que dos variables sean iguales, por ejemplo) y, según el resultado de esta validación, se realiza una tarea u otra. Esto se puede comprender de forma sencilla a través del siguiente diagrama de flujo: ![](https://cdn.steemitimages.com/DQmZ8amgugHqsdHS7mEcrMrQ84gJ6vXBgxihfWTL5XGK7Y8/imagen.png) [Fuente](https://desarrolloweb.com/articulos/images/algoritmos/ordinograma_si_doble.gif) El diagrama de flujo anterior es claro: Hay una condición y una serie de instrucciones que se ejecutan en caso de que esta se cumpla y en caso de que no. Si pensamos en lenguajes de programación, estas instrucciones se verían traducidas en líneas de código. Veamos el siguiente enunciado: > Se requiere hacer un programa en Python que, luego de ingresar un número entero por teclado, diga si este número es par o impar. Es seguro que para hacer este programa será necesario utilizar un **condicional**, pues todos los números enteros tienen dos posibilidades: Son pares o son impares. El primer objetivo que el programador debe plantearse en este caso es averiguar **cuál es la condición que define si un número es par o no**. Como bien dije en el capítulo anterior de este tutorial, la programación lleva **MUCHAS MATEMÁTICAS**, por lo que es necesario repasar y estudiar bastante todo lo relacionado con números, pues esto lo necesitaremos diariamente. Si el lector tiene un buen desempeño con la aritmética, seguramente se habrá percatado de que los números pares tienen una particularidad: Todos son divisibles entre 2. En los números impares pasa absolutamente lo contrario. Eso nos plantea un interrogante más: ¿Cómo sé si un número es divisible entre 2? En este caso hay una operación matemática que nos será de gran ayuda: **El módulo**. ¿Recuerdan cuando hacían divisiones *a mano* en la primaria? Se averiguaba el resultado (cociente) y en ocasiones, cuando la división ***no era exacta***, quedaba un sobrante conocido como *residuo*. Pues bien, la operación **módulo** permite averiguar el residuo que resulta de dividir dos números. Por ejemplo, 11 módulo 5 es igual a 1, pues al dividir 11 entre 5 el resultado (entero) da 2 y obtenemos un residuo de 1. Por lo tanto, siempre que se le aplique la operación **módulo** a dos números que se dividen de forma exacta, el resultado será 0 (cero), pues en las divisiones exactas no hay ningún residuo. La información anterior es supremamente valiosa en el problema de saber si un número es par o no. En este caso, solamente bastará con preguntar si al aplicar el módulo entre 2 al número ingresado el resultado es 0. Esto querrá decir que el número se puede dividir exactamente por 2, por lo que se puede afirmar con seguridad que es par. Siempre que esta operación dé como resultado un valor distinto de 0, el número será impar. ## Condicionales en Python El proceso de análisis hecho anteriormente dio como resultado un **ALGORITMO**, es decir, una secuencia de pasos a seguir para resolver el problema dado. En este caso, la secuencia sería la siguiente: 1. Pedirle un número al usuario. 2. Averiguar si el número ingresado *módulo 2* da 0 o no. 2.1 En caso afirmativo, mostrar que el número es par. 2.2 En caso negativo, mostrar que el número es impar. Después de tener claro nuestro algoritmo, debemos preocuparnos por codificar la solución propuesta utilizando Python en este caso. Les mostraré el código para este problema y con él les explicaré la sintaxis de los condicionales en este lenguaje de programación. Aquí va: ```python #!/usr/bin/env python # -*- coding: utf-8 -*- if __name__ == '__main__': n = input("Ingresa un número: ") if n % 2 == 0: print n, " es un número par." else: print n, " es un número impar." ```
Primero, se empieza pidiendo un número y guardándolo en la variable *n* (en el capítulo anterior se resuelven todas las dudas respecto al ingreso de datos). Luego viene el condicional propiamente dicho: Siempre se debe escribir la palabra *if* ("si" en inglés), pues esta le indica al intérprete de Python que allí viene un condicional. Luego, con un espacio de separación, viene la condición propiamente dicha. Para el caso de Python, la operación *módulo* se expresa con un porcentaje (%). Además, es necesario que noten que la igualdad no se expresa con un solo signo *igual* (=) sino que se hace con dos (==). Esto se hace en casi todos los lenguajes de programación y tiene como objetivo diferenciar la *comparación* de la *asignación*. En palabras coloquiales, la condición expresada arriba se puede leer como: *"si n módulo 2 es igual a 0"*. Después de la condición, vienen los dos puntos (:) y después viene el código que se ejecuta en caso de que la premisa se cumpla. **Todo el código que se ejecuta si la condición se cumple debe ir con un nivel extra de identación, es decir, con un espacio en blanco mayor a la izquierda** (si miran el código se darán cuenta de qué les estoy hablando). En este caso, si la condición se cumple, se muestra que el número es par a través de la función *print*. Para las instrucciones que se ejecutan si la condición no se cumple se utiliza la palabra *else* seguida de dos puntos (:). Esta palabra debe tener el mismo nivel de identación que el *if* del principio y, así mismo, las líneas que se ejecutan si la condición no se cumplen deben tener un nivel más de identación (más espacio en blanco a la izquierda). Para el programa que estamos desarrollando, en caso de que la condición no se cumpla, se muestra que el número es impar a través de la función *print*. Sencillo, ¿no? El código presentado anteriormente se puede encontrar en el [repositorio de GitHub](https://github.com/JuanCRdrums/CursoSteemit) del curso con el nombre de *esPar.py*. Es importante saber manejar los operadores matemáticos y de comparación en Python, pues estos son *el pan de cada día* a la hora de hacer cálculos y evaluar condiciones. A continuación, les voy a dejar dos tablas muy importantes: Una con los operadores aritméticos básicos de Python y otra con los operadores de comparación. **Las tablas son de elaboración propia**:
## Operadores aritméticos
| Operador | Nombre | Descripción | Ejemplos | | :--------: | ------------ | :---------------: | ---------- | | + | Suma | Suma los valores ubicados a ambos lados del operador | b = 3 + 10 | | - | Resta | Resta los valores ubicados a ambos lados del operador | b = 3 - 10 | | * | Multiplicación | Multiplica los valores ubicados a ambos lados del operador | b = 3 * 10 | | / | División | Aplica división entre los valores ubicados a ambos lados. Si son valores enteros, hace división solo con la parte entera. En el primer ejemplo, b queda con valor de 0, pues se redondea hacia abajo. En el segundo ejemplo, b queda con el valor de 0.3 | b = 3 / 10
b = 3.0/10.0 | | % | Módulo | Divide el operando de la izquierda entre el operando de la derecha y retorna el **residuo** | b = 3 % 10 | | ** | Exponente | Realiza la operación de **potenciación** o **exponenciación**, tomando el operando de la izquierda como base y el de la derecha como exponente. La expresión del ejemplo se lee como *"a al cuadrado"* o *"a a la segunda potencia"* | b = a ** 2 | | // | División entera | Divide el operando de la izquierda entre el operando de la derecha, retornando solamente **la parte entera** del resultado, es decir, ignorando las cifras decimales. Solamente se comporta distinto al operador de división convencional (/) cuando se utiliza con números reales | b = 3.0 // 10.0 |

## Operadores de comparación
| Operador | Nombre | Descripción | Ejemplo | | ------ | ------ | ------- | ------- | | == | Igualdad | Evalúa si la expresión ubicada a la derecha es **igual** a la expresión ubicada a la izquierda. Para el ejemplo, el resultado de la expresión es **verdadero** | a + b == b +a | | !=, <> | Diferente | Evalúa si la expresión ubicada a la derecha es **diferente** de la expresión ubicada a la izquierda. Para los ejemplos, el resultado de las expresiones es **falso**. Los dos operadores aquí expresados (!= y <>) tienen el mismo funcionamiento | a + b == b +a
a + b <> b + a | | > | Mayor que | Evalúa si el resultado de la expresión de la izquierda es **mayor** que el resultado de la expresión de la derecha. Para el ejemplo, el resultado de la expresión es **verdadero**. | 3 > 1 | | < | Menor que | Evalúa si el resultado de la expresión de la izquierda es **menor** que el resultado de la expresión de la derecha. Para el ejemplo, el resultado de la expresión es **falso**. | 3 < 1 | | >= | Mayor o igual | Evalúa si el resultado de la expresión de la izquierda es **mayor o igual** que el resultado de la expresión de la derecha. Para el ejemplo, el resultado de la expresión es **verdadero**. | 3 >= 1 | | <= | Menor o igual | Evalúa si el resultado de la expresión de la izquierda es **menor o igual** que el resultado de la expresión de la derecha. Para el ejemplo, el resultado de la expresión es **falso**. | 3 <= 1 |

## Condiciones y condicionales anidados Es posible validar el cumplimiento de más de una condición en un solo condicional. Para esto es necesario utilizar **las compuertas lógicas**, siendo las más básicas (por ahora solo explicaré esas) las conocidas como **and** y **or**. Para el caso de la primera, es necesario que se cumplan **las dos condiciones** de la izquierda y la derecha para que se ejecute el contenido del condicional. En la segunda, es necesario que se cumpla **al menos una de las dos condiciones** para que se ejecute el contenido del condicional. Así como es posible validar varias condiciones en un solo condicional, también es posible *anidar* los condicionales. Esto quiere decir que dentro del contenido de un condicional se puede escribir otro condicional, y dentro de este otro más; tantas veces como sea necesario. En los ejercicios del final les plantearé algunos problemas en los que esta situación sea necesaria. Los condicionales también se pueden anidar por el lado del *else* (condición negativa). Si se quiere ahorrar código (y tiempo, claro está) se puede utilizar la palabra *elif* seguida de una nueva condición. En este caso, solamente se ejecutaría el código que está después si no se cumplió la condición anterior y si **sí se cumple** la condición que se expresa después de esta palabra. Más abajo les daré un ejemplo con esto. Por último, para entender la solución al siguiente problema es necesario comprender el concepto de **VARIABLE BOOLEANA**. Su nombre suena muy extraño, pero este tipo de dato es realmente sencillo: Se trata de una variable que puede tomar solamente un valor **Verdadero** o **Falso**. En Python se escriben estos valores en inglés (**True** y **False**), respetando la letra mayúscula del principio. En el siguiente ejemplo podrán entender esto de forma sencilla. Prestemos atención al siguiente enunciado: > Se le quiere hacer una modificación al primer ejemplo. En este caso, no solamente se quiere validar si un número ingresado es par, sino que también se quiere validar si este es múltiplo de 3. El programa deberá mostrar toda la información del número respecto a las condiciones anteriores: Si solamente es par, si es par y también múltiplo de 3, si solamente es múltiplo de 3 o si no es par ni múltiplo 3. El problema de los múltiplos de un número se resuelve fácilmente a través del operador de **módulo** (%), usando el mismo método con el que se resolvió el primer problema de este capítulo. Primero les presentaré el código de mi propuesta de solución, con el cual podremos entender todos los conceptos nuevos de la presente publicación: ``` #!/usr/bin/env python # -*- coding: utf-8 -*- if __name__ == '__main__': n = input("Ingresa un número: ") par = False tres = False if n % 2 == 0: par = True if n % 3 == 0: tres = True if par and tres: print n, " es un número par y un múltiplo de 3." elif par: print n, " es un número par." elif tres: print n, " es un múltiplo de 3." else: print n, " no es un número par ni un múltiplo de 3." ``` Vamos paso a paso: - Primero, se lee el número y se guarda en la variable **n**. - Luego, se inicializan dos variables **booleanas** (**par** y **tres**) con valores falsos (**False**). En este tipo de problemas, normalmente se asume primero que no se va a cumplir ninguna de las condiciones que se van a evaluar. En este caso, la variable **par** será una *bandera* que indicará si el número ingresado es par o no, mientras que la variable **tres** indicará si el número ingresado es múltiplo de 3 o no. - A continuación, se validan ambas condiciones (con los dos condicionales) a través de la operación módulo. Noten que cada vez que se cumple una de ellas, se le da el valor verdadero (**True**) a la variable booleana respectiva. - Por último, se validan las condiciones a través de las variables booleanas. Noten que para validar que una variable booleana tenga valor **True** en un condicional solamente es necesario escribir su nombre; no hace falta escribir por ejemplo par == True, aunque esta opción también es válida. - Noten el uso de la palabra **elif**. En el código anterior se puede entender de manera sencilla. **NOTA:** El código anterior puede ser visto y descargado en el [repositorio de GitHub](https://github.com/JuanCRdrums/CursoSteemit) del curso en el archivo con nombre *esPar2.py*. Recomiendo descargarlo y ejecutarlo ingresando diferentes valores de prueba para ver el funcionamiento del programa.
## ¡A practicar! Como siempre, les propongo algunos ejercicios para ejercitar lo aprendido en este capítulo. Estaré atento para resolver cualquier duda que surja en los comentarios de este post. Aquí van: > 1. Hacer un programa que le pregunte al usuario cuántos kilogramos pesa. Si pesa más de 100 kg debe decirle: "Estás gordo" y si pesa menos debe decirle "Tu peso es normal". > 2. Hacer un programa que lea dos números y diga si estos son iguales o son distintos. En caso de que sean distintos, debe decir además cuál es el mayor. ![](https://cdn.steemitimages.com/DQmUsHVYoJqB5syyxBueyG56xKqr4qiFkniWkxTXrSZuZym/imagen.png) Aquí llegamos al final de la quinta parte de este tutorial. Espero que les haya gustado y la información haya sido útil. Si así fue, no olviden dar upvote y resteem. Nos reencontramos pronto.