Python_Data_Science.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/AlejandroMontoyaT/Python_Data_Science/blob/main/Python_Data_Science.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Python para Data Science\n",
        "\n",
        "Notebook para el curso de Python para Data Science publicado en la plataforma de [Alura Latam](https://www.aluracursos.com/)"
      ],
      "metadata": {
        "id": "lQx6Mmv0OJyT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Introducción a Python\n",
        "¡Vamos a conocer Python, nuestro ambiente de estudio, y también generaremos nuestro primer código en este lenguaje!"
      ],
      "metadata": {
        "id": "7SiB6JIpYKmY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Google Colaboratory\n",
        "\n",
        "Ya aprendimos qué es [Python](https://www.python.org/) y ahora aprenderemos a usar nuestra herramienta de ejecución [Google Colaboratory](https://colab.research.google.com/) para programar en un notebook interactivo.\n",
        "\n",
        "Vamos a probar algunas funciones de este ambiente."
      ],
      "metadata": {
        "id": "Yugfb3fCOYY9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        " **`>>> Usa esta celda para mover <<<`**"
      ],
      "metadata": {
        "id": "2iUHQsJasJAk"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "o7jrX_iKhdkU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## ¡Hola mundo!\n",
        "\n",
        "Vamos a conocer un poco más de cerca nuestro notebook. Para ello ejecutaremos nuestro primer comando en Python: [`print()`](https://docs.python.org/3/library/functions.html#print)"
      ],
      "metadata": {
        "id": "aLSFP2V7XTfe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print (\"hola mundo\")"
      ],
      "metadata": {
        "id": "0qZX8_ZQBYyk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c07415c1-d72d-4f0f-a619-574db7656470"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hola mundo\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Reto de Data \")"
      ],
      "metadata": {
        "id": "GLMzF_AKBY7a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c1335559-39b8-49fb-9890-d7ec41ef0ad2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reto de Data \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Nombre: Alexander\")\n",
        "print(\"Apellido: Mota\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B4ziib0oPlgN",
        "outputId": "ca858594-d3db-4810-abe6-fcb2e528661f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Nombre: Alexander\n",
            "Apellido: Mota\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Manipulando los datos\n",
        "\n",
        "Vamos a aprender sobre las variables en Python, cómo declararlas y utilizarlas además de conocer otros comandos de este lenguaje. :D"
      ],
      "metadata": {
        "id": "iP8uWQmFYFRs"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "doB1n1ZIStME"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Variables\n",
        "\n",
        "En Data Science trabajamos con varios tipos de datos e informaciones, entonces es esencial saber cómo trabajar con las variables."
      ],
      "metadata": {
        "id": "sLNVmnTbag1Z"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Las variables en Python se crean cuando atribuimos un valor a ella.\n",
        "\n",
        "Para esto, colocamos el nombre de la variable, el signo de igual (`=`) y el valor que queremos atribuirle."
      ],
      "metadata": {
        "id": "lsCY0wahAbf6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "5"
      ],
      "metadata": {
        "id": "vsHh5buZADND",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d2e12a3c-7ef1-4417-e4ac-4bbeef7a0f3e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "id(5)"
      ],
      "metadata": {
        "id": "sivPtqSjADQV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f07b675a-2650-4da7-c937-be04ed65ee0c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10750984"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "edad = 5"
      ],
      "metadata": {
        "id": "JC8jO47wADlm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(id(edad))\n",
        "print(id(5))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m3o-ytPKTQgN",
        "outputId": "eaa55ea6-f1a7-42d9-9bea-c6847d1ddc62"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10750984\n",
            "10750984\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "numerocinco= 5"
      ],
      "metadata": {
        "id": "sXFDrNSuTQ4u"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "id(numerocinco)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TWXpYO97TRNA",
        "outputId": "9499c29d-622e-4e1a-984c-91c95cb56cb4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10750984"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nombre ='gabriel'"
      ],
      "metadata": {
        "id": "pxBfXlf5TnOu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "id('gabriel')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zAARukmqT3BH",
        "outputId": "4a444b76-d508-4da9-dd81-69501e57f463"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "134340732359664"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "id(nombre) #probando los comentarios"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BEfX80VPUCmD",
        "outputId": "bf782ac6-b9ac-411d-bb44-12b22d909dc6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "134340732359664"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Existen algunos tipos de nomes que **no** podemos definir para las variables:\n",
        "\n",
        "- **Nombres que comiencen con números**\n",
        "  - Ejemplos: `10_notas`, `2_nombre_casa`, etc.\n",
        "- **Palabras separadas por espacio**\n",
        "  - Ejemplos: `Nombre escuela`, `notas estudiantes`, etc.\n",
        "- **Nombres de funciones de Python**\n",
        "  - Ejemplos: `print`, `type`, etc."
      ],
      "metadata": {
        "id": "om2N0jHKAzwL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "n6l1a8pjToQU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "> Las letras mayúsculas y minúsculas generarán diferentes variables. La variable `edad` es diferente de `Edad` que a su vez es diferente de `EDAD`:\n",
        "``` Python\n",
        "edad = 1\n",
        "Edad = 2\n",
        "EDAD = 3\n",
        "_edad = 4\n",
        "_edad_ = 5\n",
        "print(edad, Edad, EDAD, _edad, _edad_)\n",
        "1 2 3 4 5\n",
        "```"
      ],
      "metadata": {
        "id": "A19vY2GVMujB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Tipos de variables\n",
        "\n",
        "Cada variable contiene una clase específica con respecto al tipo de objeto al cual esta hace referencia. Estas clases serán diferentes de acuerdo con el tipo de dato que le sea atribuido a una variable.\n",
        "\n",
        "Para conocer la clase de cada elemento usamos la función [`type()`](https://docs.python.org/3/library/functions.html#type)"
      ],
      "metadata": {
        "id": "UqhzuBhBHsps"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "edad = 5"
      ],
      "metadata": {
        "id": "J5a9t73A_-PX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type (edad)"
      ],
      "metadata": {
        "id": "rqmO1ew-_-So",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "608a1fa4-494f-4c06-d1da-3dfc1d79cc88"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "promedio = 9.5"
      ],
      "metadata": {
        "id": "xkrPMkeY_-cP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type (promedio)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CobiWW6hXRoC",
        "outputId": "28421226-6f6a-4b8a-db43-26984f6cdf75"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nombre = 'gabriel'\n",
        "type ('gabriel')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9TE835hZXaQz",
        "outputId": "663671aa-ee14-45c0-feb6-752066901d30"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "v = True\n",
        "type (v)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GJ1ajUWBXh1u",
        "outputId": "c6fdd9b6-9771-4fca-97a8-63f7f16c57f2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "bool"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "En un conjunto de datos escolares podemos tener varios tipos de informaciones. Supongamos que tenemos acceso a la ficha de datos del alumno *Penélope Camacho*, cómo transformamos este nombre en variables de Python?\n",
        "\n",
        "#### Ficha:\n",
        "\n",
        "- Nombre: Penélope Camacho\n",
        "- Edad: 11 años\n",
        "- Promedio del semestre: 9,75\n",
        "- Situación de aprobación: Verdadera (aprobado)"
      ],
      "metadata": {
        "id": "O-FxDumfWu0C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nombre_estudiante ='Penelope Camacho'\n",
        "edad_estudiante = 11\n",
        "promedio_estudiante = 9.75\n",
        "aprobado_estudiante = True\n",
        "\n",
        "print(nombre_estudiante,edad_estudiante,promedio_estudiante,aprobado_estudiante)\n",
        "print(type(nombre_estudiante),type(edad_estudiante),type(promedio_estudiante),type(aprobado_estudiante))"
      ],
      "metadata": {
        "id": "IZLQnZUj_8bd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f1b78e07-f70a-4275-b82a-2d94422852f2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Penelope Camacho 11 9.75 True\n",
            "<class 'str'> <class 'int'> <class 'float'> <class 'bool'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Variables numéricas\n",
        "\n",
        "Entre los tipos de datos numéricos vamos a enfocarnos en los tipos `entero` y `float`."
      ],
      "metadata": {
        "id": "KFq_8Sxf-OG0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Tenemos una tabla de información sobre los diversos cargos, cantidad de personas empleadas y el salario correspondiente:\n",
        "\n",
        "|Cargo | Cantidad | Salario|\n",
        "|---|---|---|\n",
        "|Vigilante | 5 | 300 |\n",
        "|Docente | 16| 500|\n",
        "|Coordinador| 2 |600|\n",
        "\n",
        "Necesitamos trabajar con estos datos para obtener:\n",
        "\n",
        "- La cantidad total de empleados;\n",
        "- La diferencia entre el salario más bajo y más alto; y\n",
        "- El promedio ponderado de los salarios de los empleados de la escuela."
      ],
      "metadata": {
        "id": "8_HYUbkVYdQY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "c_vigilante = 5\n",
        "s_vigilante = 300\n",
        "\n",
        "c_docente = 16\n",
        "s_docente = 500\n",
        "\n",
        "c_coordinador = 2\n",
        "s_coordinador = 600"
      ],
      "metadata": {
        "id": "F_X-wxdm_5Ys"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "total_empleados = c_vigilante + c_docente + c_coordinador\n",
        "total_empleados"
      ],
      "metadata": {
        "id": "gKmBbhII_5b9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "64d0fd2e-ccf1-431e-f86c-18a10a3d4988"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "23"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "diferencia_salarios = s_coordinador - s_vigilante\n",
        "diferencia_salarios"
      ],
      "metadata": {
        "id": "fIugsxNy_53j",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "34e4f915-88aa-4015-886b-036b6a4de64d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "300"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "promedio_salarios = (s_vigilante * c_vigilante + s_docente * c_docente + s_coordinador * c_coordinador) / total_empleados\n",
        "promedio_salarios"
      ],
      "metadata": {
        "id": "xufuiJ2laWaa",
        "outputId": "f72a0941-9457-42cb-a60a-d926a707f852",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "465.2173913043478"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "type (promedio_salarios)"
      ],
      "metadata": {
        "id": "WntCdaWeatLv",
        "outputId": "2dd524e7-0d4e-4fe8-94cc-65424ed82e9a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Strings"
      ],
      "metadata": {
        "id": "yQy7b0ZWoD-P"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Strings hace referencia a un conjunto de caracteres formando un texto.\n",
        "\n",
        "Podemos crear Strings cuando atribuimos un dato a una variable entre comillas sencillas (`'`) o comillas dobles (`\"`)."
      ],
      "metadata": {
        "id": "vlo2-DXusv3s"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ityEWqvh_2wK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Las variables textuales son objetos que poseen métodos que nos ayudan a formatear strings. Los métodos los podemos ejecutar al definir un objeto de acuerdo con la siguiente estructura:\n",
        "\n",
        "```\n",
        "objeto.metodo()\n",
        "```\n",
        "\n",
        "Existen métodos que no necesitan los `()`, siempre es una buena práctica verificar la documentación para cada caso."
      ],
      "metadata": {
        "id": "2e9UD_CCxqz_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "**Situación:**\n",
        "\n",
        "Recibimos una variable con el nombre de una profesora de la escuela para añadirla a los registros. Sin embargo, necesitamos darle un tratamiento a este texto antes de insertarlo al sistema."
      ],
      "metadata": {
        "id": "p6aPmMGP4tf9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "texto = '  Micaela de los Sanyos '\n",
        "id(texto)"
      ],
      "metadata": {
        "id": "icDWtYTjBO0n",
        "outputId": "a011eb17-cba7-42f3-91cb-2e5f0efb9628",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "138608939360912"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "El objetivo final es que el nombre aparezca de la siguiente forma:\n",
        "\n",
        "```\n",
        "'MICAELA DE LOS SANTOS'\n",
        "```"
      ],
      "metadata": {
        "id": "Dg2ZXSZOGzjC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### [`str.upper()` ](https://docs.python.org/3/library/stdtypes.html#str.upper)\n",
        "Convierte una string a mayúsculas."
      ],
      "metadata": {
        "id": "iVTAD8q702eN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "str.upper(texto)"
      ],
      "metadata": {
        "id": "wMVshJrY_ZXh",
        "outputId": "aeae4bdc-a98c-40a7-b56d-31b6a4e059ab",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'  MICAELA DE LOS SANYOS '"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### [`str.lower()`](https://docs.python.org/3/library/stdtypes.html#str.lower)\n",
        "Convierte una string a minúsculas."
      ],
      "metadata": {
        "id": "hbDSBtMV1TpG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "texto.lower()"
      ],
      "metadata": {
        "id": "px3yEeNH_YK4",
        "outputId": "54471714-b8ea-4707-96c7-462c37164767",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'  micaela de los sanyos '"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### [`str.strip()`](https://docs.python.org/3/library/stdtypes.html#str.strip)\n",
        "Elimina los espacios en blanco al inicio y al final de una string."
      ],
      "metadata": {
        "id": "kz47eWM11gii"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "texto.strip()"
      ],
      "metadata": {
        "id": "76dLgNa4_XAe",
        "outputId": "e657bb45-bb02-4595-bc57-6145b9a2a888",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Micaela de los Sanyos'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### [`str.replace(antiguo, nuevo)`](https://docs.python.org/3/library/stdtypes.html#str.replace)\n",
        "\n",
        "Sustituye todas las ocurrencias del texto \"antiguo\" en la string por el  \"nuevo\"."
      ],
      "metadata": {
        "id": "m6notiyS1SCV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "texto.replace('y','t')"
      ],
      "metadata": {
        "id": "PNXAixtE_V6R",
        "outputId": "08b8424f-8ade-4a0a-e9a6-7ae5ccb13a19",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'  Micaela de los Santos '"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Observaciones\n",
        "\n",
        "1. Los métodos devuelven una **tranformación**, no son ejecutados directamente sobre la variable donde está almacenado el texto.\n",
        "\n",
        "2. Adicionalmente, podemos acumular la ejecución de los métodos."
      ],
      "metadata": {
        "id": "zukvEjhG2Rcn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "texto"
      ],
      "metadata": {
        "id": "JjkBRklr_T5n",
        "outputId": "380aaa9e-c965-480a-f96a-4ab1b4b4fb63",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'  Micaela de los Sanyos '"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "id(texto)"
      ],
      "metadata": {
        "id": "gKC_uPX87INy",
        "outputId": "8d92e18b-b0cf-4785-8501-7ff6c6abc99c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "138608939360912"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para que la transformación se pueda ejecutar debemos atribuir la salida de las transformaciones a las variables"
      ],
      "metadata": {
        "id": "1KbwfVut2h6I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nuevo_texto = texto.strip().replace('y','t').upper()\n",
        "print(nuevo_texto)\n",
        "print(id(texto),id(nuevo_texto))"
      ],
      "metadata": {
        "id": "ocPP-Jaj_SJI",
        "outputId": "178f6c0b-daab-4d64-90d9-f5ab071eb11e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MICAELA DE LOS SANTOS\n",
            "138608939360912 138608939822144\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "texto = texto.strip().replace('y','t').upper()\n",
        "print(nuevo_texto)\n",
        "print(id(texto),id(nuevo_texto))"
      ],
      "metadata": {
        "id": "m1RvLGZZ_SP3",
        "outputId": "7058c61f-40e2-467d-cf29-b05ad584aa67",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MICAELA DE LOS SANTOS\n",
            "138608940508112 138608939822144\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Capturando datos\n",
        "\n",
        "En algunas aplicaciones necesitamos capturar los valores del usuario de nuestro proyecto. En python, logramos capturar los datos del usuario a través del comando [`input()`](https://docs.python.org/3/library/functions.html#input).\n",
        "\n",
        "Para ejecutar la captura debemos atribuir el resultado de esta función a una variable."
      ],
      "metadata": {
        "id": "0h9Fh5G9kHCa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nombre= input('Escribe tu Nombre:')"
      ],
      "metadata": {
        "id": "zbH_9i3q_PdY",
        "outputId": "6c8fdc1e-f381-41e0-d28f-58d338670c3d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Escribe tu Nombre:alexander\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "type(nombre)"
      ],
      "metadata": {
        "id": "JZy1Q9Tl_PgL",
        "outputId": "e7d0bff1-2020-419a-bd0d-b1b81f3f70bf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "La salida de este comando siempre será una *string*. Esto quiere decir que aunque capturemos un valor de variable numérica, este será de tipo string.\n",
        "\n",
        "Entonces, será necesario **convertir el resultado cuando no se desea utilizar el valor como tipo string**."
      ],
      "metadata": {
        "id": "7z7hcLCk_aCY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Existen funciones para la conversión de valores:\n",
        "\n",
        "- Enteros: [`int(dato_para_conversion)`](https://docs.python.org/3/library/functions.html#int)\n",
        "- Coma flotante: [`float(dato_para_conversion)`](https://docs.python.org/3/library/functions.html#float)\n",
        "- String: [`str(dato_para_conversion)`](https://docs.python.org/3/library/functions.html#func-str)\n",
        "- Booleano: [`bool(dato_para_conversion)`](https://docs.python.org/3/library/functions.html#bool)"
      ],
      "metadata": {
        "id": "TOlegATj1Jfp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ano_admicion =int(input ('Digita el año de admicion'))"
      ],
      "metadata": {
        "id": "M2ueeH6l_NMe",
        "outputId": "9914f130-b968-4221-8c1f-aa253c285f7d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Digita el año de admicion2023\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "type(ano_admicion)"
      ],
      "metadata": {
        "id": "xfWwuViK_NUn",
        "outputId": "dec1e377-01fa-4464-8d64-fc51b5832fe1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nota_admicion= float(input('Digita la nota de admicion'))"
      ],
      "metadata": {
        "id": "uFCHDyew_NZm",
        "outputId": "ba8a76fd-03a8-4852-fd4a-85e7a688e235",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Digita la nota de admicion8.7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "type(nota_admicion)"
      ],
      "metadata": {
        "id": "Dz5e5IQ2_XWx",
        "outputId": "4977ac8f-47f7-47e5-956a-da5916b267b0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Trataremos de representar mejor ahora el resultado de la transformación que obtuvimos. Nosotros podemos formatear y presentar nuestro resultado mezclando strings con valores no textuales.\n",
        "\n",
        "Para ello utilizamos la estructura de formatación `f` con strings."
      ],
      "metadata": {
        "id": "yNI2-XTbB3aS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(f'El año de admicion fue {ano_admicion}\\nLa nota de admision fue: {nota_admicion}')"
      ],
      "metadata": {
        "id": "keJjA5N9_K5i",
        "outputId": "eaeedda9-052c-446c-84b5-f4ec970f7362",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "El año de admicion fue 2023\n",
            "La nota de admision fue: 8.7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# ***`Desafio seccion 2 Manipulacion de datos en Python`***\n",
        "\n",
        "---\n"
      ],
      "metadata": {
        "id": "W0fEiGRo9Qz2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# ***Recopilación y muestra de datos***"
      ],
      "metadata": {
        "id": "xN8hBDKf7nsi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1 - Crea un programa que solicite al usuario que escriba su nombre y luego imprima \"Hola, [nombre].\"\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "`Podemos solicitar el nombre con la función input y asignar el resultado de la salida a una variable. A continuación, podemos imprimir el resultado de la variable en la función print usando la formatación f-string.`"
      ],
      "metadata": {
        "id": "5EPQPdgW7rW3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nombre = input('Ingrese su nombre: ')\n",
        "print(f'¡Hola, {nombre}!')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_XMpcZVj9sQA",
        "outputId": "41fe45c5-fdb1-4a36-bdea-60b581b4c782"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese su nombre: t\n",
            "¡Hola, t!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2 - Crea un programa que solicite al usuario que escriba su nombre y edad, y luego imprima \"Hola, [nombre], tienes [edad] años.\"\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "`Podemos solicitar el nombre y la edad con la función input y asignar el resultado de la salida a una variable. En el caso de la edad, es necesaria una conversión de la salida de input a un valor entero con la función int(). A continuación, podemos imprimir el resultado de las recopilaciones en la función print usando la formateación f-string.`"
      ],
      "metadata": {
        "id": "NMRSDcQ972Ec"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nombre = input('Ingrese su nombre: ')\n",
        "edad = int(input('Ingrese su edad: '))\n",
        "print(f'¡Hola, {nombre}, tienes {edad} años!')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LxAuvVfl9-rR",
        "outputId": "674e44f3-24a8-4b82-b43b-0b41e2c34601"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese su nombre: r\n",
            "Ingrese su edad: 3\n",
            "¡Hola, r, tienes 3 años!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3 - Crea un programa que solicite al usuario que escriba su nombre, edad y altura en metros, y luego imprima \"Hola, [nombre], tienes [edad] años y mides [altura] metros.\"\n",
        "\n",
        "\n",
        "---\n",
        "`Podemos solicitar el nombre, la edad y la altura con la función input y asignar el resultado de la salida a una variable. En el caso de la edad, es necesaria una conversión de la salida de input a un valor entero con la función int(). Para la altura, es necesario realizar una conversión al tipo de valor flotante con la función float(). A continuación, podemos imprimir el resultado de las recopilaciones en la función print usando la formateación f-string.`\n"
      ],
      "metadata": {
        "id": "TjyjTIx3749h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nombre = input('Ingrese su nombre: ')\n",
        "edad = int(input('Ingrese su edad: '))\n",
        "altura = float(input('Ingrese su altura: '))\n",
        "print(f'¡Hola, {nombre}, tienes {edad} años y mides {altura} metros!')"
      ],
      "metadata": {
        "id": "p6Y7IU_n-KZh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# ***Calculadora con operadores***"
      ],
      "metadata": {
        "id": "L08IiVFY78e9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "4 - Crea un programa que solicite dos valores numéricos al usuario y luego imprima la suma de ambos valores.\n",
        "\n",
        "\n",
        "---\n",
        "`Podemos recopilar los dos valores con input y convertir la salida a un número entero con la función int(). Luego, podemos mostrar el resultado de la suma entre las dos entradas con +.`\n"
      ],
      "metadata": {
        "id": "yqLk5cql8BM_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = int(input('Ingrese el primer valor: '))\n",
        "b = int(input('Ingrese el segundo valor: '))\n",
        "print(a + b)"
      ],
      "metadata": {
        "id": "Txr_0510-RFh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "5 - Crea un programa que solicite tres valores numéricos al usuario y luego imprima la suma de los tres valores.\n",
        "\n",
        "\n",
        "---\n",
        "`Usando la misma lógica que en la pregunta anterior, podemos recopilar los tres valores con input y convertir la salida a números enteros con la función int(). Luego, podemos mostrar el resultado de la suma de los tres valores con +.`\n"
      ],
      "metadata": {
        "id": "wOVMM5xa8EaW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = int(input('Ingrese el primer valor: '))\n",
        "b = int(input('Ingrese el segundo valor: '))\n",
        "c = int(input('Ingrese el tercer valor: '))\n",
        "print(a + b + c)"
      ],
      "metadata": {
        "id": "IeGmXj3X-yhR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "6 - Crea un programa que solicite dos valores numéricos al usuario y luego imprima la resta del primero menos el segundo valor.\n",
        "\n",
        "---\n",
        "Podemos recopilar los dos valores con input y convertir la salida a números enteros con la función int(). Luego, podemos mostrar el resultado de la resta del primer valor menos el segundo valor con -.\n"
      ],
      "metadata": {
        "id": "_aPXaoas8Gow"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = int(input('Ingrese el primer valor: '))\n",
        "b = int(input('Ingrese el segundo valor: '))\n",
        "print(a - b)"
      ],
      "metadata": {
        "id": "nzPxXv0n-7Ow"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "7 - Crea un programa que solicite dos valores numéricos al usuario y luego imprima la multiplicación de los dos valores.\n",
        "\n",
        "---\n",
        "`Podemos recopilar los dos valores con input y convertir la salida a números enteros con la función int(). Luego, podemos mostrar el resultado de la multiplicación de los dos valores con *.`\n"
      ],
      "metadata": {
        "id": "bPQNF1WT8JEi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = int(input('Ingrese el primer valor: '))\n",
        "b = int(input('Ingrese el segundo valor: '))\n",
        "print(a * b)"
      ],
      "metadata": {
        "id": "MoxMz-A6_DyB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "8 - Crea un programa que solicite dos valores numéricos, un numerador y un denominador, y realice la división entre los dos valores. Asegúrate de que el valor del denominador no sea igual a 0.\n",
        "\n",
        "---\n",
        "`Podemos recopilar el numerador y denominador con input y convertir la salida a números enteros con la función int(). Luego, podemos mostrar el resultado de la división entre los dos valores con /.`\n"
      ],
      "metadata": {
        "id": "rRpk0ddz8Le4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "numerador = int(input('Ingrese el numerador: '))\n",
        "denominador = int(input('Ingrese el denominador (OBS: el valor no puede ser nulo): '))\n",
        "print(numerador / denominador)"
      ],
      "metadata": {
        "id": "EG4YVUf1_K-Q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "9 - Crea un programa que solicite dos valores numéricos, un operador y una potencia, y realice la exponenciación entre estos dos valores.\n",
        "\n",
        "---\n",
        "\n",
        "`Podemos recopilar el operador y potencia con input y convertir la salida a números enteros con la función int(). Luego, podemos mostrar el resultado de la exponenciación entre estos dos valores con **.`"
      ],
      "metadata": {
        "id": "kFz3Kvs_8NzD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "operador = int(input('Ingrese el valor del operador: '))\n",
        "potencia = int(input('Ingrese el valor de la potencia: '))\n",
        "print(operador ** potencia)"
      ],
      "metadata": {
        "id": "ngpU0LwF_S8I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "10 - Crea un programa que solicite dos valores numéricos, un numerador y un denominador, y realice la división entera entre los dos valores. Asegúrate de que el valor del denominador no sea igual a 0.\n",
        "\n",
        "---\n",
        "`Podemos recopilar el numerador y denominador con input y convertir la salida a números enteros con la función int(). Luego, podemos mostrar el resultado de la división entera entre los dos valores con //.`\n"
      ],
      "metadata": {
        "id": "8s1hA0fF8PwU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "numerador = int(input('Ingrese el numerador: '))\n",
        "denominador = int(input('Ingrese el denominador (OBS: el valor no puede ser nulo): '))\n",
        "print(numerador // denominador)"
      ],
      "metadata": {
        "id": "HKGQi2q6_d_I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "11 - Crea un programa que solicite dos valores numéricos, un numerador y un denominador, y devuelva el resto de la división entre los dos valores. Asegúrate de que el valor del denominador no sea igual a 0.\n",
        "\n",
        "---\n",
        "`Podemos recopilar el numerador y denominador con input y convertir la salida a números enteros con la función int(). Luego, podemos mostrar el resultado del resto de la división entre los dos valores con %.`\n"
      ],
      "metadata": {
        "id": "eUsDba4M8Rrf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "numerador = int(input('Ingrese el numerador: '))\n",
        "denominador = int(input('Ingrese el denominador (OBS: el valor no puede ser nulo): '))\n",
        "print(numerador % denominador)"
      ],
      "metadata": {
        "id": "_qi-FHZF_uYy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "12 - Crea un código que solicite las 3 notas de un estudiante e imprima el promedio de las notas.\n",
        "\n",
        "---\n",
        "`Podemos recopilar las tres notas con input y convertir la salida a números con decimales utilizando la función float(). Luego, podemos mostrar el resultado del promedio entre las tres variables sumando las notas con + y dividiendo la suma entre 3.`\n"
      ],
      "metadata": {
        "id": "Q3LDsd_d8Txu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nota_1 = float(input('Ingrese la 1° nota: '))\n",
        "nota_2 = float(input('Ingrese la 2° nota: '))\n",
        "nota_3 = float(input('Ingrese la 3° nota: '))\n",
        "print(f'Media {(nota_1+nota_2+nota_3)/3}.')"
      ],
      "metadata": {
        "id": "IHFwSo6-_6dn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "13 - Crea un código que calcule e imprima el promedio ponderado de los números 5, 12, 20 y 15 con pesos respectivamente iguales a 1, 2, 3 y 4.\n",
        "\n",
        "---\n",
        "\n",
        "`Calculamos la media ponderada multiplicando los pesos por sus respectivos valores y sumando el resultado de cada multiplicación. El valor de estas sumas se divide entre la suma total de los pesos. Con el comando print, imprimimos el resultado del cálculo de la media.`"
      ],
      "metadata": {
        "id": "DJgSzh0K8WEL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "media_ponderada = (5*1 + 12*2 + 20*3 + 15*4) / (1+2+3+4)\n",
        "print(f'Media {media_ponderada}.')"
      ],
      "metadata": {
        "id": "oa71wD2aADqT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# ***Editando textos***"
      ],
      "metadata": {
        "id": "g_65grw18ZPt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "14 - Crea una variable llamada \"frase\" y asígnale una cadena de texto de tu elección. Luego, imprime la frase en pantalla.\n",
        "\n",
        "---\n",
        "`Definimos una frase arbitraria entre comillas simples y la imprimimos insertando la variable en un comando print.`\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "E5iXkwNh8bZg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "frase = '¡Hola Python!'\n",
        "print(frase)"
      ],
      "metadata": {
        "id": "HgY9P4DSEVIw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "15 - Crea un código que solicite una frase y luego imprima la frase en pantalla.\n",
        "\n",
        "---\n",
        "\n",
        "`Recopilamos una frase utilizando la función input y luego imprimimos el resultado con el comando print.`"
      ],
      "metadata": {
        "id": "JQw0olMO8fwO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "frase = input('Escribe una frase: ')\n",
        "print(frase)"
      ],
      "metadata": {
        "id": "9dnc4KAWEbSR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "16 - Crea un código que solicite una frase al usuario y luego imprima la misma frase ingresada pero en mayúsculas.:\n",
        "\n",
        "---\n",
        "\n",
        "`Recopilamos una frase utilizando la función input y luego mostramos su valor en mayúsculas utilizando el método upper. Podemos mostrar la salida de esto en un comando print.`"
      ],
      "metadata": {
        "id": "BlrWrnMk8rBT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "frase = input('Escribe una frase: ')\n",
        "print(frase.upper())"
      ],
      "metadata": {
        "id": "fsO19xyXEd3h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "17 - Crea un código que solicite una frase al usuario y luego imprima la misma frase ingresada pero en minúsculas.\n",
        "\n",
        "---\n",
        "\n",
        "`Recopilamos una frase utilizando la función input y luego mostramos su valor en minúsculas utilizando el método lower. Podemos mostrar la salida de esto en un comando print`."
      ],
      "metadata": {
        "id": "7sVnMdVz8v0I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "frase = input('Escribe una frase: ')\n",
        "print(frase.lower())"
      ],
      "metadata": {
        "id": "m3zKd7-8FElY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "18 - Crea una variable llamada \"frase\" y asígnale una cadena de texto de tu elección. Luego, imprime la frase sin espacios en blanco al principio y al final.\n",
        "\n",
        "---\n",
        "\n",
        "`Para este ejemplo, es interesante definir una frase con espacios al principio y al final de la frase. Una vez hecho esto, podemos eliminar estos espacios utilizando el método strip y mostrar el resultado en un comando print.`"
      ],
      "metadata": {
        "id": "1wdMWW9L8xSI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "frase = ' ¡Hola Python! '\n",
        "print(frase.strip())"
      ],
      "metadata": {
        "id": "GtMaKPNlFVZY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "19 - Crea un código que solicite una frase al usuario y luego imprima la misma frase sin espacios en blanco al principio y al final.\n",
        "\n",
        "---\n",
        "\n",
        "`Recopilamos una frase utilizando la función input, incluso si no estamos seguros de si tendrá espacios al principio y al final de la frase. Luego, podemos eliminar estos espacios utilizando el método strip. El resultado se puede mostrar en un comando print.`"
      ],
      "metadata": {
        "id": "dTqBA9We8zlR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "frase = input('Escribe una frase: ')\n",
        "print(frase.strip())"
      ],
      "metadata": {
        "id": "JJ_AQvgcFe-Z",
        "outputId": "1ed38694-63d2-4651-fd12-bdcd417c1c7b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Escribe una frase:  frase espacio \n",
            "frase espacio\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "20 - Crea un código que solicite una frase al usuario y luego imprima la misma frase sin espacios en blanco al principio y al final, además de convertirla a minúsculas.\n",
        "\n",
        "---\n",
        "\n",
        "`Recopilamos una frase utilizando la función input, incluso si no estamos seguros de si tendrá espacios al principio y al final de la frase. Luego, eliminamos estos espacios utilizando el método strip y también usamos el método lower junto con strip. El resultado se puede mostrar en un comando print.`"
      ],
      "metadata": {
        "id": "Kb6wm4QZ81mN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "frase = input('Escribe una frase: ')\n",
        "print(frase.strip().lower())"
      ],
      "metadata": {
        "id": "-UUKjApZF5Nf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "21 - Crea un código que solicite una frase al usuario y luego imprima la misma frase con todas las vocales \"e\" reemplazadas por la letra \"f\".\n",
        "\n",
        "---\n",
        "\n",
        "`Recopilamos una frase utilizando la función input. Para asegurarnos de que los caracteres no estén en mayúsculas, convertimos toda la frase a minúsculas utilizando el método lower y luego aplicamos el método replace, definiendo el valor a reemplazar como 'e' y el nuevo valor como 'f'. El resultado se muestra en un comando print.`"
      ],
      "metadata": {
        "id": "gh8tS1yX84HI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "frase = input('Escribe una frase: ')\n",
        "print(frase.lower().replace('e','f'))"
      ],
      "metadata": {
        "id": "2CDtCchDGRqQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "22 - Crea un código que solicite una frase al usuario y luego imprima la misma frase con todas las vocales \"a\" reemplazadas por el carácter \"@\".\n",
        "\n",
        "---\n",
        "\n",
        "`Recopilamos una frase utilizando la función input. Para asegurarnos de que los caracteres no estén en mayúsculas, convertimos toda la frase a minúsculas utilizando el método lower y luego aplicamos el método replace, definiendo el valor a reemplazar como 'a' y el nuevo valor como el carácter 64 según la tabla Unicode, que corresponde al carácter @. El resultado se muestra en un comando print.`"
      ],
      "metadata": {
        "id": "rkEeI4g-86uX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "frase = input('Escribe una frase: ')\n",
        "print(frase.lower().replace('a',chr(64)))"
      ],
      "metadata": {
        "id": "IL_CEfnRGZMX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "23 - Crea un código que solicite una frase al usuario y luego imprima la misma frase con todas las consonantes \"s\" reemplazadas por el carácter \"$\".\n",
        "\n",
        "---\n",
        "\n",
        "`Recopilamos una frase utilizando la función input. Para asegurarnos de que los caracteres no estén en mayúsculas, convertimos toda la frase a minúsculas utilizando el método lower y luego aplicamos el método replace, definiendo el valor a reemplazar como 's' y el nuevo valor como el carácter 36 según la tabla Unicode, que corresponde al símbolo $. El resultado se muestra en un comando print.`"
      ],
      "metadata": {
        "id": "UA5v4erl89QQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "frase = input('Escribe una frase: ')\n",
        "print(frase.lower().replace('s',chr(36)))"
      ],
      "metadata": {
        "id": "YJy70mfnHCH_",
        "outputId": "07d01eb3-e9b6-416c-e05d-fd003d05e522",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Escribe una frase: dddswwws\n",
            "ddd$www$\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Estructuras condicionales"
      ],
      "metadata": {
        "id": "NwRaiHHHhhyl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Nota de aprobacion es de 7 y 10 == nota de aprobacion >=7\n",
        "# Nota de aprobcion es menor a 7 == Nota de reprobacion <7\n",
        "\"\"\"\n",
        "Si la nota es mayor o igual a 7:\n",
        "  Aprobado\n",
        "Si la nota es menor a 7:\n",
        "  Reprobado\n",
        "\"\"\"\n"
      ],
      "metadata": {
        "id": "pa4gLncu-mvU",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "1cd0eddf-a6d5-46f4-814d-9acd568be87c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'\\nSi la nota es mayor o igual a 7:\\n  Aprobado\\nSi la nota es menor a 7:\\n  Reprobado\\n'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "_cWRmDiE-m4p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## `IF` y `ELSE`\n",
        "\n",
        "Los comandos `if` y `else` son dos estructuras condicionales. El comando `if` ejecutará el bloque de comandos en caso de que la condición citada sea  **verdadera**. El comando `else` ejecutará el bloque de comandos en el caso de que la condicional de `if` sea **falsa**."
      ],
      "metadata": {
        "id": "qXZqg9aYEhAh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "El comando `if` es una palabra clave en Python que significa \"si\". Este se emplea para conformar la estructura condicional, que te permite verificar si una determinada condición es verdadera o falsa e, inmediatamente después, ejecute un bloque de código específico dependiendo del resultado de la verificación. La sintaxis para usar el comando `if` es:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "if condicion:\n",
        "    # Realiza algo\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "EIhlqHXd2Gil"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "if 2 < 7:\n",
        "  print('La ondicion es verdadera')"
      ],
      "metadata": {
        "id": "S2S6XAFz-czM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "007b17f2-d5a6-4464-d99a-8f017198e0b5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "La ondicion es verdadera\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "if 2 > 7:\n",
        "  print('La ondicion es verdadera')\n",
        "print('Fin de la consulta')"
      ],
      "metadata": {
        "id": "YHkwMMyY-c1r",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ea55344e-57cb-4e64-f503-242d3550c278"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Fin de la consulta\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ya el comando `else` en Python se usa en junción con la palabra clave `if` para formar una estructura condicional. la sintaxis para usar el `else` es:\n",
        "\n",
        "```\n",
        "if condicion:\n",
        "  # codigo en caso de que sea verdad\n",
        "else:\n",
        "  # codigo en caso de que sea falso\n",
        "```\n",
        "\n",
        "el comando `else` se ejecuta cuando la condición verificada por el `if` es evaluada como `False`."
      ],
      "metadata": {
        "id": "27RW2v_sIKct"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "if 2 > 7:\n",
        "  print('La condicion es verdadera')\n",
        "else:\n",
        "  print('La condicion es falsa')\n",
        "print('Fin de la consulta')"
      ],
      "metadata": {
        "id": "ZTfNJd_f-aOq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f473b3b0-8589-46bc-e3d9-99a6e41f3dbf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "La condicion es falsa\n",
            "Fin de la consulta\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "**Situación:**\n",
        "\n",
        "Recibiremos el promedio de la nota de los estudiantes y necesitamos de un algoritmo que ejecute el análisis y determine si el estudiante fue **Aprobado** o **Reprobado**, mostrando un mensaje del resultado. Para ser aprobado, el promedio necesita ser igual o superior a 7.0."
      ],
      "metadata": {
        "id": "BqORg85XX-Nl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nota = float(input('Ingrese la nota del estudiante: '))\n",
        "if nota >= 7.0:\n",
        "  print('Aprobado')\n",
        "else:\n",
        "  print('Reprobado')"
      ],
      "metadata": {
        "id": "UukCN4AQ-YYW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "203c0c0f-c0f5-40e4-a9eb-5fea9d68a7a7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese la nota del estudiante: 8\n",
            "Aprobado\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ahora, nuestra institución educativa estableció que las personas que tengan el promedio entre 5.0 y 7.0 pueden participar del curso de **Recuperación** durante las vacaciones para lograr aprobar.\n",
        "\n",
        "Entonces podemos apoyarnos en un conjunto de `if`s para poder estructurar esta nueva condición."
      ],
      "metadata": {
        "id": "bD9O17HB6LUo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nota = float(input('Ingrese la nota del estudiante: '))\n",
        "if nota >= 7.0:\n",
        "  print('Aprobado')\n",
        "if 7 > nota >= 5:\n",
        "  print('Reuperacion')\n",
        "if nota < 5:\n",
        "  print('Reprobado')"
      ],
      "metadata": {
        "id": "G9cJ5O9--W52"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Observa que en casos con 3 situaciones como este necesitamos definir bien nuestras condiciones. Pues, si realizamos una condición con `else` al final, este irá a considerar solamente la condición `if` inmediatamente anterior para generar la salida en caso de que el resultado de su operación lógica sea **falso** dando como resultado, dos o más ejecuciones.\n",
        "\n",
        "Por ejemplo:"
      ],
      "metadata": {
        "id": "D5e2mByjvycO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nota = float(input('Ingrese la nota del estudiante: '))\n",
        "if nota >= 7.0:\n",
        "  print('Aprobado')\n",
        "if 7 > nota >= 5:\n",
        "  print('Reuperacion')\n",
        "else:\n",
        "  print('Reprobado')"
      ],
      "metadata": {
        "id": "C21JmOuK-VU8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bbaafca1-0881-4d58-b7a9-2f008d1729e6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese la nota del estudiante: 9\n",
            "Aprobado\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## `ELIF`\n",
        "\n",
        "El comando `elif` es una palabra clave en Python que significa \"si no, si\" y lo podemos considerar una *contracción* entre `else` e `if`. Se utiliza en conjunto con la palabra clave `if` para formar una estructura condicional en cadena."
      ],
      "metadata": {
        "id": "04T5g-7h4zWx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "la sintaxis para utilizar el comando `elif` es:\n",
        "\n",
        "```\n",
        "if condicion1:\n",
        "    # Realiza algo\n",
        "elif condicion2:\n",
        "    # Realiza otra cosa\n",
        "elif condicion3:\n",
        "    # Realiza otra cosa\n",
        "else:\n",
        "    # Realiza algo diferente\n",
        "```\n",
        "\n",
        "El comando `elif` permite que puedas verificar varias condiciones en cadena, economizando espacio en tu código. Si la primera condición se evalúa como `False`, el interpretador de Python evaluará la próxima condición con el `elif`. Ello continuará hasta que una condición sea evaluada como `True` o hasta que el `else` sea alcazado. Si ninguna de las condiciones es evaluada como `True`, la ejecución del código del comando `else` será iniciada."
      ],
      "metadata": {
        "id": "rNBHr5mm1Lm6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Vamos a emplear el mismo caso anterior:"
      ],
      "metadata": {
        "id": "MVoykFbB4bd4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nota = float(input('Ingrese la nota del estudiante: '))\n",
        "if nota >= 7.0:\n",
        "  print('Aprobado')\n",
        "elif 7 > nota >= 5:\n",
        "  print('Reuperacion')\n",
        "else:\n",
        "  print('Reprobado')"
      ],
      "metadata": {
        "id": "QFamB78s-TW_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Operadores\n",
        "\n",
        "Durante la construcción de comandos a veces necesitamos de una elaboración mayor de la expresión condicional, necesitando que algunos operadores lógicos se encuentren integrados."
      ],
      "metadata": {
        "id": "Tf1wSOem6iwZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### `AND`, `OR`, `NOT`\n",
        "\n",
        "**AND** = `si 2 condiciones son verdaderas la salida es verdadera `\n",
        "\n",
        "**OR** = `si alguna de las 2 condciones es verdadera es verdadero`\n",
        "\n",
        "**NOT** = `Negacion de la condicion si es verdadero en not es falso y si es falso en not es verdadero`\n",
        "\n",
        "Los operadores lógicos `and`, `or` y `not` son usados para combinar expresiones lógicas en Python. Ellos son usados frecuentemente en conjunto con el comando `if` para crear estructuras condicionales más complejas.\n"
      ],
      "metadata": {
        "id": "GFIZnRWXGPWO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `AND` es usado para verificar si dos condiciones son verdaderas. La expresión lógica¹ `x and y` se evalúa como `True` tan solo si **ambas condiciones `x` y `y` son verdaderas**, y como `False` en caso contrario.\n",
        "\n",
        "- `OR` es usado para verificar si al menos una de las condiciones es verdadera. La expresión lógica `x or y` se evalúa como `True` **si al menos una de las condiciones `x` o `y` es verdadera**, y como `False` si ambas condiciones son falsas.\n",
        "\n",
        "- `NOT` es usado para **negar una condición**. La expresión lógica `not x` es evaluada como `True` si la condición x es falsa, y como `False` si la condición x es verdadera.\n",
        "\n",
        "¹ Una expresión lógica es una declaración que puede ser evaluada como verdadera o falsa. Ella se compone por operandos lógicos² y por operadores lógicos³, que son usados ​​para combinar varias expresiones lógicas en una única expresión.\n",
        "\n",
        "² Los operandos lógicos son los elementos que son comparados o evaluados en una expresión lógica. Ellos son generalmente valores verdaderos o falsos, pero también pueden ser expresiones lógicas más complejas. En Python, los operandos lógicos son los valores `True` y `False`.\n",
        "\n",
        "³ Los operadores lógicos son ls símbolos o palabras clave que son usados ​​para combinar varias expresiones lógicas en una única expresión. En Python, los operadores lógicos son `and`, `or` y `not`, bien como las palabras clave `if`, `elif` e `else`."
      ],
      "metadata": {
        "id": "Z_dgAoHXJbzB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "> Operadores lógicos más comunes\n",
        "\n",
        "|a|b|AND|OR|NOT|\n",
        "|-|-|-|-|-|\n",
        "|0|0|0|0|1\n",
        "|0|1|0|1|-\n",
        "|1|0|0|1|-\n",
        "|1|1|1|1|0\n"
      ],
      "metadata": {
        "id": "2E5aUogf-49u"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "v= True\n",
        "f = False"
      ],
      "metadata": {
        "id": "DFKmpvmS-Pa6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "if v and f:\n",
        "  print('La condición es verdadera')\n",
        "else:\n",
        "  print('La condición es falsa')"
      ],
      "metadata": {
        "id": "W5BIrpOD-PeI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cacb9b1b-5bfb-4e2d-a84b-0034fe4b0ce3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "La condición es falsa\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "if f or f:\n",
        "  print('La condición es verdadera')\n",
        "else:\n",
        "  print('La condición es falsa')"
      ],
      "metadata": {
        "id": "fpDhYxq4-PiM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "74395ba6-dfe5-4e42-e7e6-9399edef8c9b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "La condición es falsa\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "if not v:\n",
        "  print('La condición es verdadera')\n",
        "else:\n",
        "  print('La condición es falsa')"
      ],
      "metadata": {
        "id": "rOUmfLsMmAAQ",
        "outputId": "81f24f4f-df18-4e08-baa8-5f8ef86c2285",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "La condición es falsa\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### `IN`\n",
        "\n",
        "Es usado para verificar si un elemento está presente en una lista, tupla u otra colección de conjunto. La expresión `x in y` se evalúa como `True` si el elemento `x` esta presente na variávelen la variable de conjunto `y`, y como `False` en caso contrario."
      ],
      "metadata": {
        "id": "w7EXG1dhWtja"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Podemos verificarlo con variables de texto.\n",
        "\n",
        "---\n",
        "\n",
        "**Situación:**\n",
        "\n",
        "En la escuela nos entregaron una lista con nombres de estudiantes que fueron aprobados según el promedio del semestre, pero es necesario verificar si algunos nombres están en esa lista para confirmar que los datos estén correctos.\n",
        "\n",
        "La lista distribuida puede ser observada a continuación:\n",
        "\n",
        "```\n",
        "lista = 'Juan Pérez, María González, Pedro Rodríguez, Ana López, Carlos Martínez,\n",
        "    Laura Sánchez, José García, Elena Fernández, Luis Morales, Carmen Torres,\n",
        "    David Ruiz, Isabel Ramírez, Javier Díaz, Sara Herrera, Miguel Castro,\n",
        "    Patricia Ortega, Francisco Vargas, Marta Jiménez, Manuel Medina, Rosa Molina,\n",
        "    Alejandro Silva, Silvia Ruiz, Andrés Torres, Natalia Soto, Diego Guerrero,\n",
        "    Paula Ríos, Ricardo Navarro, Alicia Cordero, Carlos Vidal, Lorena Gómez'\n",
        "```\n",
        "\n",
        "Los nombres que necesitas verificar son los siguientes:\n",
        "\n",
        "```\n",
        "nombre_1 = 'Miguel Castro'\n",
        "nombre_2 = 'Marcelo Noguera'\n",
        "```"
      ],
      "metadata": {
        "id": "enJNp6JenQbq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lista = 'Juan Pérez, María González, Pedro Rodríguez, Ana López, Carlos Martínez,\\\n",
        "    Laura Sánchez, José García, Elena Fernández, Luis Morales, Carmen Torres,\\\n",
        "    David Ruiz, Isabel Ramírez, Javier Díaz, Sara Herrera, Miguel Castro,\\\n",
        "    Patricia Ortega, Francisco Vargas, Marta Jiménez, Manuel Medina, Rosa Molina,\\\n",
        "    Alejandro Silva, Silvia Ruiz, Andrés Torres, Natalia Soto, Diego Guerrero,\\\n",
        "    Paula Ríos, Ricardo Navarro, Alicia Cordero, Carlos Vidal, Lorena Gómez'"
      ],
      "metadata": {
        "id": "gPPN9BCT-Mki"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "nombre_1 = 'Miguel Castro'\n",
        "nombre_2 = 'Marcelo Noguera'"
      ],
      "metadata": {
        "id": "GINbG3Fa-Mnb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "if nombre_1 in lista:\n",
        "  print(f'{nombre_1} El estudiante aprobo')\n",
        "else:\n",
        "  print(f'{nombre_1} El estudiante reprobo')"
      ],
      "metadata": {
        "id": "hk-RhNRT-Mp7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5bc95281-d751-4158-a09e-47e873abf968"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Miguel Castro El estudiante aprobo\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "if nombre_2 in lista:\n",
        "  print(f'{nombre_1} El estudiante aprobo')\n",
        "else:\n",
        "  print(f'{nombre_1} El estudiante reprobo')"
      ],
      "metadata": {
        "id": "K-6S0OmQnP_Y",
        "outputId": "1b53e440-19df-4c75-df44-e44b97e77af0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Miguel Castro El estudiante reprobo\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **`Desafio: ¡Es hora de practicar! MODULO 3 `**"
      ],
      "metadata": {
        "id": "9bzf8XdFV5hv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# `Entrenando la programación`\n",
        "\n",
        "---\n",
        "\n",
        "1 - Escribe un programa que pida a la persona usuaria que proporcione dos números y muestre el número más grande."
      ],
      "metadata": {
        "id": "RhSX54OpWLaJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recolectamos los números\n",
        "num1 = float(input('Ingrese el primer número: '))\n",
        "num2 = float(input('Ingrese el segundo número: '))\n",
        "# Comparamos ambos números y determinamos cuál es el mayor\n",
        "if num1 > num2:\n",
        "    print(f'El primer número es mayor: {num1}')\n",
        "elif num2 > num1:\n",
        "    print(f'El segundo número es mayor: {num2}')\n",
        "else: # En caso de que los números sean iguales\n",
        "    print('Ambos números son iguales.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IF9lECcWXDyq",
        "outputId": "586f411b-d32b-4ee2-c75c-a21f3650095b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese el primer número: 3\n",
            "Ingrese el segundo número: 4\n",
            "El segundo número es mayor: 4.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2 - Escribe un programa que solicite el porcentaje de crecimiento de producción de una empresa e informe si hubo un crecimiento (porcentaje positivo) o una disminución (porcentaje negativo)."
      ],
      "metadata": {
        "id": "DzDk_AMgWbfa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "variacion = float(input('Ingrese el porcentaje de crecimiento de la producción: '))\n",
        "if variacion > 0:\n",
        "    print('Hubo un crecimiento en la producción.')\n",
        "elif variacion < 0:\n",
        "    print('Hubo una disminución en la producción.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uhHDYuEaXcOb",
        "outputId": "da2705da-ac1f-49a5-f047-9b5b3c8a41f7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese el porcentaje de crecimiento de la producción: 50\n",
            "Hubo un crecimiento en la producción.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3 - Escribe un programa que determine si una letra proporcionada por la persona usuaria es una vocal o una consonante."
      ],
      "metadata": {
        "id": "WEmIBxIAWfvg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "letra = input('Ingrese una letra: ')\n",
        "if letra.lower() in 'aeiou':\n",
        "    print('Es una vocal.')\n",
        "else:\n",
        "    print('Es una consonante.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "39a31D0PYM95",
        "outputId": "03793cd6-81f2-4eec-d85e-a2f0b870c455"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese una letra: r\n",
            "Es una consonante.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "4 - Escribe un programa que lea valores promedio de precios de un modelo de automóvil durante 3 años consecutivos y muestre el valor más alto y más bajo entre esos tres años."
      ],
      "metadata": {
        "id": "yMbveIy6Wg1D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recolectamos los precios de los 3 años\n",
        "precio_ano1 = float(input('Ingrese el precio promedio del automóvil en el primer año: '))\n",
        "precio_ano2 = float(input('Ingrese el precio promedio del automóvil en el segundo año: '))\n",
        "precio_ano3 = float(input('Ingrese el precio promedio del automóvil en el tercer año: '))\n",
        "# Determinamos el valor más alto mediante comparaciones\n",
        "mayor = precio_ano1\n",
        "if precio_ano2 > mayor:\n",
        "  mayor = precio_ano2\n",
        "if precio_ano3 > mayor:\n",
        "  mayor = precio_ano3\n",
        "# Determinamos el valor más bajo mediante comparaciones\n",
        "menor = precio_ano1\n",
        "if precio_ano2 < menor:\n",
        "  menor = precio_ano2\n",
        "if precio_ano3 < menor:\n",
        "  menor = precio_ano3\n",
        "# Mostramos los resultados\n",
        "print(f'El precio más alto fue de R$ {mayor}.')\n",
        "print(f'El precio más bajo fue de R$ {menor}.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uT5nfyQnYYSV",
        "outputId": "c7b55fa0-b989-4af2-a69e-c297ba82bcd9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese el precio promedio del automóvil en el primer año: 45690\n",
            "Ingrese el precio promedio del automóvil en el segundo año: 34577\n",
            "Ingrese el precio promedio del automóvil en el tercer año: 56789\n",
            "El precio más alto fue de R$ 56789.0.\n",
            "El precio más bajo fue de R$ 34577.0.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "5 - Escribe un programa que pregunte sobre el precio de tres productos e indique cuál es el producto más barato para comprar."
      ],
      "metadata": {
        "id": "JoXz8SiVWjGR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recolectamos el precio de tres productos\n",
        "producto1 = float(input('Ingrese el precio del primer producto: '))\n",
        "producto2 = float(input('Ingrese el precio del segundo producto: '))\n",
        "producto3 = float(input('Ingrese el precio del tercer producto: '))\n",
        "\n",
        "# Usamos el operador lógico `and` para determinar cuál es el precio más bajo entre los 3 productos\n",
        "# ya que esto nos permite hacer una comparación de 3 entradas\n",
        "if producto1 < producto2 and producto1 < producto3:\n",
        "    print('El primer producto es el más barato.')\n",
        "elif producto2 < producto1 and producto2 < producto3:\n",
        "    print('El segundo producto es el más barato.')\n",
        "else:\n",
        "    print('El tercer producto es el más barato.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z_0LFjafYZBR",
        "outputId": "3d930723-78bd-43cd-9a34-aed0be1abc9d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese el precio del primer producto: 34\n",
            "Ingrese el precio del segundo producto: 32\n",
            "Ingrese el precio del tercer producto: 2\n",
            "El tercer producto es el más barato.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "6 - Escribe un programa que lea tres números y los muestre en orden descendente."
      ],
      "metadata": {
        "id": "UUBJF5qEWk5j"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recolectamos los 3 números\n",
        "num1 = int(input('Ingrese el primer número: '))\n",
        "num2 = int(input('Ingrese el segundo número: '))\n",
        "num3 = int(input('Ingrese el tercer número: '))\n",
        "\n",
        "# Comparación entre los 3 números\n",
        "if (num1 >= num2) and (num1 >= num3):\n",
        "    print(num1)\n",
        "    if num2 >= num3:\n",
        "        print(num2)\n",
        "        print(num3)\n",
        "    else:\n",
        "        print(num3)\n",
        "        print(num2)\n",
        "elif (num2 >= num1) and (num2 >= num3):\n",
        "    print(num2)\n",
        "    if num1 >= num3:\n",
        "        print(num1)\n",
        "        print(num3)\n",
        "    else:\n",
        "        print(num3)\n",
        "        print(num1)\n",
        "else:\n",
        "    print(num3)\n",
        "    if num1 >= num2:\n",
        "        print(num1)\n",
        "        print(num2)\n",
        "    else:\n",
        "        print(num2)\n",
        "        print(num1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mwRlm8WtYZqS",
        "outputId": "7f3d2d77-664e-4839-cb76-493dba5359f9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese el primer número: 4\n",
            "Ingrese el segundo número: 5\n",
            "Ingrese el tercer número: 6\n",
            "6\n",
            "5\n",
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "7 -Escribe un programa que pregunte en qué turno estudia la persona usuaria (\"mañana\", \"tarde\" o \"noche\") y muestre el mensaje \"¡Buenos Días!\", \"¡Buenas Tardes!\", \"¡Buenas Noches!\" o \"Valor Inválido!\", según el caso."
      ],
      "metadata": {
        "id": "W9z1ikTLWnbe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recolectamos el turno de estudio\n",
        "turno = input('Ingresa en qué turno estudias (mañana, tarde o noche): ')\n",
        "\n",
        "# Comparamos la entrada con todas las opciones y mostramos el resultado.\n",
        "if turno == 'mañana':\n",
        "  print('¡Buenos Días!')\n",
        "elif turno == 'tarde':\n",
        "  print('¡Buenas Tardes!')\n",
        "elif turno == 'noche':\n",
        "  print('¡Buenas Noches!')\n",
        "else:\n",
        "  print('¡Valor Inválido!')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kmiVFqMEYadC",
        "outputId": "6188379f-865b-4ec0-d86e-f12f9bd33706"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingresa en qué turno estudias (mañana, tarde o noche): mañana\n",
            "¡Buenos Días!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "8 - Escribe un programa que solicite un número entero a la persona usuaria y determine si es par o impar. Pista: Puedes usar el operador módulo (%)."
      ],
      "metadata": {
        "id": "Uscjz2JFWrDY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recolectamos los datos\n",
        "num = int(input('Ingresa un número: '))\n",
        "\n",
        "# Verificamos si el número es par según el resultado del módulo\n",
        "if num % 2 == 0:\n",
        "    print('El número es par.')\n",
        "else:\n",
        "    print('El número es impar.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ClkYrrlfYbPp",
        "outputId": "be42f1b3-1c5d-40e1-ec65-0b0430292bab"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingresa un número: 7\n",
            "El número es impar.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "9 - Escribe un programa que pida un número a la persona usuaria y le informe si es entero o decimal."
      ],
      "metadata": {
        "id": "tag2h4ZTWr_p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recolectamos los datos\n",
        "num = float(input('Ingresa un número: '))\n",
        "# Verificamos si el número es entero o decimal según el resultado del módulo\n",
        "if num % 1 == 0:\n",
        "    print('El número es entero.')\n",
        "else:\n",
        "    print('El número es decimal.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cv4LhSM4YbwZ",
        "outputId": "d3860d1f-2395-4793-bb1e-276e06220f7b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingresa un número: 6\n",
            "El número es entero.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# `Momento de los proyectos`\n",
        "\n",
        "---\n",
        "\n",
        "10 - Un programa debe ser escrito para leer dos números y luego preguntar a la persona usuaria qué operación desea realizar. El resultado de la operación debe incluir información sobre el número, si es par o impar, positivo o negativo, e entero o decimal."
      ],
      "metadata": {
        "id": "FBGCubOlWt6x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recolectamos los números a operar y solicitamos la operación deseada por el usuario\n",
        "num1 = float(input('Ingrese el primer número: '))\n",
        "num2 = float(input('Ingrese el segundo número: '))\n",
        "operación = input('Ingrese la operación deseada (+, -, *, /): ')\n",
        "\n",
        "# Verificamos la operación seleccionada y realizamos la operación matemática según la elección\n",
        "if operación == '+':\n",
        "    resultado = num1 + num2\n",
        "elif operación == '-':\n",
        "    resultado = num1 - num2\n",
        "elif operación == '*':\n",
        "    resultado = num1 * num2\n",
        "elif operación == '/':\n",
        "    resultado = num1 / num2\n",
        "else: # Especificamos un resultado en caso de que el usuario no ingrese una de las operaciones correctamente.\n",
        "    print('Operación no válida, el resultado de la operación será 0')\n",
        "    resultado = 0\n",
        "\n",
        "# Realizamos las mismas verificaciones que en preguntas anteriores para generar el informe del cálculo entre números\n",
        "if resultado % 1 == 0:\n",
        "    print('El resultado es un número entero.')\n",
        "else:\n",
        "    print('El resultado es un número decimal.')\n",
        "\n",
        "if resultado > 0:\n",
        "    print('El resultado es positivo.')\n",
        "else:\n",
        "    print('El resultado es negativo.')\n",
        "\n",
        "if resultado % 2 == 0:\n",
        "    print('El resultado es un número par.')\n",
        "else:\n",
        "    print('El resultado es un número impar.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MC8S9r7fYc2K",
        "outputId": "57a8baf1-396d-46a3-89fd-ed6e4a102d03"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese el primer número: 6\n",
            "Ingrese el segundo número: 8\n",
            "Ingrese la operación deseada (+, -, *, /): +\n",
            "El resultado es un número entero.\n",
            "El resultado es positivo.\n",
            "El resultado es un número par.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "11 - Escribe un programa que pida a la persona usuaria tres números que representan los lados de un triángulo. El programa debe informar si los valores pueden utilizarse para formar un triángulo y, en caso afirmativo, si es equilátero, isósceles o escaleno. Ten en cuenta algunas sugerencias:\n",
        "\n",
        "Tres lados forman un triángulo cuando la suma de cualesquiera dos lados es mayor que el tercero;\n",
        "Triángulo Equilátero: tres lados iguales;\n",
        "Triángulo Isósceles: dos lados iguales;\n",
        "Triángulo Escaleno: tres lados diferentes."
      ],
      "metadata": {
        "id": "eGMH6JRTWzdX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recolectamos los lados de un triángulo\n",
        "print('Estamos recopilando los lados de un triángulo.')\n",
        "lado1 = float(input('Ingresa la longitud del primer lado: '))\n",
        "lado2 = float(input('Ingresa la longitud del segundo lado: '))\n",
        "lado3 = float(input('Ingresa la longitud del tercer lado: '))\n",
        "\n",
        "# Verificamos si los lados pueden formar un triángulo\n",
        "if (lado1 + lado2 > lado3) and (lado2 + lado3 > lado1) and (lado1 + lado3 > lado2):\n",
        "    print('¡Los valores pueden formar un triángulo!')\n",
        "    # Comparamos los lados para determinar el tipo de triángulo\n",
        "    if (lado1 == lado2) and (lado2 == lado3):\n",
        "        print('El triángulo es equilátero.')\n",
        "    elif (lado1 != lado2) and (lado2 != lado3) and (lado1 != lado3):\n",
        "        print('El triángulo es escaleno.')\n",
        "    else:\n",
        "        print('El triángulo es isósceles.')\n",
        "else:\n",
        "    print('¡Los valores no pueden formar un triángulo!')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "319t81m0YfA5",
        "outputId": "ca4af42d-36d3-4864-fd7e-2190cc8f30c9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Estamos recopilando los lados de un triángulo.\n",
            "Ingresa la longitud del primer lado: 56\n",
            "Ingresa la longitud del segundo lado: 32\n",
            "Ingresa la longitud del tercer lado: 56\n",
            "¡Los valores pueden formar un triángulo!\n",
            "El triángulo es isósceles.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "12 - Un establecimiento está vendiendo combustibles con descuentos variables. Para el etanol, si la cantidad comprada es de hasta 15 litros, el descuento será del 2% por litro. En caso contrario, será del 4% por litro. Para el diésel, si la cantidad comprada es de hasta 15 litros, el descuento será del 3% por litro. En caso contrario, será del 5% por litro. El precio por litro de diésel es de R$ 2,00 y el precio por litro de etanol es de R$ 1,70. Escribe un programa que lea la cantidad de litros vendidos y el tipo de combustible (E para etanol y D para diésel) y calcule el valor a pagar por el cliente. Ten en cuenta algunas sugerencias:\n",
        "\n",
        "El valor del descuento será el producto del precio por litro, la cantidad de litros y el valor del descuento.\n",
        "El valor a pagar por un cliente será el resultado de la multiplicación del precio por litro por la cantidad de litros menos el valor del descuento resultante del cálculo."
      ],
      "metadata": {
        "id": "mOCbo74dW2pj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recolectamos la cantidad de litros y el tipo de combustible,\n",
        "# convirtiendo el carácter en mayúsculas para facilitar nuestro análisis\n",
        "cantidad_litros = float(input('Ingrese la cantidad de litros vendidos: '))\n",
        "tipo_combustible = input('Ingrese el tipo de combustible (E para etanol y D para diésel): ').upper()\n",
        "\n",
        "# Verificamos primero el tipo de combustible\n",
        "if tipo_combustible == 'E':\n",
        "  # Establecemos el precio por litro de etanol\n",
        "  precio_litro = 1.70\n",
        "  # Según la cantidad de litros, establecemos el descuento correspondiente\n",
        "  if cantidad_litros <= 15:\n",
        "    descuento = 0.02\n",
        "  else:\n",
        "    descuento = 0.04\n",
        "elif tipo_combustible == 'D':\n",
        "  # Establecemos el precio por litro de diésel\n",
        "  precio_litro = 2.00\n",
        "  # Según la cantidad de litros, establecemos el descuento correspondiente\n",
        "  if cantidad_litros <= 15:\n",
        "    descuento = 0.03\n",
        "  else:\n",
        "    descuento = 0.05\n",
        "# En caso de error en la especificación del tipo de combustible,\n",
        "# consideramos las entradas como no válidas y establecemos los precios y descuentos en 0\n",
        "else:\n",
        "    print('Entradas no válidas!')\n",
        "    precio_litro = 0\n",
        "    descuento = 0\n",
        "\n",
        "# Calculamos el valor del descuento, seguido del cálculo del precio descontado\n",
        "valor_descuento = precio_litro * cantidad_litros * descuento\n",
        "valor_pagado = precio_litro * cantidad_litros - valor_descuento\n",
        "\n",
        "# Resultado\n",
        "print(f'Valor a pagar por el cliente: R$ {valor_pagado}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lfvZJ0B8YgYR",
        "outputId": "8c01c540-bfb0-43be-a777-944a960bfa5f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese la cantidad de litros vendidos: 45\n",
            "Ingrese el tipo de combustible (E para etanol y D para diésel): 23\n",
            "Entradas no válidas!\n",
            "Valor a pagar por el cliente: R$ 0.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "13 - En una empresa de venta de bienes raíces, debes crear un código que analice los datos de ventas anuales para ayudar a la dirección en la toma de decisiones. El código debe recopilar los datos de cantidad de ventas durante los años 2022 y 2023 y calcular la variación porcentual. A partir del valor de la variación, se deben proporcionar las siguientes sugerencias:\n",
        "\n",
        "Para una variación superior al 20%: bonificación para el equipo de ventas.\n",
        "Para una variación entre el 2% y el 20%: pequeña bonificación para el equipo de ventas.\n",
        "Para una variación entre el 2% y el -10%: planificación de políticas de incentivo a las ventas.\n",
        "Para bonificaciones inferiores al -10%: recorte de gastos."
      ],
      "metadata": {
        "id": "X14kAqCRW6gp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recolectamos las ventas de los dos años\n",
        "venta_2022 = float(input('Ingrese la cantidad de ventas en 2022: '))\n",
        "venta_2023 = float(input('Ingrese la cantidad de ventas en 2023: '))\n",
        "\n",
        "# Calculamos la variación porcentual entre las ventas de los años 2022 y 2023\n",
        "var_porcentual = 100 * (venta_2023 - venta_2022) / (venta_2022)\n",
        "\n",
        "# Análisis condicional de la variación porcentual para determinar la sugerencia a enviar\n",
        "if var_porcentual > 20:\n",
        "    print('Bonificación para el equipo de ventas.')\n",
        "elif 2 <= var_porcentual <= 20:\n",
        "    print('Pequeña bonificación para el equipo de ventas.')\n",
        "elif -10 <= var_porcentual < 2:\n",
        "    print('Planificación de políticas de incentivo a las ventas.')\n",
        "else:\n",
        "    print('Recorte de gastos.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5KY2pXpEYhlB",
        "outputId": "6abcc8f5-2463-4002-82db-bce64094d234"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese la cantidad de ventas en 2022: 34567\n",
            "Ingrese la cantidad de ventas en 2023: 45\n",
            "Recorte de gastos.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Estructuras de repetición"
      ],
      "metadata": {
        "id": "aL1vJPewvwvz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Cuando tenemos que ejecutar un mismo bloque de comandos durante varias ocasiones no es nada práctico hacerlo a mano.\n",
        "\n",
        "**Situación**: Nos fue solicitado obtener e imprimir el promedio de 2 notas de **3 estudantes**:"
      ],
      "metadata": {
        "id": "VcPfCa8d-84t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nota_1 = float(input('Ingrese la nota del estudiante 1: '))\n",
        "nota_2 = float(input('Ingrese la nota del estudiante 2: '))\n",
        "print(f'El promedio del estudiante 1 es: {(nota_1 + nota_2) / 2}')\n",
        "\n",
        "nota_1 = float(input('Ingrese la nota del estudiante 1: '))\n",
        "nota_2 = float(input('Ingrese la nota del estudiante 2: '))\n",
        "print(f'El promedio del estudiante 1 es: {(nota_1 + nota_2) / 2}')\n",
        "\n",
        "nota_1 = float(input('Ingrese la nota del estudiante 1: '))\n",
        "nota_2 = float(input('Ingrese la nota del estudiante 2: '))\n",
        "print(f'El promedio del estudiante 1 es: {(nota_1 + nota_2) / 2}')"
      ],
      "metadata": {
        "id": "xcx21IGT9qA0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0128ab97-08b8-4556-a66a-2aeca0001394"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese la nota del estudiante 1: 6\n",
            "Ingrese la nota del estudiante 2: 6\n",
            "El promedio del estudiante 1 es: 6.0\n",
            "Ingrese la nota del estudiante 1: 7\n",
            "Ingrese la nota del estudiante 2: 8\n",
            "El promedio del estudiante 1 es: 7.5\n",
            "Ingrese la nota del estudiante 1: 4\n",
            "Ingrese la nota del estudiante 2: 9\n",
            "El promedio del estudiante 1 es: 6.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ahora imaginemos una situación en que no son tan solo 3 estudiantes, sino 100 estudiantes. No sería nada interesante repetir el mismo código 100 veces, sino **ejecutar el mismo código 100 veces**.\n",
        "\n",
        "¡Esta estructura la logramos construir con lazos de repetición!"
      ],
      "metadata": {
        "id": "9puIuvUbFSFX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## `WHILE`"
      ],
      "metadata": {
        "id": "uLO9-aE4-wx8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "El lazo `while` es una estructura de control de repetición en Python que permite ejecutar un bloque de código repetidamente mientras que una determinada condición sea verdadera. Su estructura es:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "while condicion:\n",
        "    # bloque de codigo\n",
        "```\n",
        "\n",
        "Vamos a construir un ejemplo con un contador de 1 hasta 10.\n"
      ],
      "metadata": {
        "id": "rXZxDMiqHxm9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "contador = 1\n",
        "while contador <= 10:\n",
        "  print(contador)\n",
        "  # contador = contador + 1\n",
        "  contador += 1"
      ],
      "metadata": {
        "id": "Hd0ZSWxD9wCD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c4632fc6-38e2-470a-e473-da28ee594de1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ahora vamos a colectar las notas y promedios de cada alumno dentro del lazo `while`. Haremos un ejemplo con 3 promedios."
      ],
      "metadata": {
        "id": "W4KZPBJuIrut"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "contador = 1\n",
        "while contador <= 3:\n",
        "  nota_1 = float(input('Ingrese la nota del estudiante 1: '))\n",
        "  nota_2 = float(input('Ingrese la nota del estudiante 2: '))\n",
        "  print(f'El promedio del estudiante 1 es: {(nota_1 + nota_2) / 2}')\n",
        "  contador += 1"
      ],
      "metadata": {
        "id": "9T5eCLFx9wk6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## `FOR`"
      ],
      "metadata": {
        "id": "WgAIaENMMfCP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "El lazo `for` es un tipo de estructura de control de flujo en Python que permite iterar sobre un conjunto de elementos. Su estructura es:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "for elemento in conjunto:\n",
        "    # codigo a ser ejecutado para cada elemento\n",
        "```\n",
        "\n",
        "El lazo `for` itera sobre cada elemento del conjunto especificado y ejecuta el bloque de código dentro del lazo para cada elemento. Cuando el lazo llega al final del conjunto, este se interrumpe y el programa continúa la ejecución después del lazo.\n",
        "\n"
      ],
      "metadata": {
        "id": "HxrSZoRAMh-x"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "El conjunto lo podemos generar con la función incorporada [`range()`](https://docs.python.org/3/library/functions.html#func-range). Se trata de una función capaz de generar una secuencia de números enteros. La estructura de esta función es:\n",
        "\n",
        "```\n",
        "range(inicio, fin, paso)\n",
        "```\n",
        "\n",
        "Según la documentación, `range()` genera una secuencia de números enteros a partir del valor del parámetro `inicio` hasta el valor del parámetro `fin`, de acuerdo con el valor del parámetro `paso`. Si `inicio` no es especificado, el valor por defecto es `0`. Si `paso` no es especificado, el valor por defecto es `1`.\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "6VgjyoQtPHBM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Vamos a recrear el mismo contador `while` con el lazo `for`."
      ],
      "metadata": {
        "id": "ryn0hfdlUwC8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for n in range(1,11):\n",
        "  print(n)"
      ],
      "metadata": {
        "id": "KkL1wUIj9jL4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7e2318c3-d37b-48c6-8db2-bb361c2f53b1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for e in range(1,4):\n",
        "  nota_1 = float(input('Ingrese la nota del estudiante 1: '))\n",
        "  nota_2 = float(input('Ingrese la nota del estudiante 2: '))\n",
        "  print(f'El promedio del estudiante 1 es: {(nota_1 + nota_2) / 2}')"
      ],
      "metadata": {
        "id": "uXIZnLSr9jOu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8dea6dfd-c2bb-468b-fe21-5c452956f998"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese la nota del estudiante 1: 8\n",
            "Ingrese la nota del estudiante 2: 9\n",
            "El promedio del estudiante 1 es: 8.5\n",
            "Ingrese la nota del estudiante 1: 7\n",
            "Ingrese la nota del estudiante 2: 8\n",
            "El promedio del estudiante 1 es: 7.5\n",
            "Ingrese la nota del estudiante 1: 9\n",
            "Ingrese la nota del estudiante 2: 7\n",
            "El promedio del estudiante 1 es: 8.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Desafío: ¡Es hora de practicar! Modulo 4**\n",
        "\n",
        "---\n",
        "\n",
        "Vamos practicar el uso de estructuras de repetición como el \"while\" y el \"for\" a partir de algunas actividades. Ahora que estamos avanzando en el contenido, podemos hacer los desafíos más interesantes. ¡Para ello, trabajaremos en proyectos de código!\n",
        "\n",
        "Comencemos resolviendo algunos problemas para calentar y prepararnos para los proyectos."
      ],
      "metadata": {
        "id": "n6-nm11Gbtw0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# ***Entrenando la programación***\n",
        "\n",
        "---\n",
        "1 - Escribe un programa que solicite dos números enteros e imprima todos los números enteros entre ellos.\n"
      ],
      "metadata": {
        "id": "xTbCIadQcFmC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recolectamos los valores de inicio y fin\n",
        "inicio = int(input('Ingresa el primer número entero: '))\n",
        "fin = int(input('Ingresa el segundo número entero: '))\n",
        "\n",
        "# Verificamos si el valor de inicio es menor que el fin\n",
        "if inicio < fin:\n",
        "  # Podemos imprimir los enteros entre el valor menor y el valor mayor\n",
        "  for i in range(inicio + 1, fin):\n",
        "    print(i)\n",
        "elif inicio > fin:\n",
        "  for i in range(fin + 1, inicio):\n",
        "    print(i)\n",
        "else: # En caso de que los números sean iguales, no podemos imprimir ninguna secuencia.\n",
        "  print('Los números son iguales.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aw0mbowXdOdx",
        "outputId": "05b01e45-ac5b-4b56-c9c4-f8bdcc57d670"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingresa el primer número entero: 9\n",
            "Ingresa el segundo número entero: 1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2 - Escribe un programa para calcular cuántos días tomará que la colonia de una bacteria A supere o iguale a la colonia de una bacteria B, basado en tasas de crecimiento del 3% y 1.5%, respectivamente. Supón que la colonia A comienza con 4 elementos y B con 10."
      ],
      "metadata": {
        "id": "HerArQGOcPCS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Número inicial de bacterias\n",
        "colonia_a = 4\n",
        "colonia_b = 10\n",
        "\n",
        "# Tasas de crecimiento de las colonias\n",
        "tasa_a = 0.03\n",
        "tasa_b = 0.015\n",
        "\n",
        "# Contador de días\n",
        "días = 0\n",
        "\n",
        "# La condición que termina el bucle es cuando\n",
        "# la colonia A supera a la colonia B\n",
        "while colonia_a <= colonia_b:\n",
        "  # Usamos un operador de asignación con multiplicación\n",
        "  colonia_a *= 1 + tasa_a\n",
        "  colonia_b *= 1 + tasa_b\n",
        "  # Contamos los días en cada iteración\n",
        "  días += 1\n",
        "\n",
        "# Resultado final\n",
        "print(f'Necesitará {días} días para que la colonia A supere a la colonia B.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DtLwoHuVdVPn",
        "outputId": "b7830237-2beb-4a05-ed0d-1944efc7092f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Necesitará 63 días para que la colonia A supere a la colonia B.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3 - Para procesar una cantidad de 15 datos de evaluaciones de usuarios de un servicio de la empresa, necesitamos verificar si las calificaciones son válidas. Por lo tanto, escribe un programa que recibirá calificaciones del 0 al 5 y verificará si son valores válidos. Si se ingresa una calificación superior a 5 o inferior a 0, se repetirá hasta que el usuario ingrese un valor válido."
      ],
      "metadata": {
        "id": "f3PIyepXcRRD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Bucle para recopilar las 15 notas\n",
        "for i in range(15):\n",
        "  nota = float(input(f'Ingresa la nota del usuario {i}: '))5\n",
        "\n",
        "\n",
        "  # Verifica si la nota está entre 0 y 5\n",
        "  # Si no lo está, el bucle se repetirá hasta que se obtenga un valor válido\n",
        "  while (nota < 0) or (nota > 5):\n",
        "    nota = float(input(f'Nota no válida, ingresa nuevamente la nota del usuario {i}: '))\n",
        "\n",
        "print('Verificación completa. Todas las notas son válidas.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e8JOhvaNdizv",
        "outputId": "1a6b3321-27e5-43bf-bd38-42588502ddc1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingresa la nota del usuario 0: 5\n",
            "Ingresa la nota del usuario 1: 6\n",
            "Nota no válida, ingresa nuevamente la nota del usuario 1: 5\n",
            "Ingresa la nota del usuario 2: 6\n",
            "Nota no válida, ingresa nuevamente la nota del usuario 2: 5\n",
            "Ingresa la nota del usuario 3: 7\n",
            "Nota no válida, ingresa nuevamente la nota del usuario 3: 5\n",
            "Ingresa la nota del usuario 4: 5\n",
            "Ingresa la nota del usuario 5: 5\n",
            "Ingresa la nota del usuario 6: 5\n",
            "Ingresa la nota del usuario 7: 5\n",
            "Ingresa la nota del usuario 8: 5\n",
            "Ingresa la nota del usuario 9: 5\n",
            "Ingresa la nota del usuario 10: 5\n",
            "Ingresa la nota del usuario 11: 5\n",
            "Ingresa la nota del usuario 12: 5\n",
            "Ingresa la nota del usuario 13: 5\n",
            "Ingresa la nota del usuario 14: 5\n",
            "Verificación completa. Todas las notas son válidas.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "4 - Desarrolla un programa que lea un conjunto indefinido de temperaturas en grados Celsius y calcule su promedio. La lectura debe detenerse al ingresar el valor -273°C."
      ],
      "metadata": {
        "id": "yV9zqvUTcUfL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recopilamos la temperatura\n",
        "temperatura = float(input('Ingresa la temperatura en grados Celsius: '))\n",
        "\n",
        "# Inicializamos un contador y una suma para calcular el promedio\n",
        "contador = 0\n",
        "suma = 0\n",
        "\n",
        "# Nuestro código se ejecuta hasta que el valor de temperatura sea igual a -273\n",
        "while temperatura != -273:\n",
        "    # La suma se actualiza sumando la temperatura a la variable suma\n",
        "    suma += temperatura\n",
        "    # Contamos la cantidad de valores recopilados con el contador\n",
        "    contador += 1\n",
        "    # Recopilamos nuevamente la temperatura\n",
        "    temperatura = float(input('Ingresa la temperatura en grados Celsius: '))\n",
        "\n",
        "promedio = suma / contador\n",
        "\n",
        "print(f'El promedio de las temperaturas es: {promedio}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uosFkzEeeFTx",
        "outputId": "6eaba223-26b1-4b08-9b33-f93d94d4c889"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingresa la temperatura en grados Celsius: 40\n",
            "Ingresa la temperatura en grados Celsius: 56\n",
            "Ingresa la temperatura en grados Celsius: 78\n",
            "Ingresa la temperatura en grados Celsius: 345\n",
            "Ingresa la temperatura en grados Celsius: 6785\n",
            "Ingresa la temperatura en grados Celsius: 324\n",
            "Ingresa la temperatura en grados Celsius: -273\n",
            "El promedio de las temperaturas es: 1271.3333333333333\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "5 - Escribe un programa que calcule el factorial de un número entero proporcionado por el usuario. Recuerda que el factorial de un número entero es el producto de ese número por todos sus antecesores hasta llegar al número 1. Por ejemplo, el factorial de 5 es 5 x 4 x 3 x 2 x 1 = 120."
      ],
      "metadata": {
        "id": "ciiCV7U8cVs5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Solicita el número\n",
        "num = int(input('Ingresa un número entero: '))\n",
        "\n",
        "# Inicializa el cálculo\n",
        "factorial = 1\n",
        "\n",
        "# Nuestro contador comienza con el número máximo\n",
        "# y se realizará un conteo decreciente con el operador -=\n",
        "i = num\n",
        "while i > 0:\n",
        "    # Queremos multiplicar el valor factorial por el número\n",
        "    # y todos los números por debajo de él hasta 1\n",
        "    factorial *= i\n",
        "    i -= 1\n",
        "\n",
        "# Imprime el cálculo del factorial\n",
        "print(f'El factorial de {num} es {factorial}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3DB9w3zdeWh1",
        "outputId": "39d3d86f-57b4-497f-bcdd-ae012c15b796"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingresa un número entero: 10\n",
            "El factorial de 10 es 3628800\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Momento de los proyectos**\n",
        "\n",
        "---\n",
        "\n",
        "6 - Escribe un programa que genere la tabla de multiplicar de un número entero del 1 al 10, según la elección del usuario. Como ejemplo, para el número 2, la tabla de multiplicar debe mostrarse en el siguiente formato:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "Tabla de multiplicar del 2:\n",
        "2 x 1 = 2\n",
        "2 x 2 = 4\n",
        "[...]\n",
        "2 x 10 = 20\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "cUICP-ENcX9X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Solicita el número\n",
        "num = int(input('Ingresa un número entero del 1 al 10: '))\n",
        "\n",
        "# Generamos la tabla de multiplicar\n",
        "print(f'Tabla de multiplicar del {num}:')\n",
        "for i in range(1, 11):\n",
        "    resultado = num * i\n",
        "    print(f'{num} x {i} = {resultado}')"
      ],
      "metadata": {
        "id": "NvLdf2RFfN0X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "7 - Los números primos tienen diversas aplicaciones en Ciencia de Datos, como en criptografía y seguridad. Un número primo es aquel que es divisible solo por sí mismo y por 1. Por lo tanto, crea un programa que solicite un número entero y determine si es un número primo o no."
      ],
      "metadata": {
        "id": "N_pZgN3Rck8R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recopilamos el número\n",
        "num = int(input('Ingresa un número entero: '))\n",
        "\n",
        "# Los números enteros iguales o menores que 1 no se consideran primos\n",
        "if num > 1:\n",
        "    for i in range(2, num):\n",
        "        # Verificamos todos los residuos de la división entre todos los números menores que num\n",
        "        # Si algún residuo es 0, significa que es divisible por otro número además de sí mismo y 1\n",
        "        if (num % i) == 0:\n",
        "            print(f'{num} no es un número primo')\n",
        "            break\n",
        "    else:\n",
        "        print(f'{num} es un número primo')\n",
        "else:\n",
        "    print(f'{num} no es un número primo')"
      ],
      "metadata": {
        "id": "BQGFXLI3fQYK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "8 - Vamos a comprender la distribución de edades de los pensionistas de una empresa de seguros. Escribe un programa que lea las edades de una cantidad no informada de clientes y muestre la distribución en los intervalos [0-25], [26-50], [51-75] y [76-100]. La entrada de datos se detendrá al ingresar un número negativo."
      ],
      "metadata": {
        "id": "1jebsRYYcpKT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recopilamos las edades de los clientes\n",
        "edad = int(input('Ingresa la edad (o un número negativo para finalizar)')):\n",
        "\n",
        "# Inicializamos las variables de conteo\n",
        "contador_0_25 = 0 # contador de edades entre 0 y 25\n",
        "contador_26_50 = 0 # contador de edades entre 26 y 50\n",
        "contador_51_75 = 0 # contador de edades entre 51 y 75\n",
        "contador_76_100 = 0 # contador de edades entre 76 y 100\n",
        "\n",
        "# Nuestro código se ejecuta hasta que el valor de edad sea negativo\n",
        "while edad >= 0:\n",
        "    # Contamos cada caso\n",
        "    if edad >= 0 and edad <= 25:\n",
        "        contador_0_25 += 1\n",
        "    elif edad >= 26 and edad <= 50:\n",
        "        contador_26_50 += 1\n",
        "    elif edad >= 51 and edad <= 75:\n",
        "        contador_51_75 += 1\n",
        "    elif edad >= 76 and edad <= 100:\n",
        "        contador_76_100 += 1\n",
        "\n",
        "    # Repetimos el proceso de entrada de datos hasta que se ingrese un número negativo\n",
        "    edad = int(input('Ingresa la edad (o un número negativo para finalizar)')):\n",
        "\n",
        "# Mostramos los resultados\n",
        "print('Distribución de edades:')\n",
        "print('[0-25]:', contador_0_25)\n",
        "print('[26-50]:', contador_26_50)\n",
        "print('[51-75]:', contador_51_75)\n",
        "print('[76-100]:', contador_76_100)"
      ],
      "metadata": {
        "id": "qWzO96CufUK_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "9 - En una elección para la gerencia de una empresa con 20 empleados, hay cuatro candidatos. Escribe un programa que calcule al ganador de la elección. La votación se realizó de la siguiente manera:\n",
        "\n",
        "Cada empleado votó por uno de los cuatro candidatos (representados por los números 1, 2, 3 y 4).\n",
        "\n",
        "También se contaron los votos nulos (representados por el número 5) y los votos en blanco (representados por el número 6).\n",
        "\n",
        "Al final de la votación, el programa debe mostrar el número total de votos para cada candidato, los votos nulos y los votos en blanco. Además, debe calcular y mostrar el porcentaje de votos nulos con respecto al total de votos y el porcentaje de votos en blanco con respecto al total de votos."
      ],
      "metadata": {
        "id": "Hu1oDPdecqb_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Inicializamos las variables contadoras\n",
        "votos_candidato1 = 0\n",
        "votos_candidato2 = 0\n",
        "votos_candidato3 = 0\n",
        "votos_candidato4 = 0\n",
        "votos_nulos = 0\n",
        "votos_blanco = 0\n",
        "\n",
        "# Inicio del bucle para leer los votos\n",
        "for i in range(0, 20):\n",
        "    voto = int(input('Ingresa tu voto: '))\n",
        "    if voto == 1:\n",
        "        votos_candidato1 += 1\n",
        "    elif voto == 2:\n",
        "        votos_candidato2 += 1\n",
        "    elif voto == 3:\n",
        "        votos_candidato3 += 1\n",
        "    elif voto == 4:\n",
        "        votos_candidato4 += 1\n",
        "    elif voto == 5:\n",
        "        votos_nulos += 1\n",
        "    elif voto == 6:\n",
        "        votos_blanco += 1\n",
        "    else:\n",
        "        print(\"Voto inválido.\")\n",
        "\n",
        "print(f'Votos candidato 1: {votos_candidato1}')\n",
        "print(f'Votos candidato 2: {votos_candidato2}')\n",
        "print(f'Votos candidato 3: {votos_candidato3}')\n",
        "print(f'Votos candidato 4: {votos_candidato4}')\n",
        "print(f'Votos nulos: {votos_nulos}')\n",
        "print(f'Votos en blanco: {votos_blanco}')\n",
        "print(f'Porcentaje de votos nulos: {(votos_nulos / 20 * 100)}')\n",
        "print(f'Porcentaje de votos en blanco: {(votos_blanco / 20 * 100)}')"
      ],
      "metadata": {
        "id": "Sm8ULNzifldK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Estructuras de datos"
      ],
      "metadata": {
        "id": "8noP8OJ0Vhux"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Un conjunto de elementos es una colección de items, que son almacenados juntos de manera organizada. Algunos ejemplos de conjuntos de elementos en Python son las listas, los strings y los diccionarios."
      ],
      "metadata": {
        "id": "xpEUkefTu8fY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Listas"
      ],
      "metadata": {
        "id": "THSg4KYLwxIb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Las listas pueden almacenar una colección de items en orden. Ellas son delimitadas por corchetes `[]` y sus elementos son separados por comas.\n",
        "\n",
        "Estas pueden almacenar cualquier tipo de items, incluyendo números, strings, objetos, otras listas, entre otros. También nos permiten almacenar items de tipos de datos diferentes juntos en una única lista."
      ],
      "metadata": {
        "id": "dzpsiqrOyJcK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lista = ['Penélope Camacho',9.5,9.0,9.7,True]\n",
        "lista"
      ],
      "metadata": {
        "id": "DO3TBj7nAYeG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c8edfdbb-373c-4dbb-a566-e34f5b7481dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Penélope Camacho', 9.5, 9.0, 9.7, True]"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "type(lista)"
      ],
      "metadata": {
        "id": "DO2ubP9N9D_2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "194dc422-0ed1-441d-99e5-880ab1fd0a9e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Las listas son organizadas en Python porque **cada elemento de la lista tiene un índice que indica su posición al interior de la lista**. Los índices comienzan en 0 van hasta el tamaño de la lista menos 1."
      ],
      "metadata": {
        "id": "qUz3sJNl6LgK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Tenemos entonces 5 elementos con índices que varían de 0 a 4, ordenadamente:\n",
        "\n",
        "```\n",
        "#             [0]           [1]   [2]   [3]    [4]\n",
        "lista = ['Penélope Camacho', 9.5 , 9.0 , 9.7 , True]\n",
        "```\n",
        "\n",
        "En Python tenemos también los índices **negativos** que se inician en el último elemento con el valor de `-1` y avanzan en el universo de los negativos hasta llegar al 1° elemento:\n",
        "\n",
        "```\n",
        "#             [-5]         [-4]  [-3]  [-2]   [-1]\n",
        "lista = ['Penélope Camacho', 9.5 , 9.0 , 9.7 , True]\n",
        "```\n",
        "\n",
        "Logramos seleccionar separadamente cada elemento a través de sus respectivos índices. Colocando el nombre de la lista y en seguida el índice que será seleccionado."
      ],
      "metadata": {
        "id": "rLf-Qg526hFD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "type(lista[0])"
      ],
      "metadata": {
        "id": "4hco1Zqy88Kw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "24e0c44d-c97f-4868-88ed-d95fac9cbeca"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "type(lista[1])"
      ],
      "metadata": {
        "id": "M8lH0I2288Ph",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e3ec2eb5-1bb5-4907-fed4-91df54fb1681"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "type(lista[-1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C81Fy7p1qa6B",
        "outputId": "82e1598b-4a58-4050-8671-fc1d72060bd4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "bool"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Una forma más dinámica de trabajar item a item en una lista es utilizando un lazo `for` para leer un elemento a la vez."
      ],
      "metadata": {
        "id": "6TaE1ijmBTCd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for elemento in lista:\n",
        "  print(elemento)"
      ],
      "metadata": {
        "id": "rBx4Yu1786Sy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "88a162ad-0690-4684-a5a0-3cf1df625a86"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Penélope Camacho\n",
            "9.5\n",
            "9.0\n",
            "9.7\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Situación**: La nota `9.0` de Penélope necesita ser ajustada pues ganó 1 punto en su última nota por participación en clase. Entonces es necesario realizar un cambio en el índice `2` de `9.0` a `10.0`."
      ],
      "metadata": {
        "id": "Dh1_HnIVvucY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lista[2] = 10.0\n"
      ],
      "metadata": {
        "id": "bVPoZg668z3T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lista"
      ],
      "metadata": {
        "id": "Jo_PBQ0g8z7D",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9e237568-e1ee-4aba-b178-e0bb721d4570"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Penélope Camacho', 9.5, 10.0, 9.7, True]"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "También podemos calcular el promedio del estudiante a partir de los datos que tenemos."
      ],
      "metadata": {
        "id": "53XduzXkycAf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "promedio = (lista[1]+lista[2]+lista[3])/3\n",
        "promedio"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "13s4K4Tcrk74",
        "outputId": "87bc91e1-4c32-406b-f8d1-09888c8a9eb6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9.733333333333333"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Manipulación de listas\n",
        "\n",
        "Las listas son muy útiles en Python porque nos permiten almacenar y acceder a una colección de items de manera organizada y rápida. Estas también ofrecen muchos métodos útiles para manipular los itens almacenados, como adicionar, remover, clasificar y buscar elementos."
      ],
      "metadata": {
        "id": "d-iYr10-y4qw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Cantidad de elementos\n",
        "\n",
        "Usamos la función [`len()`](https://docs.python.org/3/library/functions.html#len) para descubrir la cantidad de elementos de un conjunto."
      ],
      "metadata": {
        "id": "ZLqx9A97XVB_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "len(lista)"
      ],
      "metadata": {
        "id": "6q1Tmm7P8wQf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "720fc802-4c5e-4e9a-8cf3-011652aea6c3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Partición\n",
        "\n",
        "La partición de listas por indexación en Python es una técnica muy útil para seleccionar un subconjunto de elementos de una lista. Esta se realiza usando la sintaxis `lista[inicio:fin]`, donde `inicio` es el índice del primer elemento que será incluído en la partición `fin` es el índice del primer elemento que será excluído de la partición."
      ],
      "metadata": {
        "id": "Z5tpstlHJss3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lista[0:2]"
      ],
      "metadata": {
        "id": "NctvJTTU8uV9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9aef98d4-06c3-4eb1-9098-e544704db78a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Penélope Camacho', 9.5]"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lista[:3]"
      ],
      "metadata": {
        "id": "bQZUwldj8uY2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "597931cc-b0c1-4117-f3f6-326b7aae82d8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Penélope Camacho', 9.5, 10.0]"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lista[3:]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EEcJC1pBxNXF",
        "outputId": "416f3efe-c583-42f1-b0cb-4e59a1f51f22"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[9.7, True]"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lista[:]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uggIAXmixUBX",
        "outputId": "99a15f31-ef30-4efa-ab73-0bb9bde6f773"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Penélope Camacho', 9.5, 10.0, 9.7, True]"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### [`append()`](https://docs.python.org/3/tutorial/datastructures.html#:~:text=of%20list%20objects%3A-,list.append(x),-Add%20an%20item)\n",
        "\n",
        "Añade un elemento al final de la lista."
      ],
      "metadata": {
        "id": "O0RRyabkRzZC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lista.append(promedio)"
      ],
      "metadata": {
        "id": "_Q0oODwa8spC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lista"
      ],
      "metadata": {
        "id": "RM894r2M8sse",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "360bb1b4-1ba6-45e0-8dac-c6619779006b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Penélope Camacho', 9.5, 10.0, 9.7, True, 9.733333333333333]"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### [`extend()`](https://docs.python.org/3/tutorial/datastructures.html#:~:text=list.extend(iterable))\n",
        "\n",
        "Añade varios elementos al final de la lista.\n",
        "\n",
        "Añadiremos las notas `[10.0,8.0,9.0]` En la lista de Penélope Camacho."
      ],
      "metadata": {
        "id": "uQV91XMsUOJD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lista.extend([10.0,8.0,9.0])"
      ],
      "metadata": {
        "id": "6Zk2MpMw8rQc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lista"
      ],
      "metadata": {
        "id": "NnoKkoWb8rTQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "04f8f3ad-a799-42a3-9f6d-400a0f0cb432"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Penélope Camacho', 9.5, 10.0, 9.7, True, 9.733333333333333, 10.0, 8.0, 9.0]"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "*A continuación te mostraremos lo que no puede realizarse con* `append`."
      ],
      "metadata": {
        "id": "IVJvkTwNUk6M"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lista.append([10.0,8.0,9.0])"
      ],
      "metadata": {
        "id": "u3Eub2ZL8pp3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lista"
      ],
      "metadata": {
        "id": "tsKK5Ne58pvN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e077b117-1895-4388-defe-79ef95a84c72"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Penélope Camacho',\n",
              " 9.5,\n",
              " 10.0,\n",
              " 9.7,\n",
              " True,\n",
              " 9.733333333333333,\n",
              " 10.0,\n",
              " 8.0,\n",
              " 9.0,\n",
              " [10.0, 8.0, 9.0]]"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### [`remove()`](https://docs.python.org/3/tutorial/datastructures.html#:~:text=append(x).-,list.remove(x),-Remove%20the%20first)\n",
        "\n",
        "Remueve un elemento específico de la lista."
      ],
      "metadata": {
        "id": "dPGM5gpyUX1z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lista.remove([10.0,8.0,9.0])"
      ],
      "metadata": {
        "id": "mmboODPc8nd5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lista"
      ],
      "metadata": {
        "id": "T_w6vVgV8nh_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "954b8a96-7030-4c31-82e5-f65374a8ee0c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Penélope Camacho', 9.5, 10.0, 9.7, True, 9.733333333333333, 10.0, 8.0, 9.0]"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Diccionario"
      ],
      "metadata": {
        "id": "Rc22Vc08YDZ2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Los diccionarios son un tipo de estructura de datos que almacenan pares de *llave-valor*. Estos son delimitados por llaves `{}` y los pares *llave-valor* son separados por comas.\n",
        "\n",
        "```\n",
        "diccionario = {llave: valor}\n",
        "```\n",
        "\n",
        "La **llave** es un elemento único que identifica a un valor en el diccionario, mientras que el **valor** es el item que será almacenado para la llave. Las llaves y sus respectivos valores se pueden emplear para **cualquier tipo de dato**.\n",
        "\n",
        "Los diccionarios son útiles para almacenar y acceder a los datos de manera organizada y rápida. Se trata de un tipo de conjunto de elementos en Python, pues almacenan una colección de items."
      ],
      "metadata": {
        "id": "PJ-cCKPjeWxL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "diccionario = {'llave_1':1,\n",
        "               'llave_2':2}\n",
        "diccionario"
      ],
      "metadata": {
        "id": "NDHhzooE8ld5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "81c895a0-2e93-455a-f70e-c68e14296384"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'llave_1': 1, 'llave_2': 2}"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "type(diccionario)"
      ],
      "metadata": {
        "id": "AVOzqzy-8lhh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "42a5a13d-a3a0-4e57-99d5-1ecc89c690c9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict"
            ]
          },
          "metadata": {},
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "**Situación:**\n",
        "\n",
        "Vamos a crear un conjunto de datos con las informaciones de matrícula de un estudiante. Los datos son los siguientes:\n",
        "\n",
        "- matrícula: 2000168933\n",
        "- día de registro: 25\n",
        "- mes de registro: 10\n",
        "- grupo: 2E"
      ],
      "metadata": {
        "id": "_JbQ3KMKfkXU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "estudiante = {'matrícula':2000168933,\n",
        "              'día de registro':25,\n",
        "              'mes de registro':10,\n",
        "              'grupo':'2E'}\n",
        "estudiante"
      ],
      "metadata": {
        "id": "0lfOu_c38jED",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7f418f9b-c513-4f5c-a696-50de61da0db7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'matrícula': 2000168933,\n",
              " 'día de registro': 25,\n",
              " 'mes de registro': 10,\n",
              " 'grupo': '2E'}"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "estudiante['matrícula']"
      ],
      "metadata": {
        "id": "XIuqpTTy8jHV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "34483ef1-701d-4b9d-e863-5408b44a3338"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2000168933"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "estudiante['grupo']"
      ],
      "metadata": {
        "id": "UAQSBcaw44Ux",
        "outputId": "e9b6418b-db0f-4a7a-aa5d-d7c9fb94ef76",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'2E'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Es posible sustituir los valores dentro de una llave. Por ejemplo, recibimos la información de que el grupo del estudiante que registramos cambio a `'2G'` y ahora necesitamos cambiar el valor de la llave `'grupo'`."
      ],
      "metadata": {
        "id": "8ex5pt2ykDd2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "estudiante['grupo'] = '2G'"
      ],
      "metadata": {
        "id": "kQGlp36b8fyP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "estudiante"
      ],
      "metadata": {
        "id": "DnfH_qHi8f17",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "50ce709d-e6bb-4d21-ad7b-86ae5e44b191"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'matrícula': 2000168933,\n",
              " 'día de registro': 25,\n",
              " 'mes de registro': 10,\n",
              " 'grupo': '2G'}"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "También podemos añadir otros datos al diccionario. Vamos a añadir la información sobre la modalidad de estudio, nuestro estudiante estudiará inicialemente en la modalidad EAD.\n",
        "\n",
        "Definiremos una llave llamada `'modalidad'` con el valor `'EAD'`."
      ],
      "metadata": {
        "id": "wB0qRb56mQvv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "estudiante['modalidad']= 'EAD'"
      ],
      "metadata": {
        "id": "EeLYdlIm8d8a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "estudiante"
      ],
      "metadata": {
        "id": "olDIavsm8d_o",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c59f34fd-e42e-49ab-8182-d908127737c0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'matrícula': 2000168933,\n",
              " 'día de registro': 25,\n",
              " 'mes de registro': 10,\n",
              " 'grupo': '2G',\n",
              " 'modalidad': 'EAD'}"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Profundizando en diccionarios"
      ],
      "metadata": {
        "id": "LJ3o_inroxg_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### [`pop()`](https://python-reference.readthedocs.io/en/latest/docs/dict/pop.html)\n",
        "Remueve un item de un diccionario y lo representa en la salida."
      ],
      "metadata": {
        "id": "2N3GLlkSpBiu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "estudiante.pop('grupo')"
      ],
      "metadata": {
        "id": "ZsSCZx6G8b-T",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "93a2fc65-ec41-4785-c4b4-2933d379eb0c"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'2G'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "estudiante"
      ],
      "metadata": {
        "id": "7lQ8_jpi8cBR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "68ada497-8dda-474f-fe55-01443c5feb99"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'matrícula': 2000168933,\n",
              " 'día de registro': 25,\n",
              " 'mes de registro': 10,\n",
              " 'modalidad': 'EAD'}"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### [`items()`](https://python-reference.readthedocs.io/en/latest/docs/dict/items.html)\n",
        "Retorna una lista de pares `llave-valor` del diccionario."
      ],
      "metadata": {
        "id": "sYZGvJJYrW_y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "estudiante.items()"
      ],
      "metadata": {
        "id": "ncdycLV08an7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "53f56ea8-7fa5-4608-a914-ba7edf8e19f7"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_items([('matrícula', 2000168933), ('día de registro', 25), ('mes de registro', 10), ('modalidad', 'EAD')])"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### [`keys()`](https://python-reference.readthedocs.io/en/latest/docs/dict/keys.html)\n",
        "Retorna una lista de las llaves del diccionario."
      ],
      "metadata": {
        "id": "Lb0utNFGrZBY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "estudiante.keys()"
      ],
      "metadata": {
        "id": "eZo0biaM8ZVs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "764a71ba-2f95-4b53-fa29-5e8550722d51"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_keys(['matrícula', 'día de registro', 'mes de registro', 'modalidad'])"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### [`values()`](https://python-reference.readthedocs.io/en/latest/docs/dict/values.html)\n",
        "Retorna una lista de los valores del diccionario."
      ],
      "metadata": {
        "id": "qKyu3bf9rbtX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "estudiante.values()"
      ],
      "metadata": {
        "id": "-NxRT9C18Yvo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4361b3c8-5196-44b2-ac38-f91bad37c97b"
      },
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_values([2000168933, 25, 10, 'EAD'])"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Lectura de valores con el lazo `for`"
      ],
      "metadata": {
        "id": "e3XVjR8Frp75"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for llave in estudiante.keys():\n",
        "  print(llave)"
      ],
      "metadata": {
        "id": "NYcjU-Ip8Xan",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "07135a94-5d46-4168-a9de-18d08c0a4310"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "matrícula\n",
            "día de registro\n",
            "mes de registro\n",
            "modalidad\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for llave,valor in estudiante.items():\n",
        "  print(llave,valor)"
      ],
      "metadata": {
        "id": "aAnpP1Wv8XfJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bf0b65b3-1918-4316-d031-37050a3c4a43"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "matrícula 2000168933\n",
            "día de registro 25\n",
            "mes de registro 10\n",
            "modalidad EAD\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for llave,valor in estudiante.items():\n",
        "  print(llave, '-->', valor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AlwXh4auUxD6",
        "outputId": "d59034ba-d89f-48a9-b193-527b9f383168"
      },
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "matrícula --> 2000168933\n",
            "día de registro --> 25\n",
            "mes de registro --> 10\n",
            "modalidad --> EAD\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Desafío: ¡Es hora de practicar! Modulo 5 Final **\n",
        "\n",
        "---\n",
        "Vamos practicar el uso de estructuras de datos, como listas y diccionarios, a través de algunas actividades. Ahora que estamos avanzando en el contenido, podemos hacer los desafíos más interesantes. ¡Para ello, trabajaremos con proyectos de código!\n",
        "\n",
        "Primero, resolveremos algunos problemas para calentar y prepararnos para los proyectos.\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "# **Entrenando la programación**\n"
      ],
      "metadata": {
        "id": "rFV0ejD_V3gj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1 - Crea un programa que tenga la siguiente lista con los gastos de una empresa de papel [2172.54, 3701.35, 3518.09, 3456.61, 3249.38, 2840.82, 3891.45, 3075.26, 2317.64, 3219.08]. Con estos valores, crea un programa que calcule el promedio de gastos. Sugerencia: usa las funciones integradas sum() y len().\n",
        "\n",
        "---\n",
        "` Incluso si ya sabemos manualmente cuál es el resultado, es interesante pensar cómo podríamos ejecutar las operaciones mediante programación.`\n"
      ],
      "metadata": {
        "id": "qo3z-wkoWInM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Datos de gastos\n",
        "gastos = [2172.54, 3701.35, 3518.09, 3456.61, 3249.38, 2840.82, 3891.45, 3075.26, 2317.64, 3219.08]\n",
        "\n",
        "# Calculamos el promedio encontrando el valor total de gastos con la función sum\n",
        "# y la cantidad total de compras realizadas con len\n",
        "total_gastos = sum(gastos)\n",
        "cantidad_compras = len(gastos)\n",
        "media_gastos = total_gastos / cantidad_compras\n",
        "# Resultado\n",
        "print(f'El promedio de gastos es {media_gastos} reales.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GM4R9KcoWU2b",
        "outputId": "6f63b0e0-9d9b-4c5e-9dc1-e497b0d81be6"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "El promedio de gastos es 3144.222 reales.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2 - Con los mismos datos de la pregunta anterior, determina cuántas compras se realizaron por encima de 3000 reales y calcula el porcentaje con respecto al total de compras."
      ],
      "metadata": {
        "id": "beXefDvFWVjb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Datos de gastos\n",
        "gastos = [2172.54, 3701.35, 3518.09, 3456.61, 3249.38, 2840.82, 3891.45, 3075.26, 2317.64, 3219.08]\n",
        "\n",
        "# Variable que contará cuántas compras se realizaron por encima de 3000\n",
        "contador_acima_3000 = 0\n",
        "# Usamos un bucle para recorrer la lista de gastos\n",
        "for gasto in gastos:\n",
        "  # Verificamos si el elemento está por encima de 3000\n",
        "  if gasto > 3000:\n",
        "    # Sumamos uno al contador si hay algún valor por encima de 3000\n",
        "    contador_acima_3000 += 1\n",
        "\n",
        "# Con el conteo podemos calcular el porcentaje de valores por encima de 3000 entre todas las compras\n",
        "porcentaje_acima_3000 = 100 * contador_acima_3000 / cantidad_compras\n",
        "\n",
        "# Resultado\n",
        "print(f'{contador_acima_3000} compras estuvieron por encima de R$3000,00.')\n",
        "print(f'{porcentaje_acima_3000}% de los gastos estuvieron por encima de R$3000,00.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gOpDco6sWXqs",
        "outputId": "79351219-fd48-4f2f-c639-95e21803bb25"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7 compras estuvieron por encima de R$3000,00.\n",
            "70.0% de los gastos estuvieron por encima de R$3000,00.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3 - Crea un código que recoja en una lista 5 números enteros aleatorios e imprima la lista. Ejemplo: [1, 4, 7, 2, 4]."
      ],
      "metadata": {
        "id": "RaA7TjT4WYXQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Lista que almacenará los 5 números enteros\n",
        "lista_numeros = []\n",
        "\n",
        "# Creamos un bucle que iterará 5 veces para recibir los 5 números\n",
        "for i in range(0, 5):\n",
        "  # Recopilamos el valor e lo insertamos en la lista 5 veces\n",
        "  numero = int(input('Ingresa un número entero: '))\n",
        "  lista_numeros.append(numero)\n",
        "#Resultado\n",
        "print(f'Lista de números ingresados: {lista_numeros}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "291XuAA_WaJJ",
        "outputId": "ad560f93-bbb8-4de1-fe18-7770813276fa"
      },
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingresa un número entero: 56\n",
            "Ingresa un número entero: 44\n",
            "Ingresa un número entero: 9\n",
            "Ingresa un número entero: 67\n",
            "Ingresa un número entero: 56\n",
            "Lista de números ingresados: [56, 44, 9, 67, 56]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "4 - Recoge nuevamente 5 números enteros e imprime la lista en orden inverso al enviado.\n",
        "\n",
        "---\n",
        "\n",
        "`Dado que el objetivo es imprimir la lista de números enteros en orden inverso al ingresado, podemos utilizar la técnica de partición, en la que la lista se recorre desde el último elemento (usando el índice -1) hasta el primero. De esta manera, la lista se imprime en orden inverso al original, de modo que el último elemento es el primero en mostrarse, seguido por el penúltimo elemento y así sucesivamente.`"
      ],
      "metadata": {
        "id": "sCp_Z9XKWa3c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Lista que almacenará los 5 números enteros\n",
        "lista_numeros = []\n",
        "\n",
        "# Creamos un bucle que iterará 5 veces para recibir los 5 números\n",
        "for i in range(0, 5):\n",
        "  # Recopilamos el valor e lo insertamos en la lista 5 veces\n",
        "  numero = int(input('Ingresa un número entero: '))\n",
        "  lista_numeros.append(numero)\n",
        "# Usamos la técnica de partición para imprimir el resultado\n",
        "print(f'Lista de números invertida: {lista_numeros[::-1]}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L9J2-5pvWdAN",
        "outputId": "2835f1af-3581-4892-f509-9948568fa263"
      },
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingresa un número entero: 45\n",
            "Ingresa un número entero: 67\n",
            "Ingresa un número entero: 90\n",
            "Ingresa un número entero: 12\n",
            "Ingresa un número entero: 34\n",
            "Lista de números invertida: [34, 12, 90, 67, 45]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "5 - Crea un programa que, al ingresar un número cualquiera, genere una lista que contenga todos los números primos entre 1 y el número ingresado.\n",
        "\n",
        "---\n",
        "`Para este problema, necesitamos verificar si todos los números, por debajo de lo especificado por el usuario, son o no divisibles por otros valores además de sí mismos. Para hacer esto, podemos anidar un bucle dentro de otro. Usamos un bucle para recorrer los números enteros de 2 al número ingresado. Para cada número, otro bucle se utiliza para verificar si es divisible por números más pequeños que él. Si el número no es divisible por ninguno de estos números, se considera un número primo. Esta estructura se puede observar a continuación:`\n"
      ],
      "metadata": {
        "id": "gU203uATWe3y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recopilamos el número\n",
        "numero = int(input('Ingresa un número entero: '))\n",
        "# Lista para almacenar los números primos\n",
        "lista_primos = []\n",
        "# Bucle que recorre todos los números por debajo del número ingresado\n",
        "for num in range(2, numero):\n",
        "  # Primo es una bandera que nos permite saber si el valor analizado es primo o no.\n",
        "  primo = True\n",
        "  # Probamos si todos los números por debajo del especificado en el primer bucle pueden dar una división exacta.\n",
        "  for prueba_divisibles in range(2, num):\n",
        "    if num % prueba_divisibles == 0:\n",
        "      # Si es divisible por algún número, entendemos que el número no es primo y terminamos el bucle interno con break.\n",
        "      primo = False\n",
        "      break\n",
        "  # La condición se convierte en el resultado booleano de primo: False. Ignoramos la condición True y ejecutamos el bloque del if.\n",
        "  if primo:\n",
        "    lista_primos.append(num)\n",
        "# Resultado\n",
        "print(f'Lista de números primos: {lista_primos}')"
      ],
      "metadata": {
        "id": "QIQQ-5BEWgAG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "6 - Escribe un programa que pida una fecha, especificando el día, mes y año, y determine si es válida para su análisis.\n",
        "\n",
        "---\n",
        "\n",
        "`Recopilamos el día, mes y año de una fecha y realizamos comprobaciones mes a mes, confirmando si en febrero (sea o no un año bisiesto) el día coincide con lo que es posible. También se analizan los meses que terminan en 31 o 30 días para evitar la existencia de fechas inválidas en los datos.`"
      ],
      "metadata": {
        "id": "5QlwsVInWglM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recopilamos la fecha\n",
        "dia = int(input('Ingrese el día: '))\n",
        "mes = int(input('Ingrese el mes: '))\n",
        "año = int(input('Ingrese el año: '))\n",
        "\n",
        "# Análisis de febrero\n",
        "if mes == 2:\n",
        "  # Verificamos si es o no un año bisiesto\n",
        "  if año % 4 == 0 and (año % 400 == 0 or año % 100 != 0):\n",
        "    dias_febrero = 29\n",
        "  else:\n",
        "    dias_febrero = 28\n",
        "  # Verificamos si el día ingresado coincide con el máximo de días de febrero\n",
        "  if dia >= 1 and dia <= dias_febrero:\n",
        "    print('Fecha válida')\n",
        "  else:\n",
        "    print('Fecha inválida')\n",
        "# Verificamos meses que terminan en 31 días\n",
        "elif mes in [1, 3, 5, 7, 8, 10, 12]:\n",
        "  if dia >= 1 and dia <= 31:\n",
        "    print('Fecha válida')\n",
        "  else:\n",
        "    print('Fecha inválida')\n",
        "# Verificamos meses que terminan en 30 días\n",
        "elif mes in [4, 6, 9, 11]:\n",
        "  if dia >= 1 and dia <= 30:\n",
        "    print('Fecha válida')\n",
        "  else:\n",
        "    print('Fecha inválida')\n",
        "# Si el mes no está entre 1 y 12\n",
        "else:\n",
        "  print('Fecha inválida')"
      ],
      "metadata": {
        "id": "BHPozPS3Wi1U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Momento para los proyectos**\n",
        "\n",
        "---\n",
        "7 - Para un estudio sobre la multiplicación de bacterias en una colonia, se recopiló el número de bacterias multiplicadas por día y se puede observar a continuación: [1.2, 2.1, 3.3, 5.0, 7.8, 11.3, 16.6, 25.1, 37.8, 56.9]. Con estos valores, crea un código que genere una lista que contenga el porcentaje de crecimiento de bacterias por día, comparando el número de bacterias en cada día con el número de bacterias del día anterior. Sugerencia: para calcular el porcentaje de crecimiento, utiliza la siguiente ecuación: 100 * (muestra_actual - muestra_anterior) / muestra_anterior.\n"
      ],
      "metadata": {
        "id": "5gD2XJQIWje0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Lista de crecimiento de bacterias\n",
        "bacterias_colonia = [1.2, 2.1, 3.3, 5.0, 7.8, 11.3, 16.6, 25.1, 37.8, 56.9]\n",
        "# Lista que almacenará las tasas de crecimiento\n",
        "porcentaje_crecimiento = []\n",
        "# Recorremos los índices de 1 a 9 para comparar los valores actuales con los anteriores\n",
        "for i in range(1, len(bacterias_colonia)):\n",
        "  # Realizamos el cálculo: 100 * (muestra_actual - muestra_anterior) / (muestra_anterior)\n",
        "  porcentaje = 100 * (bacterias_colonia[i] - bacterias_colonia[i-1]) / (bacterias_colonia[i-1])\n",
        "  # Agregamos el resultado a la lista porcentaje_crecimiento\n",
        "  porcentaje_crecimiento.append(porcentaje)\n",
        "# Resultado\n",
        "print(f'Porcentajes de crecimiento:\\n{porcentaje_crecimiento}')"
      ],
      "metadata": {
        "id": "LG9IxpLEWorr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "8 - Para una selección de productos alimenticios, debemos separar el conjunto de IDs proporcionados por números enteros, sabiendo que los productos con ID par son dulces y los que tienen ID impar son amargos. Crea un código que recoja 10 IDs. Luego, calcula y muestra la cantidad de productos dulces y amargos."
      ],
      "metadata": {
        "id": "aX0qA3CsWpMM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Lista que contendrá los valores de IDs\n",
        "ids = []\n",
        "# Variables contadoras de dulces y amargos\n",
        "dulce = 0\n",
        "amargo = 0\n",
        "\n",
        "# Creamos un bucle que iterará 10 veces para recopilar los 10 IDs\n",
        "for i in range(0,10):\n",
        "  # Recopilamos el ID y lo agregamos a la lista\n",
        "  ids.append(int(input(f'Ingrese el ID {i+1}°: '))\n",
        "\n",
        "# Leemos todos los elementos de la lista de IDs y los asignamos a id\n",
        "for id in ids:\n",
        "  # Verificamos si los elementos son pares o impares para llevar el conteo\n",
        "  if id % 2 == 0:\n",
        "    dulce += 1\n",
        "  else:\n",
        "    amargo += 1\n",
        "\n",
        "# Resultado\n",
        "print(f'Cantidad de productos dulces: {dulce}')\n",
        "print(f'Cantidad de productos amargos: {amargo}')"
      ],
      "metadata": {
        "id": "KG85bqLTWsFb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "9 - Desarrolla un programa que informe la puntuación de un estudiante de acuerdo con sus respuestas. Debe pedir la respuesta del estudiante para cada pregunta y verificar si la respuesta coincide con el resultado. Cada pregunta vale un punto y hay opciones A, B, C o D.\n",
        "\n",
        "\n",
        "```\n",
        "Resultado del examen:\n",
        "01 - D\n",
        "02 - A\n",
        "03 - C\n",
        "04 - B\n",
        "05 - A\n",
        "06 - D\n",
        "07 - C\n",
        "08 - C\n",
        "09 - A\n",
        "10 - B\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "0gx2bUvSWsw0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Inicializamos los datos\n",
        "respuestas = []  # Lista para almacenar las respuestas\n",
        "# Lista de respuestas correctas\n",
        "gabarito = ['D', 'A', 'C', 'B', 'A', 'D', 'C', 'C', 'A', 'B']\n",
        "nota = 0  # Acumulará la nota total\n",
        "\n",
        "# Recopilamos las respuestas del estudiante\n",
        "for i in range(0, 10):\n",
        "  respuestas.append(input(f'Introduzca la respuesta a la pregunta {i + 1}: ').upper())\n",
        "\n",
        "# Verificamos si las respuestas coinciden y las sumamos a la nota\n",
        "for i in range(0, 10):\n",
        "  if respuestas[i] == gabarito[i]:\n",
        "    nota += 1\n",
        "\n",
        "# Mostrando la nota final\n",
        "print(f'Nota final: {nota}')"
      ],
      "metadata": {
        "id": "i_qJ9ikKW0Fp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "10 - Un instituto de meteorología desea realizar un estudio de la temperatura media de cada mes del año. Para ello, debes crear un código que recoja y almacene esas temperaturas medias en una lista. Luego, calcula el promedio anual de las temperaturas y muestra todas las temperaturas por encima del promedio anual y en qué mes ocurrieron, mostrando los meses por su nombre (Enero, Febrero, etc.)."
      ],
      "metadata": {
        "id": "8ba1TuRBW05F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recopilamos la lista de temperaturas mensuales\n",
        "temperaturas_mensuales = []\n",
        "for i in range(0, 12):\n",
        "  temperaturas_mensuales.append(float(input(f'Ingrese la temperatura promedio del mes {i+1}: '))\n",
        "# Creamos una lista auxiliar para los nombres de los meses\n",
        "meses = ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre']\n",
        "# Calculamos el promedio\n",
        "media_anual = sum(temperaturas_mensuales) / len(temperaturas_mensuales)\n",
        "\n",
        "# Resultado\n",
        "print('Temperaturas por encima del promedio en: ')\n",
        "for i in range(0, 12):\n",
        "  # Verificamos todas las temperaturas en comparación con la media anual\n",
        "  if temperaturas_mensuales[i] > media_anual:\n",
        "    # Dado que los índices de los meses corresponden a las temperaturas,\n",
        "    # podemos imprimirlos con el mismo índice\n",
        "    print(meses[i])"
      ],
      "metadata": {
        "id": "iUCBxXUDW4Ut"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "11 - Una empresa de comercio electrónico está interesada en analizar las ventas de sus productos. Los datos de ventas se han almacenado en un diccionario:\n",
        "\n",
        "```\n",
        "{'Producto A': 300, 'Producto B': 80, 'Producto C': 60, 'Producto D': 200, 'Producto E': 250, 'Producto F': 30}\n",
        "```\n",
        "Escribe un código que calcule el total de ventas y el producto más vendido.\n"
      ],
      "metadata": {
        "id": "aN68-2rAW49E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Diccionario de ventas\n",
        "datos_ventas = {'Producto A': 300, 'Producto B': 80, 'Producto C': 60, 'Producto D': 200, 'Producto E': 250, 'Producto F': 30}\n",
        "\n",
        "# Inicializamos las variables\n",
        "total_ventas = 0  # Sumará todas las ventas\n",
        "producto_mas_vendido = ''  # Almacenará el nombre del producto más vendido\n",
        "unidades_producto_mas_vendido = 0  # Almacenará la cantidad más alta de ventas\n",
        "\n",
        "# Recorremos las claves y elementos del diccionario\n",
        "for producto in datos_ventas.keys():\n",
        "    # Sumamos el total de ventas\n",
        "    total_ventas += datos_ventas[producto]\n",
        "    # Verificamos si el valor de ventas actual (datos_ventas[producto]) es mayor que el valor almacenado en unidades_producto_mas_vendido\n",
        "    # Cada vez que datos_ventas[producto] supere el valor en unidades_producto_mas_vendido,\n",
        "    # la variable unidades_producto_mas_vendido será igual a datos_ventas[producto], asignando un nuevo valor\n",
        "    # De manera similar, producto_mas_vendido también se actualiza con el producto actual\n",
        "    if datos_ventas[producto] > unidades_producto_mas_vendido:\n",
        "        unidades_producto_mas_vendido = datos_ventas[producto]\n",
        "        producto_mas_vendido = producto\n",
        "# Resultados\n",
        "print(f'Total de ventas es {total_ventas}')\n",
        "print(f'{producto_mas_vendido} es el más vendido')"
      ],
      "metadata": {
        "id": "UDzfSb-rW6ak"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "12 - Se realizó una encuesta de mercado para decidir cuál diseño de marca infantil es más atractivo para los niños. Los votos de la encuesta se pueden ver a continuación:\n",
        "\n",
        "```\n",
        "Tabla de votos de la marca\n",
        "Diseño 1 - 1334 votos\n",
        "Diseño 2 - 982 votos\n",
        "Diseño 3 - 1751 votos\n",
        "Diseño 4 - 210 votos\n",
        "Diseño 5 - 1811 votos\n",
        "```\n",
        "Adapta los datos proporcionados a una estructura de diccionario. A partir de ello, informa el diseño ganador y el porcentaje de votos recibidos.\n"
      ],
      "metadata": {
        "id": "rt_DqOo9W_vi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Diccionario de votos por diseño\n",
        "votos = {'Diseño 1': 1334, 'Diseño 2': 982, 'Diseño 3': 1751, 'Diseño 4': 210, 'Diseño 5': 1811}\n",
        "\n",
        "# Inicializamos las variables\n",
        "total_votos = 0  # Sumará todos los votos\n",
        "ganador = ''  # Almacenará el nombre del diseño ganador\n",
        "voto_ganador = 0  # Almacenará la cantidad ganadora de votos\n",
        "\n",
        "# Recorremos las claves y elementos del diccionario\n",
        "for diseño, voto_diseño in votos.items():\n",
        "    # Sumamos el total de votos\n",
        "    total_votos += voto_diseño\n",
        "    # Verificamos si el voto del diseño actual (voto_diseño) es mayor que el valor almacenado en voto_ganador\n",
        "    # Cada vez que voto_diseño supere el valor en voto_ganador,\n",
        "    # la variable voto_ganador será igual a voto_diseño, asignando un nuevo valor\n",
        "    # De manera similar, el ganador también se actualiza con el diseño actual\n",
        "    if voto_diseño > voto_ganador:\n",
        "        voto_ganador = voto_diseño\n",
        "        ganador = diseño\n",
        "# Calculamos el porcentaje del diseño ganador\n",
        "porcentaje = 100 * (voto_ganador) / (total_votos)\n",
        "\n",
        "# Resultado\n",
        "print(f'{ganador} es el ganador: ')\n",
        "print(f'Porcentaje de votos: {porcentaje}%')"
      ],
      "metadata": {
        "id": "fE6y3GclXW07"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "13 - Los empleados de un departamento de tu empresa recibirán una bonificación del 10% de su salario debido a un excelente rendimiento del equipo. El departamento de finanzas ha solicitado tu ayuda para verificar las consecuencias financieras de esta bonificación en los recursos. Se te ha enviado una lista con los salarios que recibirán la bonificación: [1172, 1644, 2617, 5130, 5532, 6341, 6650, 7238, 7685, 7782, 7903]. La bonificación de cada empleado no puede ser inferior a 200. En el código, convierte cada uno de los salarios en claves de un diccionario y la bonificación de cada salario en el valor correspondiente. Luego, informa el gasto total en bonificaciones, cuántos empleados recibieron la bonificación mínima y cuál fue el valor más alto de la bonificación proporcionada."
      ],
      "metadata": {
        "id": "4_i3OjEKXYfU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Lista de salarios\n",
        "salarios = [1172, 1644, 2617, 5130, 5532, 6341, 6650, 7238, 7685, 7782, 7903]\n",
        "# Inicializamos las variables\n",
        "diccionario_abonos = {}  # Diccionario de abonos\n",
        "total_abono = 0  # Sumará todos los gastos en abonos\n",
        "abonos_minimo = 0  # Almacenará la cantidad de abonos mínimos\n",
        "mayor_abono = 0  # Almacenará el mayor valor de abono\n",
        "\n",
        "# Recorremos toda la lista de salarios\n",
        "for salario in salarios:\n",
        "    # Calculamos el valor teórico del abono\n",
        "    abono = salario * 0.1\n",
        "    # Si el abono es inferior a 200,\n",
        "    # ajustamos el valor del abono al mínimo (200)\n",
        "    if abono < 200:\n",
        "        abono = 200\n",
        "    # Agregamos un nuevo dato en el diccionario con la clave abono\n",
        "    diccionario_abonos[salario] = abono\n",
        "\n",
        "# Recorremos todos los valores del diccionario de abonos\n",
        "for abono in diccionario_abonos.values():\n",
        "    # Contamos los salarios mínimos\n",
        "    if abono == 200:\n",
        "        abonos_minimo += 1\n",
        "    # Verificamos si el abono leído es mayor que el valor almacenado en mayor_abono\n",
        "    # Cada vez que el abono supere el valor de mayor_abono,\n",
        "    # la variable mayor_abono será igual al abono, asignando un nuevo valor\n",
        "    if abono > mayor_abono:\n",
        "        mayor_abono = abono\n",
        "    # Sumamos los abonos\n",
        "    total_abono += abono\n",
        "# Resultados\n",
        "print(f'Abonos: {diccionario_abonos}')\n",
        "print(f'Total de gastos en abonos: {total_abono}')\n",
        "print(f'Número de empleados que recibieron el abono mínimo: {abonos_minimo}')\n",
        "print(f'Mayor valor de abono: {mayor_abono}')"
      ],
      "metadata": {
        "id": "G7ujWLZtXbeX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "14 - Un equipo de científicos de datos está estudiando la diversidad biológica en un bosque. El equipo recopiló información sobre el número de especies de plantas y animales en cada área del bosque y almacenó estos datos en un diccionario. En él, la clave describe el área de los datos y los valores en las listas corresponden a las especies de plantas y animales en esas áreas, respectivamente.\n",
        "\n",
        "```\n",
        "{'Área Norte': [2819, 7236], 'Área Leste': [1440, 9492], 'Área Sul': [5969, 7496], 'Área Oeste': [14446, 49688], 'Área Centro': [22558, 45148]}\n",
        "```\n",
        "Escribe un código para calcular el promedio de especies por área e identificar el área con la mayor diversidad biológica. Sugerencia: utiliza las funciones incorporadas sum() y len()."
      ],
      "metadata": {
        "id": "OZwVs-7hXcFj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Especificamos los datos para un diccionario\n",
        "datos = {'Área Norte': [2819, 7236],\n",
        "         'Área Este': [1440, 9492],\n",
        "         'Área Sur': [5969, 7496],\n",
        "         'Área Oeste': [14446, 49688],\n",
        "         'Área Centro': [22558, 45148]}\n",
        "# Inicializamos las variables\n",
        "suma_media = 0  # Sumará todos los promedios\n",
        "mayor_diversidad = ''  # Almacenará el área con la mayor diversidad\n",
        "mayor_suma = 0  # Almacenará la mayor suma de especies\n",
        "# Recorremos las claves y elementos del diccionario\n",
        "for área, especies in datos.items():\n",
        "    # Sumamos el número de especies en cada área utilizando la función sum\n",
        "    suma_especies = sum(especies)\n",
        "    # Calculamos el promedio dividiendo la suma de las especies entre la cantidad de especies\n",
        "    media = suma_especies / len(especies)\n",
        "    # Imprimimos\n",
        "    print(f'El {área} tiene un promedio de {media} especies')\n",
        "    # Verificamos si la suma de especies es mayor que el valor almacenado de mayor_suma\n",
        "    # Cada vez que suma_especies supere el valor de mayor_suma,\n",
        "    # la variable mayor_suma será igual a suma_especies, asignando un nuevo valor\n",
        "    # De manera similar, mayor_diversidad también se actualiza\n",
        "    if suma_especies > mayor_suma:\n",
        "        mayor_suma = suma_especies\n",
        "        mayor_diversidad = área\n",
        "    # Sumamos los promedios\n",
        "    suma_media += media\n",
        "# La media total será la suma_media dividida por la cantidad de áreas\n",
        "media_total = suma_media / len(datos)\n",
        "print(f'Media general de especies: {media_total}')\n",
        "print(f'Área con la mayor diversidad biológica: {mayor_diversidad}')"
      ],
      "metadata": {
        "id": "otdk-A7-Xd7y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "15 - El departamento de Recursos Humanos de tu empresa te pidió ayuda para analizar las edades de los colaboradores de 4 sectores de la empresa. Para ello, te proporcionaron los siguientes datos:\n",
        "```\n",
        "{'Setor A': [22, 26, 30, 30, 35, 38, 40, 56, 57, 65],\n",
        " 'Setor B': [22, 24, 26, 33, 41, 49, 50, 54, 60, 64],\n",
        " 'Setor C': [23, 26, 26, 29, 34, 35, 36, 41, 52, 56],\n",
        " 'Setor D': [19, 20, 25, 27, 34, 39, 42, 44, 50, 65]}\n",
        "```\n",
        "Dado que cada sector tiene 10 colaboradores, construye un código que calcule la media de edad de cada sector, la edad media general entre todos los sectores y cuántas personas están por encima de la edad media general."
      ],
      "metadata": {
        "id": "59ms0ucrXlYi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Especificamos los datos para un diccionario\n",
        "datos = {'Sector A': [22, 26, 30, 30, 35, 38, 40, 56, 57, 65],\n",
        "        'Sector B': [22, 24, 26, 33, 41, 49, 50, 54, 60, 64],\n",
        "        'Sector C': [23, 26, 26, 29, 34, 35, 36, 41, 52, 56],\n",
        "        'Sector D': [19, 20, 25, 27, 34, 39, 42, 44, 50, 65]}\n",
        "# Inicializamos la variable que sumará todas las edades\n",
        "total_edades = 0\n",
        "# Recorremos las claves y elementos del diccionario\n",
        "for sector, edades in datos.items():\n",
        "  # Calculamos el promedio dividiendo la suma de las edades entre la cantidad de empleados en cada sector\n",
        "  media_edad = sum(edades) / len(edades)\n",
        "  # Imprimimos\n",
        "  print(f'El {sector} tiene un promedio de {media_edad}')\n",
        "  # Sumamos los promedios\n",
        "  total_edades += sum(edades)\n",
        "# La media total será el total_edades dividido por la cantidad de personas totales (sectores * empleados por sector)\n",
        "media_total = total_edades / (len(edades) * len(datos))\n",
        "print(f'La media de edad general es {media_total}')\n",
        "\n",
        "# Inicializamos la variable que contará a todas las personas con edades por encima de la media\n",
        "arriba_media = 0\n",
        "# Recorremos nuevamente las claves y elementos del diccionario\n",
        "for sector, edades in datos.items():\n",
        "  # Leemos los elementos (edades) dentro de cada lista de edades en el diccionario\n",
        "  for edad in edades:\n",
        "    # Verificamos si el valor de la edad es superior a la media total\n",
        "    if edad > media_total:\n",
        "      # En caso de que el valor de la edad sea superior a la media, incrementamos en uno el contador\n",
        "      arriba_media += 1\n",
        "# Resultado\n",
        "print(f'{arriba_media} personas están por encima de la edad media general')"
      ],
      "metadata": {
        "id": "iJoVmJ7dXqI0"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}