Semana_2_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center>\n",
    "<h1> Introducción a la programación con Python </h1>\n",
    "<h2> Alberto Mario Ceballos Arroyo </h2>\n",
    "<h2>Ingeniero de Sistemas </h2> \n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Algunos aspectos metodológicos </h1> </center>\n",
    "\n",
    "- Para participar, preferiblemente escribir por el chat o levantar la mano (somos 150).\n",
    "\n",
    "- Recordemos que el temario está disponible si queremos adelantarnos un poco.\n",
    "\n",
    "- La evaluación es automática y se basa en los retos, el resto de actividades de la plataforma son opcionales pero muy recomendadas.\n",
    "\n",
    "- La autoevaluación y las evaluaciones de la primera semana quedaron disponibles hasta el 30 de mayo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <img src=\"img/temario.png\"/> </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center> <h1> Agenda de la semana 2 </h1> </center>\n",
    "\n",
    "- Día 1:\n",
    "    - Expresiones lógicas y relacionales.\n",
    "    - Indentación.\n",
    "    - Introducción a los condicionales.\n",
    "    - Instrucciones if-else.\n",
    "    \n",
    "- Día 2:\n",
    "    - Instrucciones if-else anidadas.\n",
    "    - Instrucción elif y casos.\n",
    "    - Ejercicios\n",
    "    \n",
    "- Día 3:\n",
    "    - Introducción a los ciclos.\n",
    "    - Ciclo while.\n",
    "    - Ciclo for.\n",
    "    - Introducción a los requisitos funcionales."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Enlaces de interés </h1> </center>\n",
    "\n",
    "- Enlace de la plataforma: https://lms.misiontic2022udea.com/login\n",
    "\n",
    "- Wiki de Python con muchos recursos en español: https://wiki.python.org/moin/SpanishLanguage\n",
    "\n",
    "- Correo del docente: alceballosa@unal.edu.co \n",
    "\n",
    "- Correo de permanencia: permamenciamisiontic@udea.edu.co\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Expresiones lógicas </h1> </center>\n",
    "\n",
    "</br>\n",
    "\n",
    "- Este tipo de expresiones, en esencia, realizan comparaciones. Su valor de retorno siempre es lógico, es decir, de tipo **bool**: verdadero (*True*) o falso (*False*). \n",
    "\n",
    "- Toda expresión lógica puede definire como una sucesión de expresiones lógicas, relacionales o aritméticas conectadas mediante operadores lógicos.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Operadores relacionales </h1> </center> \n",
    "\n",
    "- Las expresiones relacionales utilizan los siguientes operadores:\n",
    "\n",
    "<style type=\"text/css\">\n",
    ".tg  {border-collapse:collapse;border-spacing:0;}\n",
    ".tg td{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;\n",
    "  overflow:hidden;padding:10px 5px;word-break:normal;}\n",
    ".tg th{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;\n",
    "  font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;}\n",
    ".tg .tg-0pky{border-color:inherit;text-align:left;vertical-align:top}\n",
    "</style>\n",
    "<table class=\"tg\">\n",
    "<thead>\n",
    "  <tr>\n",
    "    <th class=\"tg-0pky\">Operador</th>\n",
    "    <th class=\"tg-0pky\">Significado</th>\n",
    "  </tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "  <tr>\n",
    "    <td class=\"tg-0pky\">></td>\n",
    "    <td class=\"tg-0pky\">Mayor que</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-0pky\">>= </td>\n",
    "    <td class=\"tg-0pky\">Mayor o igual que</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-0pky\"><</td>\n",
    "    <td class=\"tg-0pky\">Menor que</td>\n",
    "  </tr>\n",
    "   <tr>\n",
    "    <td class=\"tg-0pky\"><=</td>\n",
    "    <td class=\"tg-0pky\">Menor o igual que</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-0pky\">==</td>\n",
    "    <td class=\"tg-0pky\">Igual que</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td class=\"tg-0pky\">!=</td>\n",
    "    <td class=\"tg-0pky\">Diferente de</td>\n",
    "  </tr>\n",
    "</tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "----------\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#Ejemplos de uso de operadores relacionales\n",
    "\n",
    "a = 40\n",
    "b = 30\n",
    "c = 30\n",
    "d = 80\n",
    "rol = \"estudiante\"\n",
    "\n",
    "print(a > b) #True\n",
    "print(b >= c) #True\n",
    "print(a < d) # True\n",
    "print(40 <= b)#False\n",
    "print(\"----------\")\n",
    "print(30 == c) #True\n",
    "print(rol == \"estudiante\") #True\n",
    "print(rol != \"Estudiante\")  #True\n",
    "print(d != 80) #False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resultado = 5 > 4 > 3 > 2 != 1\n",
    "print(resultado)\n",
    "resultado = (5 > 4) and (4 > 3) and (3 > 2) and (2 != 1)\n",
    "print(resultado)\n",
    "\n",
    "resultado_2 = 4 > 1 == (0 <= 7)\n",
    "print(resultado_2)\n",
    "\n",
    "(0 <= 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Operadores lógicos </h1> </center>\n",
    "\n",
    "- Son los operadores que nos permiten construir expresiones lógicas:\n",
    "\n",
    "| Operador| Significado | \t\n",
    "|-\t|-\t|\n",
    "| or \t| disyunción  \t| \n",
    "| and \t| conjunción\t    |  \n",
    "| not \t   |  negación\t| \n",
    "| ^ \t   | disyunción exclusiva\t|  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h2> Operador relacional OR </h2> </center>\n",
    "\n",
    "| x | y | x or y|  \t\n",
    "|-\t|-\t|-\t|\n",
    "| False \t| False  \t| False \t|  \n",
    "| False \t| True\t    |  True \t|  \t\n",
    "| True \t   |  False\t|  True \t|\n",
    "|True \t   |  True\t|  True \t|  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h2> Operador lógico AND </h2> </center>\n",
    "\n",
    "| x | y | x and y|  \t\n",
    "|-\t|-\t|-\t|\n",
    "| False \t| False  \t| False \t|  \n",
    "| False \t| True\t    |  False \t|  \t\n",
    "| True \t   |  False\t|  False \t|\n",
    "|True \t   |  True\t|  True \t|  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h2> Operador lógico NOT </h2> </center>\n",
    "\n",
    "| x | not x|  \t\n",
    "|-\t|-\t|\n",
    "| False \t| True  \t \t\n",
    "| True \t   |  False\t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h2> Operador lógico XOR </h2> </center>\n",
    "\n",
    "| x | y | x ^ y|  \t\n",
    "|-\t|-\t|-\t|\n",
    "| False \t| False  \t| False \t|  \n",
    "| False \t| True\t    |  True \t|  \t\n",
    "| True \t   |  False\t|  True \t|\n",
    "|True \t   |  True\t|  False \t|  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Evaluación de conectores u operadores lógicos </h1> </center>\n",
    "\n",
    "</br>\n",
    "\n",
    "- Prioridad: primero se evalúan las negaciones (not), luego las conjunciones (and), luego las disyunciones exclusivas (xor) y por último las disyunciones (or).\n",
    "\n",
    "- Asociatividad: operadores consecutivos de la misma prioridad se evalúan de izquierda a derecha en el orden en que aparezcan. Son asociativos por la izquierda.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = 16\n",
    "b = True\n",
    "c = 4\n",
    "d = 8\n",
    "e = 5\n",
    "\n",
    "print(a > c and e <= d) #True and True -> #True\n",
    "print(b or (d - e) > a / c) # True or 3 > 4 -> #True or False > # True\n",
    "\n",
    "res = not b and c < d or a / d <= e   # not True and 4 < 8 or 2 <= 5 -> \n",
    "                                      # not True and True or True\n",
    "                                      # False and True or True\n",
    "                                      # False or True\n",
    "                                      # True\n",
    "print(res)    \n",
    "print(not res) #not True -> False\n",
    "\n",
    "#autorizado = True\n",
    "#if autorizado:\n",
    "#    print(\"Bienvenido usuario x\")\n",
    "#if(not autorizado):\n",
    "#    print(\"El acceso no está autorizado\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "-----\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = True\n",
    "b = True\n",
    "c = False\n",
    "resultado = a and b and c\n",
    "print(resultado)\n",
    "print(\"-----\")\n",
    "sub_res = a and b\n",
    "print(sub_res)\n",
    "resultado = sub_res and c\n",
    "print(resultado)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "x es de tipo <class 'int'>\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(0 == False)\n",
    "#print(1 == False)\n",
    "#print(20 == True)\n",
    "print(bool(20) == True )\n",
    "print(bool(\"xxxxxxxx\"))\n",
    "print(bool(\"\"))\n",
    "print(bool(0.00000))\n",
    "print(bool(-0.1))\n",
    "print(bool(\"False\"))\n",
    "\n",
    "#print(20 == True)\n",
    "#print(1 == True)\n",
    "\n",
    "x = 20\n",
    "print(\"x es de tipo\", type(x))\n",
    "print(\"al\"<\"Aa\")\n",
    "print(\"estudiante\"==\"estudiante\")\n",
    "\n",
    "# https://theasciicode.com.ar/ <- En general las relaciones entre palabras las da el código ASCII"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Expresiones generales </h1> </center>\n",
    "\n",
    "</br>\n",
    "\n",
    "Una expresión general es una expresión que contiene:\n",
    "\n",
    "- Operadores lógicos\n",
    "- Expresiones relacionales\n",
    "- Expresiones aritméticas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h1> Evaluaciones de expresiones generales </h1> </center>\n",
    "\n",
    "El orden de evaluación de los elementos de una expresión general es el siguiente:\n",
    "\n",
    "1. Expresiones aritméticas\n",
    "2. Expresiones relacionales\n",
    "3. Operadores lógicos\n",
    "\n",
    "- Ejemplo:\n",
    "\n",
    "<center> <img src=\"img/sem2_expr.png\"></center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ar1: 12.56\n",
      "Ar2: 14\n",
      "Ar3: 8.6\n",
      "Rel1: False\n",
      "Rel2: True\n",
      "Resultado final: True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Consideremos los siguientes valores y hagamos el ejercicio completo:\n",
    "\"\"\"\n",
    "a = 3; b = 5; radio = 2; c = 1; q = 10; r = 4   #el ; se puede usar para juntar instrucciones\n",
    "a = o = e = 3 #se usa el igual para asignar el mismo valor a varias variables \n",
    "ar1 = 3.14*radio**2 \n",
    "print(\"Ar1:\", ar1)\n",
    "ar2 = a * b - c\n",
    "print(\"Ar2:\", ar2)\n",
    "ar3 = q * (0.3 + r )/5 #10*4.3/5 \n",
    "print(\"Ar3:\", ar3)\n",
    "ar4 = 1\n",
    "rel1 = ar1 >= ar2\n",
    "print(\"Rel1:\", rel1)\n",
    "rel2 = ar3 != ar4\n",
    "print(\"Rel2:\", rel2)\n",
    "print(\"Resultado final:\", rel1 or rel2)\n",
    "print(3.14 * radio ** 2 >= a * b - c or q * (0.3 + r) / 5 != 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Control de flujo en programación </h1> </center>\n",
    "\n",
    "- El flujo es el orden en el que se ejecutan las instrucciones o líneas de código (los renglones de nuestro archivo de texto). En Python, se ejecutan de arriba hacia abajo.\n",
    "\n",
    "- Si no se interrumpe el flujo, las líneas se ejecutarán en orden hasta llegar a la última línea. Como vimos arriba, algunas líneas pueden tener más de una instrucción. En dicho caso, se ejecutan de izquierda a derecha."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "valor_1 = 5                #Primera línea\n",
    "valor_2 = 10               #Segunda línea\n",
    "print(valor_1 + valor_2)   #Tercera línea"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Indentación </h1> </center>\n",
    "\n",
    "- La *indentación* o *sangría* es el espacio en blanco que se coloca al inicio de una línea de código. \n",
    "\n",
    "- El número de espacios en blanco que se usa en Python para representar una indentación es cuatro (4) o una tabulación con la tecla TAB.\n",
    "\n",
    "- El total de indentaciones que tenga una línea se conoce como el *nivel de indentación*.\n",
    "\n",
    "- Un grupo continuo de instrucciones al mismo nivel de indentación mínimo se conoce como un **bloque de código**. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Instrucciones de decisión: if, else </h1> </center>\n",
    "\n",
    "</br>\n",
    "\n",
    "- La instrucción **if** a menudo está acompañada por el componente **else**. Esta instrucción le permite a la máquina ejecutar instrucciones determinadas dependiendo del resultado de evaluar una condición.\n",
    "\n",
    "- Después del **if** va un bloque indentado de instrucciones que se ejecutan si la condición es verdadera. Después del **else** va un bloque indentado que se ejecuta cuando la condición es falsa.\n",
    "\n",
    "- IMPORTANTE: Como parte de la notación de Python, el **if** y el **else** van acompañados del símbolo : (dos puntos).\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <img width=\"500\" src=\"img/sem2_if.png\"></center>\n",
    "\n",
    "Nota: la condición puede ser una expresión relacional o una expresión lógica."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h1> Ejercicios con la instrucción if-else </h1> </center>\n",
    "\n",
    "- Determinar si un número entero entrado por pantalla es divisible por otro número entrado también por pantalla."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese un número entero:20\n",
      "Ingrese un número entero:3\n",
      "El número 20 es positivo no es divisible por el número 3\n"
     ]
    }
   ],
   "source": [
    "num1 = int(input(\"Ingrese un número entero:\"))\n",
    "num2 = int(input(\"Ingrese un número entero:\"))\n",
    "#Un número es divisible por otro si el residuo es 0\n",
    "es_divisible = num1%num2 == 0\n",
    "num1_es_positivo = num1 >= 0\n",
    "if num1_es_positivo:\n",
    "    pos_o_neg = \"positivo\"\n",
    "else:\n",
    "    pos_o_neg = \"negativo\"\n",
    "if es_divisible:\n",
    "    #print(\"El número {} es divisible por el número {}\".format(num1, num2))\n",
    "    print(f\"El número {num1} es divisible por el otro número que escribiste\")\n",
    "else:\n",
    "    print(\"El número {0} es {2} y no es divisible por el número {1}\".format(num1, num2, pos_o_neg)) #el número en los corchetes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h1> Ejercicios con la instrucción if-else </h1> </center>\n",
    "\n",
    "- Leer tres números enteros y determinar si la suma de los dos primeros da el tercero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese un número entero:5\n",
      "Ingrese un número entero:10\n",
      "Ingrese un número entero:11\n",
      "La suma de 5 y 10 NO es igual a 11\n"
     ]
    }
   ],
   "source": [
    "num1 = int(input(\"Ingrese un número entero:\"))\n",
    "num2 = int(input(\"Ingrese un número entero:\"))\n",
    "num3 = int(input(\"Ingrese un número entero:\"))\n",
    "\n",
    "if (num1 + num2 == num3):\n",
    "    print(f\"La suma de {num1} y {num2} es igual a {num3}\")\n",
    "else:\n",
    "    print(f\"La suma de {num1} y {num2} NO es igual a {num3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h1> Ejercicios con la instrucción if-else </h1> </center>\n",
    "\n",
    "- Leer tres números enteros y determinar si con ellos se puede construir un triángulo o no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 , 10 y 4 NO pueden formar un triángulo.\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 10\n",
    "c = 4\n",
    "\n",
    "# True and True and False\n",
    "# True and False\n",
    "# False\n",
    "if (a + b > c) and (b + c > a) and (a + c > b):\n",
    "    print(f\"{a}, {b} y {c} pueden formar un triángulo.\")\n",
    "else:\n",
    "    print(a,\",\", b, \"y\", c, \"NO pueden formar un triángulo.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Uso opcional del else </h1> </center>\n",
    "\n",
    "La instrucción **else** no debe utilizarse en todos los casos. Veamos el siguiente ejemplo:\n",
    "\n",
    "- Elaborar un algoritmo que lea el salario actual de un empleado y que calcule e imprima el nuevo salario con base en la siguiente condición: si el salario es menor que 1000 pesos, aumente el 10%; de lo contrario, no haga aumento.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Escriba el salario actual 800\n",
      "salario actual  800.0 aumentó en 80.0 y el nuevo salario es 880.0\n"
     ]
    }
   ],
   "source": [
    "salact = float(input(\"Escriba el salario actual \"))\n",
    "au = 0\n",
    "if salact < 1000:\n",
    "    au = salact * 0.1\n",
    "nuesal = salact + au\n",
    "print(\"salario actual \", salact, \"aumentó en\", au, \"y el nuevo salario es\", nuesal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Escriba el salario actual 800\n",
      "salario actual  800.0 aumentó en 80.0 y el nuevo salario es 880.0\n"
     ]
    }
   ],
   "source": [
    "salact = float(input(\"Escriba el salario actual \"))\n",
    "if salact < 1000:\n",
    "    au = salact * 0.1\n",
    "else:\n",
    "    au = 0\n",
    "nuesal = salact + au\n",
    "print(\"salario actual \", salact, \"aumentó en\", au, \"y el nuevo salario es\", nuesal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Uso obligatorio del else </h1> </center>\n",
    "\n",
    "Sin embargo, hay muchos casos en los que es imprescindible usarla para representar el flujo de trabajo que se necesita para un ejercicio. Veamos otro ejemplo:\n",
    "\n",
    "- Elaborar un algoritmo que lea dos datos numéricos enteros y que los imprima ordenados ascendentemente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "entre un número entero: 1\n",
      "entre otro número entero: 2\n",
      "1 2\n"
     ]
    }
   ],
   "source": [
    "a = int(input(\"entre un número entero: \"))\n",
    "b = int(input(\"entre otro número entero: \"))\n",
    "if a < b:\n",
    "    print(a, b)\n",
    "else:\n",
    "    print(b, a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Anidamiento en programación </h1> </center>\n",
    "\n",
    "- El anidamiento es un concepto clave en la mayoría de lenguajes de programación.\n",
    "\n",
    "- En esencia, nos indica que podemos elaborar operaciones o estructuras de mayor complejidad al insertar bloques de instrucciones o conjuntos de datos dentro de otros elementos de tipo similar.\n",
    "\n",
    "- Nota: no es recomendable abusar del anidamiento si este no es necesario."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Instrucciones de decisión anidadas </h1> </center>\n",
    "\n",
    "- Las instrucciones **if-else** anidadas permiten generar estructuras de decisión más complejas. \n",
    "\n",
    "- Un bloque de decisión anidado solo se evaluará si se cumple la condición que lo engloba (o si se entra al **else**).\n",
    "\n",
    "<center> <img width=\"650\" src=\"img/sem2_anid.png\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h1> Ejercicios con la instrucción if anidada </h1> </center>\n",
    "\n",
    "Se tiene un conjunto de personas, cada una con la siguiente información:\n",
    "- Género: 0 representa femenino, 1 representa masculino\n",
    "- Peso en kilogramos\n",
    "- Estatura en centímetros\n",
    "\n",
    "Se requiere caracterizar sus aptitudes con base en el género, la estatura y el peso:\n",
    "- Reina de belleza, si mide más de 180 cm, pesa más de 70 kilos y es mujer\n",
    "- Cantautor, si mide más de 180 cm, pesa más de 70 kilos y es hombre\n",
    "- Árbitro de fútbol, si mide más de 180 cm y pesa menos de 70 kilos\n",
    "- Jugador de parqués, si mide 180 cm o menos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese el género (0 [mujer] o 1 [hombre]):0\n",
      "Es reina de belleza\n"
     ]
    }
   ],
   "source": [
    "genero = int(input(\"Ingrese el género (0 [mujer] o 1 [hombre]):\"))\n",
    "peso = 71\n",
    "estatura = 184\n",
    "\n",
    "if estatura > 180:\n",
    "    if peso > 70: \n",
    "        if genero == 0:\n",
    "            print(\"Es reina de belleza\")\n",
    "        else:\n",
    "            print(\"Es cantautor\")\n",
    "    else:\n",
    "        print(\"Es arbitro de fútbol\")\n",
    "else:\n",
    "    print(\"Es jugador de parqués\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Ejercicios con la instrucción if anidada </h1> </center>\n",
    "\n",
    "Construya un programa de computador que lea tres números enteros y los escriba ordenados ascendentemente."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Analícemos estas tres opciones de solución...\n",
    "\n",
    "<center> <img width=\"650\" src=\"img/sem2_ej.jpg\"></center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Construya un programa de computador que lea tres números enteros y los escriba ordenados ascendentemente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Instrucción de decisión elif para selección múltiple</h1> </center>\n",
    "\n",
    "- Esta instrucción es una abreviación de las palabras **else if** y se usa cuando no se cumpla la condición del if pero sí necesitamos que se cumpla alguna otra condición.\n",
    "\n",
    "- La instrucción **elif** puede o no estar acompañada de una instrucción **else**. Sin embargo, la instrucción **else** no puede venir seguida de ninguna otra instrucción de decisión (salvo que creemos un nuevo bloque de decisión).\n",
    "\n",
    "- Esta instrucción es muy útil para generar estructuras de decisión donde hay muchas decisiones consecutivas que no están anidadas unas dentro de otras (es un equivalente del **switch**/**case** de otros lenguajes, aunque este se implementó en la versión 3.10 de Python)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```python\n",
    "if condicion_1:\n",
    "    instrucciones que se ejecutan cuando la condición 1 es verdadera\n",
    "elif condicion_2:\n",
    "    instrucciones que se ejecutan cuando la condición 2 es verdadera\n",
    "...\n",
    "\n",
    "elif condicion_n:\n",
    "    instrucciones que se ejecutan cuando la condición n es verdadera\n",
    "else:\n",
    "    instrucciones que se ejecutan cuando ninguna condición es verdadera\n",
    "   ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h1> ¿Cuándo uso if-else y cuando uso if-elif? </h1> </center>\n",
    "\n",
    "- Cuando el resultado de una comparación solo da dos alternativas, se utiliza la instrucción if - else.\n",
    "- Cuando el resultado de una comparación da más de dos alternativas, se utiliza la estructura if – elif – else."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Ejercicio con elif</h1> </center>\n",
    "\n",
    "\n",
    "Elaborar un algoritmo que lea el nombre de una persona y su estado civil. El estado civil está codificado con un dígito y con los siguientes significados.  El algoritmo debe imprimir el nombre leído y la descripción correspondiente al estado civil leído. \n",
    "\n",
    "1. Soltero\n",
    "2. Casado\n",
    "3. Separado\n",
    "4. Viudo\n",
    "5. Unión libre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Analícemos estas dos opciones de solución...\n",
    "\n",
    "<center> <img width=\"650\" src=\"img/sem2_posibles.png\"></center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese su nombre:Mario\n",
      "Mario, ingrese el código de su estado civil:4\n",
      "Mario, ingrese el género de su pareja o ex-pareja [0-1]: 1\n",
      "El estado civil de Mario es viudo\n",
      "Estuvo casado con un hombre.\n"
     ]
    }
   ],
   "source": [
    "nombre = input(\"Ingrese su nombre:\")\n",
    "cod_estado = int(input(f\"{nombre}, ingrese el código de su estado civil:\"))\n",
    "genero_pareja = int(input(f\"{nombre}, ingrese el género de su pareja o ex-pareja [0-1]: \"))\n",
    "if cod_estado == 1:\n",
    "    print(f\"El estado civil de {nombre} es soltero\")\n",
    "elif cod_estado == 2:\n",
    "    print(f\"El estado civil de {nombre} es casado\")  \n",
    "    if genero_pareja == 0:\n",
    "        print(\"Está casado con una mujer.\")\n",
    "    else:\n",
    "        print(\"Está casado con un hombre.\")\n",
    "elif cod_estado == 3:\n",
    "    print(f\"El estado civil de {nombre} es separado\")\n",
    "    if genero_pareja == 0:\n",
    "        print(\"Estuvo casado con una mujer.\")\n",
    "    else:\n",
    "        print(\"Estuvo casado con un hombre.\")\n",
    "elif cod_estado == 4:\n",
    "    print(f\"El estado civil de {nombre} es viudo\")\n",
    "    if genero_pareja == 0:\n",
    "        print(\"Estuvo casado con una mujer.\")\n",
    "    else:\n",
    "        print(\"Estuvo casado con un hombre.\")\n",
    "elif cod_estado == 5:\n",
    "    print(f\"El estado civil de {nombre} es unión libre\")\n",
    "    if genero_pareja == 0:\n",
    "        print(\"Está en unión libre con una mujer.\")\n",
    "    else:\n",
    "        print(\"Está en unión libre con un hombre.\")\n",
    "else:\n",
    "    print(f\"ERROR, el estado civil de {nombre} no está registrado\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Ejercicio con instrucciones if-else anidadas y elif </h1> </center>\n",
    "\n",
    "La empresa de aviación “El pájaro loco” presta servicios entre cinco ciudades, las cuales tiene codificadas así:\n",
    "\n",
    "1. Medellín\n",
    "2. Bogotá\n",
    "3. Cali\n",
    "4. Barranquilla\n",
    "5. Miami"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "El costo de los tiquetes está definido según sea la ciudad origen, la ciudad destino y la edad del pasajero:\n",
    "\n",
    "- Medellín a Bogotá: 200.000 pesos más 10.000 pesos si el pasajero es menor de 60 años.\n",
    "\n",
    "- Medellín a Cali: 250.000 pesos menos el 10% de la edad del pasajero por 1000.\n",
    "\n",
    "- Medellín a Barranquilla: 300.000 pesos más la edad del pasajero por 1000.\n",
    "\n",
    "- Bogotá a Medellín: 200.000 pesos, o gratis si el pasajero es mayor de 80 años.\n",
    "\n",
    "- Bogotá a Cali: 200.000 pesos más 1000 pesos por cada año que sea menor de 60 años, sin sobrepasar los 20.000 pesos.\n",
    "\n",
    "- Bogotá a Barranquilla: 400.000 pesos más el 5% de la edad del pasajero por 10.000 si es mayor de 60 años."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Cali a Medellín: 350.000 pesos.\n",
    "\n",
    "- Cali a Bogotá: 280.000 pesos más 20.000 pesos si el pasajero es menor de 60 años.\n",
    "\n",
    "- Cali a Barranquilla: 190.000 pesos más 10.000 pesos si el pasajero es menor de 60 años.\n",
    " \n",
    "- Barranquilla a Cali: 350.000 pesos más 10.000 pesos por cada año que sea mayor de 60 años.\n",
    " \n",
    "- Barranquilla a Bogotá: 210.000 pesos más 30.000 pesos si el pasajero es menor de 30 años.\n",
    "\n",
    "- Barranquilla a Medellín: 500.000 pesos o 250.000 si la edad del pasajero es inferior a 10 años.\n",
    "\n",
    "- Cualquier vuelo que tenga Miami como origen o destino tiene un costo de 980.000 pesos.\n",
    "\n",
    "Elabore un programa de computador que determine el costo del tiquete conociendo los códigos de la ciudad origen, el destino y la edad del pasajero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese su edad: 40\n",
      "Ingrese la ciudad de salida:4\n",
      "Ingrese la ciudad de destino:1\n"
     ]
    }
   ],
   "source": [
    "edad = int(input(\"Ingrese su edad: \"))\n",
    "ciudad1 = int(input(\"Ingrese la ciudad de salida:\"))\n",
    "ciudad2 = int(input(\"Ingrese la ciudad de destino:\"))\n",
    "\n",
    "if 1 <= ciudad1 <= 5 and 1 <=ciudad2 <= 5 and ciudad1 != ciudad2 and edad > 3:\n",
    "    \n",
    "    if ciudad1 == 5 or ciudad2 == 5:\n",
    "        precio = 980000\n",
    "    \n",
    "    elif ciudad1 == 1: #origen Medellín\n",
    "        if ciudad2 == 2: #destino Bogotá\n",
    "            if edad < 60:\n",
    "                precio = 210000\n",
    "            else:\n",
    "                precio = 200000\n",
    "        elif ciudad2 == 3: #destino Cali\n",
    "            precio = 250000 - 1000*edad*0.1\n",
    "        elif ciudad2 == 4: #destino Barranquilla\n",
    "            precio = 300000 + 1000*edad\n",
    "            \n",
    "    elif ciudad1 == 2: #origen Bogotá\n",
    "        if ciudad2 == 1: #destino Medellín\n",
    "            if edad >= 80:\n",
    "                precio = 0\n",
    "            else:\n",
    "                precio = 200000\n",
    "        elif ciudad2 == 3: #desitno Cali\n",
    "            if edad < 60:\n",
    "                incr = (60 - edad)*1000\n",
    "                if incr > 20000: \n",
    "                    incr = 20000\n",
    "                precio = 200000 + incr\n",
    "            else:\n",
    "                precio = 200000\n",
    "        elif ciudad2 == 4: #dest Barranq\n",
    "            precio = 400000\n",
    "            if edad >= 60:\n",
    "                precio = precio + 0.05*edad*10000\n",
    "    \n",
    "    elif ciudad1 == 3: #origen Cali\n",
    "        if ciudad2 == 1: #destino Med\n",
    "            precio = 350000\n",
    "        elif ciudad2 == 2: #destino Bogotá\n",
    "            precio = 280000\n",
    "            if edad < 60:\n",
    "                precio = precio + 20000\n",
    "        elif ciudad2 == 4: #destino bq\n",
    "            precio = 190000\n",
    "            if edad < 60:\n",
    "                precio = precio + 10000\n",
    "                \n",
    "else:\n",
    "    print(\"Los datos de las ciudades o de la edad son inválidos. Verifique por favor.\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Ejercicio con instrucciones if-else anidadas y elif </h1> </center>\n",
    "\n",
    "Elaborar un algoritmo que lea nombre de un empleado, estado civil, edad y salario actual. Para el empleado leído, determinar el nuevo salario con base en las siguientes políticas:\n",
    "\n",
    "- Soltero menor de 30 años: se le aumenta el 10% de su salario actual\n",
    "- Soltero mayor de 30 años: se le aumenta el 12% de su salario actual\n",
    "- Casado menor de 25 años: se le aumenta el 12% de su salario actual\n",
    "- Casado mayor de 25 años: se le aumenta el 15% de su salario actual\n",
    "- Separado menor de 20 años: se le aumenta el 8% de su salario actual\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Separado mayor de 20 años: se le aumenta el 10% de su salario actual\n",
    "- Viudo menor de 30 años: se le aumenta el 15% de su salario actual\n",
    "- Viudo mayor de 30 años: se le aumenta el 12% de su salario actual\n",
    "- Empleado en unión libre que devengue menos de 1000 pesos: se le aumenta el 20% de su salario actual\n",
    "- Empleado en unión libre que devengue más de 1000 pesos: se le aumenta el 12% de su salario actual\n",
    "\n",
    "El algoritmo deberá determinar el aumento del empleado leído e imprimir nombre, estado civil, descripción del estado civil, edad, salario actual, porcentaje de aumento, aumento y nuevo salario. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "   1 Soltero   2 Casado   3 Separado   4 Viudo   5 Unión libre\n",
    "\"\"\"\n",
    "nombre = input(\"Escriba su nombre:\")\n",
    "estado = int(input(\"Ingrese su estado civil:\"))\n",
    "edad = int(input(\"Ingrese su edad:\"))\n",
    "sal_actual = float(input(\"Ingrese su salario actual:\"))\n",
    "\n",
    "sal_nuevo = sal_actual\n",
    "\n",
    "if estado == 1: #soltero\n",
    "    if edad < 30:\n",
    "        sal_nuevo = sal_actual + sal_actual*0.1\n",
    "    else:\n",
    "        sal_nuevo = sal_actual + sal_actual*0.12\n",
    "        \n",
    "elif estado == 2: #casado\n",
    "    if edad < 25:\n",
    "        sal_nuevo = sal_actual + sal_actual*0.12\n",
    "    else:\n",
    "        sal_nuevo = sal_actual + sal_actual*0.15\n",
    "\n",
    "elif estado == 3: #separado\n",
    "    if edad < 20:\n",
    "        sal_nuevo = sal_actual + sal_actual*0.08\n",
    "    else:\n",
    "        sal_nuevo = sal_actual + sal_actual*0.1\n",
    "        \n",
    "else:\n",
    "    print(\"Estado civil inválido\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no está\n"
     ]
    }
   ],
   "source": [
    "a = 4\n",
    "\n",
    "if 1 <= a <= 3:\n",
    "    print(\"está en el rango\")\n",
    "else:\n",
    "    print(\"no está\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}