Semana_3_1_Jugando_con_la_Logica.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_ti4LOfKU8i3"
      },
      "source": [
        "![Data Science Black@300x.png](https://i.imgur.com/eJKkh5m.png)\n",
        "\n",
        "# ¡Bienvenidos al taller \"Learning to Code with Dell Technologies\"!\n",
        "\n",
        "En este \"notebook\" vamos a jugar con la lógica.\n",
        "\n",
        "Si pasa esto y eso luego realiza aquello Sino al mejor eso.\n",
        "\n",
        "## ¿Lógica?\n",
        "\n",
        "En efecto en Python puedes cambiar el destino de tus instrucciones dandole un toque de lógica a tus programas."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fH4jW8YFroxX"
      },
      "source": [
        "\n",
        "# OPERADORES DE COMPARACION\n",
        "\n",
        "Los operadores de comparación nos ayudan a comparar un valor con otro. Cuando usamos operadores de comparación, nos devuelven una respuesta verdadera o falsa (TRUE / FALSE) conocida como tipo booleano. Los operadores de comparación y los booleanos son muy importantes porque nos ayudan a tomar decisiones en nuestro código.\n",
        "\n",
        "# MAYOR QUE (>)\n",
        "\n",
        "Cuando lo usa, la computadora decide si el valor en el lado izquierdo del símbolo> es mayor que el valor en el lado derecho del símbolo."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6uw81PGfvl1p"
      },
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B2D3KN1pC7Yc",
        "outputId": "6872a268-27ed-41f7-8e6a-82256e8d2f1a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 1,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "3>4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jJLz5WxNCrID",
        "outputId": "d7604a77-1982-40a5-f8fe-af05a66f5548"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 2,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "10>5"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V4xdnL89DFM0"
      },
      "source": [
        "# MENOR QUE (<)\n",
        "Esta vez estamos averiguando si el valor a la izquierda del símbolo < es menor que el valor a la derecha del símbolo <."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FwH4908JDwlz",
        "outputId": "b0a12a58-b50f-45d3-9932-71044af76200"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 3,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "3<4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6c8ApNquD0KY",
        "outputId": "52774d59-71ba-4f00-8b1b-176e26521115"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 4,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "10<5"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tnaM7IxDD9QT"
      },
      "source": [
        "# MAYOR O IGUAL A (>=)\n",
        "Cuando lo usamos como operador, cuando estamos decidiendo en parte si el valor de la izquierda del operador >= es igual o mayor al valor de la derecha del operador"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J4AScJoIEp21",
        "outputId": "1fde22be-cdfc-4f53-95b7-6233e5d52b75"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 5,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "5>=5"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qhv7mqxTEsj_",
        "outputId": "0e04229c-5f3e-4e36-b4e7-d16306376b76"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 6,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "4>=2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZcwiMIObEwFY"
      },
      "source": [
        "# MENOR O IGUAL A (<=)\n",
        "Para el operador menor o igual a, miramos los valores si el valor a la izquierda del operador <= es menor que el de la derecha del operador <= o el mismo que el del operador <= derecho.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "syuZJ-M_E6cm",
        "outputId": "99b66cfe-864b-424c-e8e7-375516b79011"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 7,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "1<=3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wSOpT4WlE8_i",
        "outputId": "9bbdd10f-1e78-438a-a8cb-85089d72066c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 8,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "15<=15"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TT07ujBQE__A"
      },
      "source": [
        "# IGUAL A\n",
        "Este es más simple, le pide a la computadora que decida si el valor a la izquierda del símbolo == es el mismo que el valor a la derecha del símbolo ==.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_XOOQv39FJDp",
        "outputId": "a3bebecf-53d7-4744-e55d-633072b52dc2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 9,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "20==20"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eo-yk_GPFe-k"
      },
      "source": [
        "# OPERADORES LOGICOS\n",
        "se utilizan para ayudarnos a comparar operandos verdaderos o falsos. Estos son muy útiles porque pueden hacer que nuestra decisión de hacer reglas sea más compleja. Lo que significa un código más inteligente. Hay tres operadores lógicos principales\n",
        "\n",
        "# AND\n",
        "\n",
        "El operador AND comprueba que los valores a la derecha e izquierda sean ambos TRUE. Si hay un punto en nuestro código que solo debe ejecutarse cuando se cumplen dos condiciones, debemos usar el operador AND.\n",
        "\n",
        "# OR\n",
        "El operador OR comprueba para asegurarse de que al menos un valor que se está comparando sea TRUE.\n",
        "\n",
        "# NOT\n",
        "El operador NOT comprueba para asegurarse de que el valor que se está comparando sea FALSE.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LrOys0aMHeGb",
        "outputId": "5f679e70-bed4-4596-978b-885cd857b675"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "A and B is False\n",
            "A or B is True\n",
            "not A is True\n"
          ]
        }
      ],
      "source": [
        "A = True\n",
        "B = False\n",
        "\n",
        "print('A and B is', A and B)\n",
        "\n",
        "print('A or B is', A or B)\n",
        "\n",
        "print('not A is', not B)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aY9GutdBUfsz",
        "outputId": "ae9913bb-9335-4981-c180-ad658eff2645"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "at least one of the statements is true\n"
          ]
        }
      ],
      "source": [
        "if 590 == 110 or 99 == 99 :\n",
        "    print(\"at least one of the statements is true\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5J3FiXlBVH1G",
        "outputId": "11154a03-8690-4845-e915-d67a74ab5f33"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10 is divisible by either 3 or 5\n"
          ]
        }
      ],
      "source": [
        "a = 10\n",
        "  \n",
        "if not a:\n",
        "    print(\"Boolean value of a is True\")\n",
        "else:\n",
        "    print(\"10 is divisible by either 3 or 5\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o91wwaCOPs_F"
      },
      "source": [
        "# Condicionales\n",
        "\n",
        "Cuando escribimos código Python es posible ejecutar instrucciones dependiendo de que una condicion especifica.\n",
        "\n",
        "## Indentacion\n",
        "\n",
        "En Python verás que cada espacio de código esta identado osea, que dejamos espacio para identificar los bloques de código. Esto es parte de la syntaxis de Python.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 135
        },
        "id": "g32YNeAhQeUt",
        "outputId": "ce5d0a8f-15f5-4385-de59-4946af9c7c83"
      },
      "outputs": [
        {
          "ename": "IndentationError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-a01f4e1a1464>\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m    print(\"Hola Ana!\")\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
          ]
        }
      ],
      "source": [
        "nombre = \"Ana\"\n",
        "\n",
        "if nombre == \"Ana\":\n",
        "print(\"Hola Ana!\") # Este bloque de código debe estar espaciado al principio, por mejor practica se usan siempre 4 espacios"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uMoXajTHSBGZ"
      },
      "source": [
        "# IF STATEMENT\n",
        "\n",
        "Es un bloque de codigo que nos permite controlar el camino que la computadora cuando ejecuta el codigo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pr5QT_PUSAzl",
        "outputId": "cdabf5de-6f00-4e72-bfd3-681be8868fb3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "el lunes cae la lluvia,entonces no hay escuela\n"
          ]
        }
      ],
      "source": [
        "clima = input(\"\"\"\n",
        "Como esta el clima?\n",
        "- soleado\n",
        "- lluvioso\n",
        "- nublado\n",
        "\"\"\")\n",
        "\n",
        "if clima == \"soleado\":\n",
        "    print (\"El dia esta soleado, podemos ir al parque🌞🏞️🚶 \")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JOxy3pE8T66p",
        "outputId": "3ea32aec-a808-4c0d-cefa-1c340cb46c0c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10 is a positive number.\n",
            "This is always printed.\n",
            "This is also always printed.\n"
          ]
        }
      ],
      "source": [
        "num = 10\n",
        "if num > 0:\n",
        "    print(num, \"is a positive number.\")\n",
        "print(\"This is always printed.\")\n",
        "\n",
        "num = -5\n",
        "if num > 0:\n",
        "    print(num, \"is a positive number.\")\n",
        "print(\"This is also always printed.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y6kSNg5gO8F7"
      },
      "source": [
        "# ELSE\n",
        "\n",
        "Es una forma de ejecutar código si la condicion if no se cumple"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rP8IMB_UB4x-"
      },
      "outputs": [],
      "source": [
        "clima = input(\"\"\"\n",
        "Como esta el clima?\n",
        "- soleado\n",
        "- lluvioso\n",
        "- nublado\n",
        "\"\"\")\n",
        "\n",
        "if clima == \"soleado\":\n",
        "    print (\"El dia esta soleado, podemos ir al parque🌞🏞️🚶 \")\n",
        "else:\n",
        "    print(\"No conozco ese clima 🤔\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8z89VkmOPCRK"
      },
      "outputs": [],
      "source": [
        "edad = 18\n",
        "\n",
        "if edad >= 18:\n",
        "    print(\"Eres mayor de edad!\")\n",
        "else:\n",
        "    print(\"Todavia eres menor de edad!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L2CybcUDO-7r"
      },
      "source": [
        "# ELIF\n",
        "\n",
        "Con esta condición `elif` agregamos la posibilidad de incluir una condicion si la primera no se cumple."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qCDuy1vMB4x_"
      },
      "outputs": [],
      "source": [
        "clima = input(\"\"\"\n",
        "Como esta el clima?\n",
        "- soleado\n",
        "- lluvioso\n",
        "- nublado\n",
        "\"\"\")\n",
        "\n",
        "if clima == \"soleado\":\n",
        "    print (\"El dia esta soleado, podemos ir al parque🌞🏞️🚶 \")\n",
        "elif clima == \"lluvioso\":\n",
        "    print (\"El dia esta lluvioso, mejor nos quedamos en la casa 🏠⛈️\")\n",
        "elif clima == \"nublado\":\n",
        "    print(\"El dia esta nublado, ten cuidado con los rayos ⚡\")\n",
        "else:\n",
        "    print(\"No conozco ese clima 🤔\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PuFOw7jbRf7l"
      },
      "outputs": [],
      "source": [
        "edad = 18\n",
        "\n",
        "if edad >= 18:\n",
        "    print(\"Eres mayor de edad!\")\n",
        "elif edad >= 0:\n",
        "    print(\"Todavia eres menor de edad!\")\n",
        "else:\n",
        "    print(\"Edad inválida!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2MS5eFWQS_UV"
      },
      "source": [
        "# Ejercicios"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8NtefTRkYmoj"
      },
      "source": [
        "Vamos a ver un programa que adivina tu numero:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Xv_9mNmmYlMb"
      },
      "outputs": [],
      "source": [
        "import random\n",
        "\n",
        "Numero_Adivinado = input('Adivina un numero del 1 al 10 ')\n",
        "Numero_Ganador = random.randint(1, 10)\n",
        "\n",
        "if Numero_Adivinado == str(Numero_Ganador):\n",
        "    print('Feliciadades lo has logrado')\n",
        "elif float(Numero_Adivinado) >= 11:\n",
        "    print('Leistes bien?')\n",
        "else:\n",
        "    print('El numero ganador era {}'.format(Numero_Ganador))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tIpu0504O0pj"
      },
      "source": [
        "# Talleres\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sx1Edje2KFiR"
      },
      "source": [
        "1. Escribe un programa en Python para convertir temperaturas a y desde celsius, fahrenheit.\n",
        "\n",
        "[Fórmula : c/5 = f-32/9 [ donde c = temperatura en celsius y f = temperatura en fahrenheit ]\n",
        "\n",
        "Resultado esperado :\n",
        "60°C es 140 en Fahrenheit\n",
        "45°F es 7 en Celsius\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cnJ1ZUJvKG5P"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V89H0yULSaP-"
      },
      "source": [
        "\n",
        "2. Escribe un programa en Python para calcular la edad de un perro en años de perro\n",
        "Nota: Durante los dos primeros años, un año canino equivale a 10,5 años humanos. Después, cada año canino equivale a 4 años humanos.\n",
        "Resultado esperado:\n",
        "\n",
        "Introduzca la edad de un perro en años humanos: 15                                    \n",
        "La edad del perro en años de perro es 73"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8uDdZs0XSbPe"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TIbK4XqaSlIO"
      },
      "source": [
        "3. Escribe un programa en Python para comprobar si un alfabeto es una vocal o una consonante\n",
        "Salida esperada:\n",
        "\n",
        "Introduce una letra del alfabeto: k                                       \n",
        "k es una consonante.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yTSWvdw-Sm0u"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aBc3SqygS5mm"
      },
      "source": [
        "4. Escribe un programa en Python para convertir el nombre del mes en un número de días\n",
        "Salida esperada:\n",
        "\n",
        "Lista de meses: Enero, Febrero, Marzo, Abril, Mayo, Junio, Julio, Agosto\n",
        ", septiembre, octubre, noviembre, diciembre                                \n",
        "Introduzca el nombre del mes: Febrero                                       \n",
        "Número de días: 28/29 días \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cwsvo7qPS6m2",
        "outputId": "fda032a8-35c8-4e14-c08a-dc5fa2b66ee2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "List of months: January, February, March, April, May, June, July, August, September, October, November, December\n",
            "Input the name of Month: February\n",
            "No. of days: 28/29 days\n"
          ]
        }
      ],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "Semana_3_1_Jugando_con_la_Logica.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}