0_Intro_Python/1_Datos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://colab.research.google.com/github/contreras-juan/UPTC_Seminario_ML/blob/main/0_Intro_Python/1_Datos.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Autor:** Nicolás Castillo Ojeda y Andrés Felipe Florez"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2T73d1bptQMR"
   },
   "source": [
    "# **Módulo 1 - Curso: Fundamentos de Python**\n",
    "\n",
    "Bienvenido al curso \"*Introducción al lenguaje de programación Python*\". Durante esta experiencia educativa, nos sumergiremos en los conceptos y técnicas fundamentales de programación utilizando el lenguaje Python. Este primer módulo, contenido en el presente notebook, tiene como objetivo principal proporcionar una sólida introducción a la programación en Python, abordando desde su sintaxis más básica hasta conceptos de nivel intermedio, como ciclos y comprensiones de estructuras de datos.\n",
    "\n",
    "\n",
    "A lo largo de esta lección, exploraremos ejemplos que clarificarán los conceptos presentados, pero también brindarán una visión concreta de las aplicaciones prácticas de cada comando. Este curso está diseñado para guiarlos de manera gradual a través de los aspectos esenciales de Python, creando una base sólida para su desarrollo como programadores.\n",
    "\n",
    "---\n",
    "\n",
    "# **Contenidos:**\n",
    "\n",
    "1. **Introducción a Python**\n",
    "  *   Definición de variables\n",
    "  *   Operaciones básicas\n",
    "  *   Conversion de variables\n",
    "  *   Manejo de Strings\n",
    "2. **Estructuras de datos en Python**\n",
    "  *   Listas\n",
    "  *   Tuplas\n",
    "  *   Conjuntos\n",
    "  *   Diccionarios\n",
    "  *   Rangos\n",
    "3. **Control de flujo**\n",
    "  *   Condicionales\n",
    "  *   Ciclo for\n",
    "  *   Ciclo while\n",
    "  *   Break, continue y pass\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aMkZsHY5tzQv"
   },
   "source": [
    "# **1. Introducción a Python**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZdqDbnr-uX94"
   },
   "source": [
    "### 1.1. Definición de variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "R1PWIsmI6OBc"
   },
   "source": [
    "---\n",
    "Definición de variables\n",
    "\n",
    "---\n",
    "\n",
    "Antes de empezar a programar en Python, tenga en cuenta que el uso de comentarios es indispensable para poseer un flujo de trabajo óptimo y organizado ya que le pueden ayudar a dar una descripción acertada su código. Así pues, los comentarios son herramientas útiles para dar pistas al programador a cerca de que procedimientos están ocurriendo o deben tenerse en cuenta en una parte específica del código.\n",
    "\n",
    "Exísten dos tipos de comentarios en Python:\n",
    "\n",
    "* Comentarios de una única línea\n",
    "* Comentarios de múltiples líneas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "O58u4x-161yl"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de comentario de una única línea"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "BN9s517q66dD"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de comentario de\n",
    "# múltiples líneas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "POGa2oXk3WTo"
   },
   "source": [
    "En conjunto con los comentarios, exísten dos comandos/funciones muy útiles en el proceso deprogramación como tal, los cuales son:\n",
    "* `type()` : Permite conocer el tipo de la variable o dato.\n",
    "* `print()` : Al mostrar información por consola o terminal.\n",
    "\n",
    "La función `print()` es particularmente util para el programador pues le ayuda a visualizar los datos que hacen parte de su flujo de trabajo en cada punto que el desee observarlos, permitiendo un seguimiento de la ejecución dándole conocimiento a cerca que ocurre en un punto de interés."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Xhwq0yqkvqqO"
   },
   "source": [
    "En Python, los tipos de datos son categorías que definen el tipo de valores que pueden almacenarse y manipularse en un programa. Siendo una variable un contenedor de valores, cada una tiene un tipo asociado, que determina la naturaleza de la información que representa y cómo se almacena en la memoria de la computadora. Dentro de Python los tipos básicos de variables son:\n",
    "\n",
    "* Enteros (int): Números enteros como 42, -10, 0.\n",
    "* Flotantes (float): Números decimales como 3.14, -0.5.\n",
    "* Cadenas o Strings (str): Secuencias de caracteres, como \"Hola, mundo!\".\n",
    "* Booleanos (bool): Representa verdadero o falso.\n",
    "* None: Tipo dedato especial que representa la ausencia de valor o falta de un objeto significativo.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 184,
     "status": "ok",
     "timestamp": 1705467271218,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "h9ihKI7Ev4Y7",
    "outputId": "18016adf-a03d-4d06-bf6b-531203904f4d"
   },
   "outputs": [],
   "source": [
    "# Variables tipo String\n",
    "\n",
    "name = \"Pepe Perez Martinez\"            # String\n",
    "other_name = 'Otro Pepe Perez Martinez' # String\n",
    "age_string = \"28\"                       # 'Int' en formato String\n",
    "\n",
    "print(name)\n",
    "print(other_name)\n",
    "print(age_string)\n",
    "\n",
    "print(type(name), type(other_name), type(age_string))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 201,
     "status": "ok",
     "timestamp": 1705467287368,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "84yqvzbFxWIW",
    "outputId": "5b0d529e-d3e5-480b-e173-3e13b4e711fb"
   },
   "outputs": [],
   "source": [
    "# Variables tipo Int\n",
    "age = 28  # Int\n",
    "print(\"Su edad es: \", age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 181,
     "status": "ok",
     "timestamp": 1705467431714,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "u22V06JjqsEq",
    "outputId": "7d3d8404-dbe6-4733-a62c-35e8990b7d47"
   },
   "outputs": [],
   "source": [
    "# Variable tipo float\n",
    "\n",
    "a_float = 1.63\n",
    "b_float = 2.456\n",
    "\n",
    "print(a_float, b_float)\n",
    "print(type(a_float), type(b_float))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 173,
     "status": "ok",
     "timestamp": 1705467331594,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "bfj1vEbHxZxW",
    "outputId": "95d0f002-0ca1-4c05-9e9e-65310b4161ea"
   },
   "outputs": [],
   "source": [
    "# Variable tipo boolean\n",
    "check = False\n",
    "another_check = True\n",
    "\n",
    "print(check, another_check)\n",
    "print(type(check), type(another_check))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 12656,
     "status": "ok",
     "timestamp": 1705467550244,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "WaDn4sgNvPKM",
    "outputId": "6fd5f240-c6e6-48be-d2bc-d2e81eeb50dc"
   },
   "outputs": [],
   "source": [
    "# Asignación de variable por entrada\n",
    "\n",
    "my_name = input(\"Cuál es tu nombre? \")\n",
    "my_age  = input(\"Cuál es tu edad?\")\n",
    "\n",
    "print(\"*\"*10)\n",
    "print(\"tu nombre es \", my_name)\n",
    "print(\"tu edad es \", my_age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sXCHqbKGkLP8"
   },
   "source": [
    "En programación, el valor de una variable puede ser constantemente reasignado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 157,
     "status": "ok",
     "timestamp": 1705614979379,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "t1TfJDrPkSlu",
    "outputId": "a60cd76c-cc94-4650-8c4b-6ddedc0c9fbc"
   },
   "outputs": [],
   "source": [
    "# Definición de una variable\n",
    "variable = \"mi primer programa\"\n",
    "print(variable)\n",
    "\n",
    "# Reasignacion de valor a una variable\n",
    "variable = \"mi segundo Programa!!\"\n",
    "print(variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r0T-BbEpkqfV"
   },
   "source": [
    "Python permite asignar dentro de una mísma línea de código, valores a múltiples variables o el mísmo valor a múltiples variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 154,
     "status": "ok",
     "timestamp": 1705615164054,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "BDtstg2tkzl0",
    "outputId": "220e3513-2248-4b43-dd15-216b94251c08"
   },
   "outputs": [],
   "source": [
    "# Asignación de múltiples variables\n",
    "a, b, c = 23, 65, 16\n",
    "\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "\n",
    "print(\"*********************************\")\n",
    "\n",
    "# Asignación de un mísmo valor a múltiples variables\n",
    "\n",
    "a = b = c = \"Asignación multiple\"\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1705615936549,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "9Lpoh3OpoYfb",
    "outputId": "8c032c46-d351-4ac6-b047-2370fc86a5b8"
   },
   "outputs": [],
   "source": [
    "# Tipo None\n",
    "\n",
    "a = None\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MMZmEy4jllOj"
   },
   "source": [
    "En general, exísten ciertas reglas o buenas prácticas para dar nombre a una variable en Python las cuales son:\n",
    "\n",
    "* Los nombres de variables y constantes deben tener una combinación de letras en  minúscula, mayúscula, dígitos (0 al 9) o barras bajas (_).\n",
    "* Se recomienda que cada nombre de variable o constante tenga relación con el proósito/naturaleza de la variable o constante.\n",
    "* Si desea crear una variable compuesta de varias palabras, una estas con una barra baja (_).\n",
    "* Python diferencia entre minúsculas y mayusculas (case-sensitive).\n",
    "* Evite el uso de palabras resevadas como \"if, True, False, for\" entre otras, para identificar sus variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 174,
     "status": "ok",
     "timestamp": 1705615710609,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "OwvGHi5HmcRW",
    "outputId": "9ff600b3-bc3f-4a5c-b5f6-6d39bcca20e3"
   },
   "outputs": [],
   "source": [
    "# Nombres permitidos para variables\n",
    "variable = 9\n",
    "VaRiAble_ = 8\n",
    "VARIABLE = 7\n",
    "variable9 = 5\n",
    "\n",
    "# Congruencia del nombre de la variable con su objetivo naturaleza\n",
    "pi = 3.1416\n",
    "e  = 2.7182\n",
    "\n",
    "# Nombre de variable compuesto\n",
    "my_variable_con_nombre_complejo = 27\n",
    "\n",
    "# Case sensitive\n",
    "a = 109\n",
    "A = 632\n",
    "print(variable == VARIABLE)\n",
    "print(a)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mGcsKdYg3EZc"
   },
   "source": [
    "### 1.2. Operaciones básicas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OHxnV-DVsgFx"
   },
   "source": [
    "---\n",
    "Operaciones básicas\n",
    "\n",
    "---\n",
    "\n",
    "En programación, un operador es un símbolo especial que realiza operaciones en uno o mas operandos. Los operandos pueden ser variables, valores o expresiones, y los operadores definen cómo se realiza la operación entre ellos. Exísten cuatro tipos de operadores:\n",
    "* Operadores aritméticos.\n",
    "* Operadores de comparación.\n",
    "* Operadores lógicos.\n",
    "* Operadores de asignación.\n",
    "* Operadores especiales."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9w_X7PcuqFVS"
   },
   "source": [
    "Dentro de Python los operadores aritméticos son:\n",
    "* Adición (`+`) y sustraccion (`-`)\n",
    "* Multiplicación (`*`) y divisón (`/`)\n",
    "* División entera (`//`)\n",
    "* Módulo (`%`)\n",
    "* Potenciación (`**`)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 168,
     "status": "ok",
     "timestamp": 1705616605853,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "3cOyRUYy3Gk8",
    "outputId": "f8d8a461-b514-4f24-fbc6-88a129a31404"
   },
   "outputs": [],
   "source": [
    "# Operaciones básicas con números\n",
    "a = 16\n",
    "b = 8\n",
    "\n",
    "number_1 = a + b\n",
    "number_2 = a - b\n",
    "number_3 = a * b\n",
    "number_4 = a / b\n",
    "number_5 = a // b\n",
    "number_6 = a % b\n",
    "number_7 = a ** b\n",
    "\n",
    "print(number_1)\n",
    "print(number_2)\n",
    "print(number_3)\n",
    "print(number_4)\n",
    "print(number_5)\n",
    "print(number_6)\n",
    "print(number_7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AEbL33hSrE-h"
   },
   "source": [
    "Dentro de Python, los operadores de comparación son:\n",
    "* Igualdad (`==`)\n",
    "* Desigualdad (`!=`)\n",
    "* Mayor que (`>`) y menor que (`<`)\n",
    "* Mayor o igual que (`>=`) menor o igual que (`<=`)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1705616948574,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "bIP1qShxqE1y",
    "outputId": "c7776a88-c54f-402e-9b40-05a447f6cc07"
   },
   "outputs": [],
   "source": [
    "# Operaciones de comparación\n",
    "menor = 4\n",
    "mayor = 8\n",
    "\n",
    "print(menor == mayor)   #False\n",
    "print(menor < mayor)    #True\n",
    "print(menor > mayor)    #False\n",
    "print(menor != mayor)   #True\n",
    "print(mayor >= menor)   #True\n",
    "print(mayor >= mayor)   #True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fCT996c5s1QS"
   },
   "source": [
    "Dentro de Python los operadoreslógicos son:\n",
    "* AND (`and`)\n",
    "* OR (`or`)\n",
    "* NOT (`not`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 154,
     "status": "ok",
     "timestamp": 1705620747923,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "dwJUPWVytGaR",
    "outputId": "0f239f7e-1f70-48ee-a9e7-5e66813b650e"
   },
   "outputs": [],
   "source": [
    "# Operaciones de lógica\n",
    "resultado_and = (True and False)\n",
    "resultado_or  = (True or False)\n",
    "resultado_not = not True\n",
    "\n",
    "print(resultado_and)\n",
    "print(resultado_or)\n",
    "print(resultado_not)\n",
    "\n",
    "print(\"*\"*16)\n",
    "\n",
    "a = 3\n",
    "b = 9\n",
    "\n",
    "resultado_and = ((a < b) and (a != b))\n",
    "resultado_or  = ((a < b) or (a == b))\n",
    "resultado_not = not(a <= b)\n",
    "\n",
    "print(resultado_and)\n",
    "print(resultado_or)\n",
    "print(resultado_not)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 205,
     "status": "ok",
     "timestamp": 1705620865121,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "n0cMgm3B6_z2",
    "outputId": "c0299b95-7b15-4d93-8fbd-d2687d1e6908"
   },
   "outputs": [],
   "source": [
    "a = 3\n",
    "b = 9\n",
    "\n",
    "resultado_and = ((a < b) & (a != b))\n",
    "resultado_or  = ((a < b) | (a == b))\n",
    "\n",
    "print(resultado_and)\n",
    "print(resultado_or)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CG6lBudytw-R"
   },
   "source": [
    "En Python, los operadores de asignación son:\n",
    "* Asignación (`=`)\n",
    "* Incremento (`+=`) y decremento (`-=`)\n",
    "* Multiplicación (`*=`) y división (`/=`)\n",
    "* Asignación de módulo (`%=`)\n",
    "* Asignación de exponente (`**=`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 198,
     "status": "ok",
     "timestamp": 1705620544866,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "0BuDDD5IuIYD",
    "outputId": "bb86ccb6-59dd-48fa-83aa-e1dc2bcbeed3"
   },
   "outputs": [],
   "source": [
    "# Operadores de asignación\n",
    "a = 13\n",
    "a += 1\n",
    "print(\"a + 1 : \", a )\n",
    "\n",
    "a = 13\n",
    "a -= 5\n",
    "print(\"a - 5 : \", a )\n",
    "\n",
    "a = 13\n",
    "a *= 2\n",
    "print(\"a * 2 : \", a )\n",
    "\n",
    "a = 13\n",
    "a /= 13\n",
    "print(\"a / 13 :\", a )\n",
    "\n",
    "a = 13\n",
    "a %= 2\n",
    "print(\"a % 2 :\", a )\n",
    "\n",
    "a = 13\n",
    "a **= 2\n",
    "print(\"a ** 2 :\", a )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qBdD3Kqu8NRH"
   },
   "source": [
    "Los operadores especiales dentro de Python son aquellos que sonusados para corroborar identidad y pertenencia, entre ellos encontramos:\n",
    "* Operadores de identidad: `is`  y `is not`.\n",
    "* Operadores de membresía: `in` y `not in`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 155,
     "status": "ok",
     "timestamp": 1705621345296,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "noB7gnU88nSH",
    "outputId": "a889669f-b711-4f42-c728-235a91ce8fae"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de operadores de identidad\n",
    "x_1 = 40\n",
    "x_2 = \"cuarenta\"\n",
    "y_1 = 73\n",
    "y_2 = \"cuarenta\"\n",
    "\n",
    "print(x_1 is y_1)\n",
    "print(x_2 is y_2)\n",
    "print(x_1 is not y_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 156,
     "status": "ok",
     "timestamp": 1705621440224,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "31EvD9qq9JlF",
    "outputId": "25f0f951-6225-4cab-e534-6e26e9429812"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de operadores de membresía\n",
    "x = \"esto es una cadena de caracteres\"\n",
    "\n",
    "print(\"cadena\" in x)\n",
    "print(\"cuarenta\" in x)\n",
    "print(\"cuarenta\" not in x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hdrhotSgiDl0"
   },
   "source": [
    "### 1.3. Conversión de variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4af5lJQSpKba"
   },
   "source": [
    "---\n",
    "Conversión de variables\n",
    "\n",
    "---\n",
    "\n",
    "En programación, la conversión de variables es el proceso mediante el cual el tipo de variable/dato es cambiado por otro. Por ejemplo, una conversion de variable puede ser el transformar un dato tipo `int` a `float`. Exísten dos tipos de conversion de variables:\n",
    "* Conversion implícita: Conversion automatica de variables.\n",
    "* Convesion explicita (type casting): Conversion manual de variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sbcH232_yiMX"
   },
   "source": [
    "La conversion implícita de variables es el cambio de tipo de variable hecho mediante la deducción del compilador frente a alguna clase de operación, dicha conversion no es explícitamente hecha por el programador."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 156,
     "status": "ok",
     "timestamp": 1705618365939,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "PidXpFhNw2nB",
    "outputId": "b30270f6-78e4-4601-c1a1-6884178fe3e7"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de conversión implicita\n",
    "numero_entero = 42\n",
    "numero_float  = 176.34\n",
    "\n",
    "nuevo_numero = numero_entero + numero_float\n",
    "print(nuevo_numero)\n",
    "print(type(nuevo_numero))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hapOm2ADyuWD"
   },
   "source": [
    "La conversion explícita es el cambio de tipo de una variable explícitamente efectuada por el programador. Dentro de los comandos de conversion explícita encontramos:\n",
    "* `int()`\n",
    "* `float()`\n",
    "* `str()`\n",
    "* `bool()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 171,
     "status": "ok",
     "timestamp": 1705618741437,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "j_bfTO53x1Tx",
    "outputId": "264ef402-a492-471d-d3f2-c87920413ced"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de conversion explícita\n",
    "\n",
    "numero_string = \"26\"\n",
    "numero_entero = 93\n",
    "\n",
    "print(\"tipo de numero: \", type(numero_string))\n",
    "\n",
    "numero_string = int(numero_string)\n",
    "\n",
    "nuevo_numero = numero_string + numero_entero\n",
    "\n",
    "print(nuevo_numero)\n",
    "print(type(nuevo_numero))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 164,
     "status": "ok",
     "timestamp": 1705619186498,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "dJXEip2ZzjhA",
    "outputId": "6be159a1-5d07-4fbc-fdae-b2ad641e9584"
   },
   "outputs": [],
   "source": [
    "# Conversion entero -> flotante y flotante -> entero\n",
    "a = 13\n",
    "print(type(a))\n",
    "\n",
    "a = float(a)\n",
    "print(type(a))\n",
    "\n",
    "a = int(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 225,
     "status": "ok",
     "timestamp": 1705619247329,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "boE6PNm70bA5",
    "outputId": "d1261a2b-1cfa-4d63-cb1c-688458db7d5a"
   },
   "outputs": [],
   "source": [
    "# Conversion entero -> booleano\n",
    "a = 13\n",
    "\n",
    "print(a)\n",
    "a = bool(a)\n",
    "print(a)\n",
    "print(type(a))\n",
    "\n",
    "\n",
    "a = - 13\n",
    "a = 0\n",
    "print(a)\n",
    "a = bool(a)\n",
    "print(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GSRZT57B1Wr4"
   },
   "source": [
    "Es importante recordar lo siguiente en cuanto a la conversion de variables:\n",
    "* La conversion implícita se evita la pérdida de información.\n",
    "* La conversion explícita puede generar pérdidad de información.\n",
    "* En una conversion explícita, debe existir compabilidad de tipos entre el tipo de datos que se espera después de la conversion y antes de la conversion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 9,
     "status": "ok",
     "timestamp": 1705619572342,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "aU1uaB192LN_",
    "outputId": "d30aaa5f-a3be-441e-8bd6-46439ab95804"
   },
   "outputs": [],
   "source": [
    "# Ejemplo depreservación de información en la conversion implícita\n",
    "a = 3.546\n",
    "b = 8\n",
    "c = a + b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 160,
     "status": "ok",
     "timestamp": 1705619623081,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "slPsA6PX2Vsf",
    "outputId": "8ebe1ae2-231a-405c-dbbd-6489c9698f88"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de pérdida de información en la conversion explícita\n",
    "a = 3.546\n",
    "a = 3.946\n",
    "a = int(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "G6Q-C2xz2kwP"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de incompatibilidad de tipos de entrada y salida en la conversion explícita\n",
    "\n",
    "cadena_no_numerica = \"no es un numero\"\n",
    "entero = int(cadena_no_numerica)\n",
    "entero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 153,
     "status": "ok",
     "timestamp": 1705619721228,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "D5C9nrH32kpG",
    "outputId": "944f5735-ce56-4e98-def3-96997e4bb81f"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de compatibilidad de tipos de entrada y salida en la conversion explícita\n",
    "\n",
    "cadena_numerica = \"813\"\n",
    "entero = int(cadena_numerica)\n",
    "entero"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CTtuKyPCyzl6"
   },
   "source": [
    "### 1.4. Manejo de Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qAyLrChZ-AUV"
   },
   "source": [
    "---\n",
    "Manejo de Strings\n",
    "\n",
    "---\n",
    "\n",
    "Dentro de Python, los Strings o cadenas de caracteres son secuencias de caracteres que admiten diversas operaciones y manipulaciones tales como:\n",
    "* Concatenación.\n",
    "* Repetición.\n",
    "* Acceso y Slicing.\n",
    "* Métodos o funciones aplicados a cadenas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fHqFiYb3-dI9"
   },
   "source": [
    "La concatenación de cadenas puede entenderse como la adicción de cadenas de caracteres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 168,
     "status": "ok",
     "timestamp": 1705467874935,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "xFJSnZdhy1sq",
    "outputId": "572aeb1c-4729-49f7-fa3a-428d6e7a0813"
   },
   "outputs": [],
   "source": [
    "# Concatenación de strings\n",
    "\n",
    "name = \"Pepe Perez\"\n",
    "last_name = \"Martinez\"\n",
    "full_name = name + last_name\n",
    "\n",
    "full_name_with_space = name + \" \" + last_name\n",
    "\n",
    "print(\"Tu nombre completo es: \", full_name)\n",
    "print(\"Tu nombre completo es: \", full_name_with_space)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lLTjscja-nW0"
   },
   "source": [
    "Dentro de una cadena de caracteres, es posible usar comillas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 161,
     "status": "ok",
     "timestamp": 1705621965735,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "szdcj2XFzrY_",
    "outputId": "9dd28f20-63ce-476b-ee84-929e6f847c4a"
   },
   "outputs": [],
   "source": [
    "# Strings con doble comillas\n",
    "cadena = 'Cadena con doble \"comilla\" '\n",
    "print(cadena)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DRzSWgyd_d38"
   },
   "source": [
    "Dentro de las operaciones básicas con strings, la repeticion es una multiplicación de caracteres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "executionInfo": {
     "elapsed": 168,
     "status": "ok",
     "timestamp": 1705622032149,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "QzC6IRJy_n4-",
    "outputId": "8ab48650-f370-40c3-f5d5-f361ab596b5b"
   },
   "outputs": [],
   "source": [
    "# Repeticion de strings\n",
    "cadena = \"Cadena corta?\"\n",
    "cadena*10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-Gay6fNp_v12"
   },
   "source": [
    "El acceso y slicing de cadenas se refiere a la selección específica de caracteres dentro de una cadena y a la rebanación de la cadena de caracteres respectivamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 145,
     "status": "ok",
     "timestamp": 1705622352616,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "v0Omih62ALiv",
    "outputId": "e30aacbd-21a3-4bb4-a77c-22968d8103fb"
   },
   "outputs": [],
   "source": [
    "# Indexación de strings\n",
    "cadena_1 = \"Pepe\"\n",
    "\n",
    "primera_letra = cadena_1[0]\n",
    "segunda_letra = cadena_1[1]\n",
    "\n",
    "print(primera_letra)\n",
    "print(segunda_letra)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 164,
     "status": "ok",
     "timestamp": 1705622442078,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "k7EmBI04A2NV",
    "outputId": "3eb76800-8a0f-4e50-fdd7-a8289e8d8713"
   },
   "outputs": [],
   "source": [
    "# Slicing de strings\n",
    "cadena_1 = \"Pepe Perez Martinez\"\n",
    "\n",
    "primera_palabra = cadena_1[0:4]\n",
    "primera_palabra_mas_espacio = cadena_1[0:7]\n",
    "\n",
    "print(primera_palabra)\n",
    "print(primera_palabra_mas_espacio)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0Ee3n2mSBq8s"
   },
   "source": [
    "Dentro de los métodos más comúnes para la manipulación de strings se encuentran:\n",
    "* `len()`: Permite conocer la cantidad de caracteres que conforman la cadena.\n",
    "* `.upper()`: Permite transformar todos los caracteres a mayúscula.\n",
    "* `.lower()`: Permite transformar todos los caracteres a minúscula.\n",
    "* `.replace(input, output)`: Permite remplazar la cadena `input` por la cadena `output`.\n",
    "* `.find(input)` e `.index(input)`: Permite conocer la posición de la cadena `input` en la cadena de caracteres.\n",
    "* `.count(input)`: Permite conocer el número de veces que la cadena `input` se encuentra en la cadena de caracteres.\n",
    "* `.split(separator)`: Permite dividir la cadena de caracteres de acuerdo a el separador `separator`.\n",
    "* `.format(variable_1, variable_2, ...,)`: Permite intertar las variables `variable_1`, `variable_2`, ... , `variable_n` dentro de la cadena de caracteres en orden de aparición dentro de cada `{}`.\n",
    "* `.strip()`: Permite eliminar espacios en blanco.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 201,
     "status": "ok",
     "timestamp": 1705623269735,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "8GCW5ut4Bqh2",
    "outputId": "ecd7158c-286e-447a-a631-2f800e795a8c"
   },
   "outputs": [],
   "source": [
    "# Función len()\n",
    "cadena = \"mi cadena de caracteres\"\n",
    "len(cadena)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 188,
     "status": "ok",
     "timestamp": 1705623356931,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "cqmgmxbAEkpj",
    "outputId": "e2def4f6-7b89-4cbb-ba69-2a0f4372de57"
   },
   "outputs": [],
   "source": [
    "# Función .upper(), .lower()\n",
    "cadena = \"Pepe Perez\"\n",
    "print( cadena.upper() )\n",
    "print( cadena.lower() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 164,
     "status": "ok",
     "timestamp": 1705623431559,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "NoUO67h8Ez-f",
    "outputId": "bfa87ffb-24f2-4083-8565-abb0bd255535"
   },
   "outputs": [],
   "source": [
    "# Función .replace()\n",
    "cadena = \"Python es dificil de entender\"\n",
    "cadena = cadena.replace(\"dificil\", \"fácil\")\n",
    "\n",
    "print(cadena)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 152,
     "status": "ok",
     "timestamp": 1705623618981,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "aj_Yoa8cFJJz",
    "outputId": "4cc0fc1d-beb4-409e-90df-9ef2375dc684"
   },
   "outputs": [],
   "source": [
    "# Funciones find() e index()\n",
    "cadena = \"Ciencia de datos\"\n",
    "\n",
    "posicion_1 = cadena.find(\"c\")\n",
    "posicion_2 = cadena.find(\"C\")\n",
    "\n",
    "print(posicion_1)\n",
    "print(posicion_2)\n",
    "\n",
    "\n",
    "cadena = \"ciencia de datos\"\n",
    "\n",
    "posicion_1 = cadena.find(\"c\")\n",
    "posicion_2 = cadena.index(\"c\")\n",
    "print(posicion_1)\n",
    "print(posicion_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 148,
     "status": "ok",
     "timestamp": 1705623703251,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "NvAfidkWF5Vr",
    "outputId": "dbf38ced-5f1a-4933-fb14-5832bd72963c"
   },
   "outputs": [],
   "source": [
    "# Funcion .count()\n",
    "cadena = \"Mussissipi\"\n",
    "cuantas_s = cadena.count(\"s\")\n",
    "cuantas_s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 164,
     "status": "ok",
     "timestamp": 1705623766958,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "PKvDgHBDGHfq",
    "outputId": "06991d22-0665-41ae-fbd7-364806322a1e"
   },
   "outputs": [],
   "source": [
    "# Función .split()\n",
    "cadena = \"python, c++, javascript, r\"\n",
    "lista_de_cadenas = cadena.split(\",\")\n",
    "lista_de_cadenas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 179,
     "status": "ok",
     "timestamp": 1705623905405,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "qtv7iTVPz3QW",
    "outputId": "e6d834f5-3a7d-4f3a-a502-379d3391db06"
   },
   "outputs": [],
   "source": [
    "# Función .format()\n",
    "name = \"Pablo\"\n",
    "last_name = \"Perez\"\n",
    "age = \"28\"\n",
    "\n",
    "cadena = \"Hola, mi nombre es \" + name + \" y mi apellido es \" + last_name + \" y mi edad es \" + age\n",
    "print('cadena_1 = ', cadena)\n",
    "\n",
    "template = \"Hola, mi nombre es {} y mi apellido es {} y mi edad es {}\".format(name, last_name, age)\n",
    "print('cadena_2 = ', template)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "executionInfo": {
     "elapsed": 158,
     "status": "ok",
     "timestamp": 1705623937727,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "WTv3RYrcz86E",
    "outputId": "18d179eb-e460-43aa-ae0c-5bf89e2a0a28"
   },
   "outputs": [],
   "source": [
    "# Función .strip()\n",
    "cadena = \" mi cadena tiene muchos espacios    \"\n",
    "cadena = cadena.strip()\n",
    "cadena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e3xXlj50t5--"
   },
   "source": [
    "# **2. Estructuras de datos en Python**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iADXFGIsze07"
   },
   "source": [
    "En Python, un objeto iterable es un tipo de objeto que se puede recorrer o iterar mediante algún bucle o indexación. Dentro de Python los objetos iterables son:\n",
    "* Listas\n",
    "* Tuplas\n",
    "* Strings\n",
    "* Conjuntos\n",
    "* Diccionarios\n",
    "* Rangos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Hdg8gL8Bz4QR"
   },
   "source": [
    "### 2.1. Listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "990CCN_K2-4Y"
   },
   "source": [
    "---\n",
    "Listas\n",
    "\n",
    "---\n",
    "\n",
    "Una lista es una estructura de datos versátil y fundamental. Permite y organizar datos de manera ordenada y modificable. Una lista es una colección ordenada y modificable de elementos donde cada uno de ellos puede ser de cualquier tipo. Una lísta es una colección de objetos definible a partir de corchetes `[]` y cuyos elementos están separados por  `,`. Las listas poseen las siguientes características:\n",
    "* **Ordenadas:** los elementos de una lista mantienen el orden en el que se insertaron.\n",
    "* **Modificables:** Los objetos de una lista pueden ser cambiados por otros.\n",
    "* **Heterogéneas:** Una lista puede contener diferentes tipos de datos.\n",
    "* **Índices:** Cada elemento de la lista tiene u índice, empezando desde 0 para el primer elemento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1705636788329,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "nbCLEUBKt8Wb",
    "outputId": "db75ce64-563d-447e-ec8b-eea03f9b88c8"
   },
   "outputs": [],
   "source": [
    "# Ejemplos de listas\n",
    "\n",
    "lista = [1,2,3,4]\n",
    "lista_cadena = ['programar','en','python']\n",
    "lista_mixta = [1, 'un string', True, 3.1416]\n",
    "\n",
    "print(lista)\n",
    "print(lista_cadena)\n",
    "print(lista_mixta)\n",
    "print(type(lista_mixta))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1705637353721,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "wM8Pwy6F5ICJ",
    "outputId": "6f58cd32-8268-4d16-a265-02334a5dfe86"
   },
   "outputs": [],
   "source": [
    "# Acceso por índice a los elementos de una lísta\n",
    "\n",
    "mi_lista = [1,2,3,4,5,6]\n",
    "\n",
    "elemento_1 = mi_lista[0]\n",
    "elemento_2 = mi_lista[1]\n",
    "elemento_3 = mi_lista[2]\n",
    "\n",
    "print(mi_lista)\n",
    "print(elemento_1)\n",
    "print(elemento_2)\n",
    "print(elemento_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 177,
     "status": "ok",
     "timestamp": 1705637627850,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "98xjUvt57Afy",
    "outputId": "aa57f12c-946f-410c-ed35-55d571f55506"
   },
   "outputs": [],
   "source": [
    "# Acceso por índice negativo a los elementos de una lísta\n",
    "\n",
    "mi_lista = [1,2,3,4,5,6]\n",
    "\n",
    "elemento_1 = mi_lista[-1]\n",
    "elemento_2 = mi_lista[-2]\n",
    "elemento_3 = mi_lista[-3]\n",
    "\n",
    "print(mi_lista)\n",
    "print(elemento_1)\n",
    "print(elemento_2)\n",
    "print(elemento_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1705637327440,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "I8zdcnBX5yzS",
    "outputId": "6ea9ddf3-4f3b-4267-d5f3-15210968d980"
   },
   "outputs": [],
   "source": [
    "# Reasignación de elementos de una lista\n",
    "\n",
    "mi_lista = [1,2,3,4,5,6]\n",
    "\n",
    "mi_lista[0] = 13\n",
    "mi_lista[1] = 26\n",
    "mi_lista[2] = 39\n",
    "\n",
    "print(mi_lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 8,
     "status": "ok",
     "timestamp": 1705639372955,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "FLnPdY1PBcrq",
    "outputId": "3a60c00b-728f-480c-f0f9-17ae64129b46"
   },
   "outputs": [],
   "source": [
    "# Adición de listas\n",
    "mi_lista_numeros = [1, 2, 3, 4]\n",
    "mi_lista_string = [\"cadena_1\", \"cadena_2\", \"cadena_3\"]\n",
    "\n",
    "nueva_lista = mi_lista_numeros + mi_lista_string\n",
    "print(nueva_lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-3D6MjLR6LAu"
   },
   "source": [
    "Los métodos más comúnes y útiles para la manipulación de listas son:\n",
    "* `len()`: Regresa la longitud de la lista.\n",
    "* `count()`: Cuenta cuántas veces aparece un elemento en la lista.\n",
    "* `index()`: Regresa el índice de un elemento especificado dentro de la lista.\n",
    "* `append()`: Añade un elemento al final de la lista.\n",
    "* `insert()`: Inserta un elemento en una posición especificada.\n",
    "* `remove()`: Elimina el primer elemento con el valor especificado.\n",
    "* `pop()`: Elimina el elemento del ínice especificado y lo devuelve.\n",
    "* `reverse()`: Revierte el orden de los elementos de la lista.\n",
    "* `sort()`: Organiza de manera ascendente los elementos de la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 159,
     "status": "ok",
     "timestamp": 1705637959914,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "kuC-0CLFt5TM",
    "outputId": "ad2db91e-49ba-47c5-94e9-2d6b94a86d1c"
   },
   "outputs": [],
   "source": [
    "# Fución len()\n",
    "mi_lista = [1, 2, 3, 4, 5, 6, 7, 8]\n",
    "print( len(mi_lista) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 8,
     "status": "ok",
     "timestamp": 1705638196910,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "9JTnbLJz8ebs",
    "outputId": "a342f466-6f35-4a9e-cf08-00e696dce4ee"
   },
   "outputs": [],
   "source": [
    "# Función count()\n",
    "mi_lista = [1, 2, 3, 1, 2, 5, 1]\n",
    "mi_lista_2 = [\"cadena_1\", \" cadena_2\", \"cadena_1\", \"cadena_3\"]\n",
    "\n",
    "cantidad_de_unos = mi_lista.count(1)\n",
    "cantidad_string = mi_lista_2.count(\"cadena_1\")\n",
    "\n",
    "print(cantidad_de_unos)\n",
    "print(cantidad_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1705638281156,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "GTpmVOoU9dl3",
    "outputId": "11d100bc-cb6f-4234-ed40-8f30f9dd0525"
   },
   "outputs": [],
   "source": [
    "# Función .index()\n",
    "mi_lista = [\"python\", \"R\", \"JavaScript\",\"R\"]\n",
    "\n",
    "indices = mi_lista.index(\"R\")\n",
    "\n",
    "print(indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 279,
     "status": "ok",
     "timestamp": 1705638445746,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "4l5_Igkg92hx",
    "outputId": "6bfa2761-597c-4545-af87-d5cc5c216801"
   },
   "outputs": [],
   "source": [
    "# Función .append()\n",
    "mi_lista = [\"monica\", \"andrés\", \"juan\"]\n",
    "\n",
    "mi_lista.append(\"nicolas\")\n",
    "print(mi_lista)\n",
    "\n",
    "mi_lista = mi_lista.append(\"nicolas\")\n",
    "print(mi_lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 183,
     "status": "ok",
     "timestamp": 1705639218533,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "4pKLnS1PAqb3",
    "outputId": "197b4ce9-b22d-4a10-9faf-4d50b4e723e4"
   },
   "outputs": [],
   "source": [
    "# Función .insert()\n",
    "mi_lista = [1, 2, 3, 4]\n",
    "mi_lista.insert(5, \"numero 5\")\n",
    "print(mi_lista)\n",
    "\n",
    "mi_lista = mi_lista.insert(5, \"numero 5\")\n",
    "print(mi_lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 172,
     "status": "ok",
     "timestamp": 1705639501724,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "PggnRsUCCEj5",
    "outputId": "704f05a4-3d76-48e0-e48a-298c69016f97"
   },
   "outputs": [],
   "source": [
    "# Función .remove()\n",
    "mi_lista = [\"objeto 1\", \"objeto 2\", \"objeto 3\"]\n",
    "mi_lista.remove(\"objeto 2\")\n",
    "\n",
    "print(mi_lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1705639662982,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "4kgZ4GGHCgvW",
    "outputId": "906055a3-ed0e-4a52-ffb2-7ada76deb41a"
   },
   "outputs": [],
   "source": [
    "# Función .pop()\n",
    "mi_lista = [\"objeto 1\", \"objeto 2\", \"objeto 3\"]\n",
    "mi_lista.pop()\n",
    "\n",
    "print(mi_lista)\n",
    "\n",
    "mi_lista = [\"objeto 1 \", \"objeto 2\", \"objeto 3\"]\n",
    "\n",
    "indice = mi_lista.index(\"objeto 2\")\n",
    "mi_lista.pop(indice)\n",
    "\n",
    "print(mi_lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 3,
     "status": "ok",
     "timestamp": 1705639785809,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "cIMhkCNvDCdk",
    "outputId": "9063e92b-8df3-4f6b-bea0-fa1a4adcff89"
   },
   "outputs": [],
   "source": [
    "# Función .reverse()\n",
    "mi_lista = [1, 2, 3, 4, 5, 6]\n",
    "mi_lista.reverse()\n",
    "\n",
    "print(mi_lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1705639928685,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "m8Jdyf2ODjrR",
    "outputId": "f0a708b5-c457-4f0d-a6c8-39b413631204"
   },
   "outputs": [],
   "source": [
    "# Función .sort()\n",
    "mi_lista = [1,5,2,3,2,4,2,6,4,5]\n",
    "mi_lista.sort()\n",
    "\n",
    "print(mi_lista)\n",
    "\n",
    "mi_lista = [\"ts\",\"he\",\"ar\"]\n",
    "mi_lista.sort()\n",
    "\n",
    "print(mi_lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W4R5W9uYF9iK"
   },
   "source": [
    "### 2.2. Tuplas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L5MTN-KGGK_J"
   },
   "source": [
    "---\n",
    "Tuplas\n",
    "\n",
    "---\n",
    "\n",
    "Las tuplas son una estructura de datos versátil y similar a las listas, pero con la distinción fundamental de ser inmutable. Una tupla es una colección ordenada e inmutable de elementos, lo que significa que una vez creada  una tubla, no se pueden redefinir elementos, agregar o eliminar elementos. Las tuplas se definen utilizando paréntesis `()`.\n",
    "* **Inmutabilidad**: Los elementos de una tupla no pueden cambiarse después de su creación, esto garantiza que los datos en una tupla permanezcan constantes.\n",
    "* **Ordenadas**: Los elementos de una tupla mantienen el orden en el que se insertaron, son estructuras de datos indexables.\n",
    "* **Heterogéneas**: Al igual que las listas, las tuplas pueden contener elementos de diferentes tipos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 164,
     "status": "ok",
     "timestamp": 1705641045627,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "ED07VsT9HsB-",
    "outputId": "a8cbae3a-6c79-4344-e8c0-52b649f12ab7"
   },
   "outputs": [],
   "source": [
    "# Ejemplos de tuplas\n",
    "tupla_1 = (1,5,4,3)\n",
    "tupla_2 = (1,2,\"Tres\",True)\n",
    "\n",
    "print(tupla_1)\n",
    "print(tupla_2)\n",
    "\n",
    "# Acceso a elementos de una tupla por indices\n",
    "print(\"elemento 0:\", tupla_1[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Lutx1RoIIPNd"
   },
   "outputs": [],
   "source": [
    "# Ejemplos de inmutabilidad\n",
    "mi_tupla = (1,2,3,4,5)\n",
    "mi_tupla[0] = 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "D7kV_84AzYIy"
   },
   "source": [
    "Los métodos más comúnes y útiles para la manipulación de tuplas son:\n",
    "* `len()`: Regresa la longitud de la tupla.\n",
    "* `count()`: Cuenta cuántas veces aparece un elemento en la tupla.\n",
    "* `index()`: Regresa el índice de un elemento especificado dentro de la tupla.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 201,
     "status": "ok",
     "timestamp": 1705971296192,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "R7Q8h1bizh6J",
    "outputId": "e8be6b9b-a209-4ca0-afec-a5cbd7b03bde"
   },
   "outputs": [],
   "source": [
    "# Función len()\n",
    "mi_tupla = (1,5,2,3,2)\n",
    "\n",
    "# mi_tupla.len() --------------> no posee atributo .len()\n",
    "\n",
    "len(mi_tupla)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 181,
     "status": "ok",
     "timestamp": 1705971373891,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "NA8i6uxkzs5r",
    "outputId": "37fe3d7b-05c7-4920-8062-ac8fba689134"
   },
   "outputs": [],
   "source": [
    "# Función .index()\n",
    "mi_tupla = (1,5,2,3,2)\n",
    "indice_elemento = mi_tupla.index(5)\n",
    "\n",
    "print(indice_elemento)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1705971590456,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "1pAzwteG0ZkL",
    "outputId": "5f7e0f6d-d1b7-44bf-f028-81428016f0ae"
   },
   "outputs": [],
   "source": [
    "# Función .count()\n",
    "mi_tupla = (1,5,2,3,2,4,3,5,5)\n",
    "cantidad_elemento = mi_tupla.count(5)\n",
    "\n",
    "print(cantidad_elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4a37VuYf1vC6"
   },
   "source": [
    "### 2.3. Conjuntos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "g21gZwVB2Gwb"
   },
   "source": [
    "---\n",
    "Conjuntos\n",
    "\n",
    "---\n",
    "\n",
    "En Python, un conjunto es una estructura de datos que representa una colección no ordenada y sin duplicados de elementos. Un conjunto se define a mediante de corchetes `{}` y permíten diferentes tipos de datos. Las características escenciales de los conjuntos son:\n",
    "\n",
    "* **No Ordenados**: Los conjuntos no mantienen un orden específico de los elementos. No puedes acceder a los elementos por su posicón o índice.\n",
    "* **No duplicados**: Cada elemento en un conjunto es único, no pueden existir duplicados en un conjunto.\n",
    "* **Mutabilidad**: A diferencia de las listas, los conjuntos son mutables, lo que significa que es posible agregar o eliminar elementos después de su creación.\n",
    "* **No indexables**: Los conjuntos no pueden retornar sus elementos a partir de indexaciónes pero si pueden ser obtenidos a partir de un ciclo de iteración. Más detalles sobre esto en la sección \"Control de Flujo\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 183,
     "status": "ok",
     "timestamp": 1705972358869,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "uC9AY1Bq3_D5",
    "outputId": "61d69572-5671-402b-e67d-001babf6376c"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de un conjunto\n",
    "mi_conjunto = {'martin', True, 2, 5.645}\n",
    "print(type(mi_conjunto))\n",
    "print(mi_conjunto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 206,
     "status": "ok",
     "timestamp": 1705972215136,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "tWIIGAeF3Dhp",
    "outputId": "671ca5f3-fa91-47df-d51b-ab672535c54e"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de no duplicidad de un conjunto\n",
    "mi_conjunto = {'martin', 'mario', 'nicolas', 'sofia', 'martin','martin'}\n",
    "print(type(mi_conjunto))\n",
    "print(mi_conjunto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2Xd23_qw3pJZ"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de no indexación en conjuntos\n",
    "mi_conjunto = {'martin', True, 2, 5.645}\n",
    "# mi_conjunto[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ltMMJlRk53K6"
   },
   "source": [
    "Los métodos más comúnes usados para la manipulación de conjuntos son:\n",
    "* `len()`: Devuelve la cantidad de elementos en elconjunto.\n",
    "* `add()`: Agrega un elemento al conjunto.\n",
    "* `remove()`: Elimina un elemento del conjunto.\n",
    "* `discard()`: Elimina un elemento si está presente, sin generar un error si no lo encuentra.\n",
    "* `clear()`: Elmina todos los elementos del conjunto.\n",
    "* `set()`: Convierte otro objeto iterable tal como una tupla o una lista en un conjunto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 186,
     "status": "ok",
     "timestamp": 1705973133973,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "RG8orKQC633p",
    "outputId": "89b81064-b992-4f4b-f5af-aa65d8d2e203"
   },
   "outputs": [],
   "source": [
    "# Función len()\n",
    "mi_conjunto = {'mexico', 'chile', 'colombia', 'colombia', 'kenia'}\n",
    "len(mi_conjunto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1705973179790,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "nBOsLlqE7FVZ",
    "outputId": "76c61413-05be-4e95-821e-8162a1cfb842"
   },
   "outputs": [],
   "source": [
    "# Función .add()\n",
    "mi_conjunto = {'mexico', 'chile', 'colombia', 'colombia', 'kenia'}\n",
    "mi_conjunto.add('argentina')\n",
    "\n",
    "print(mi_conjunto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 180,
     "status": "ok",
     "timestamp": 1705973292400,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "yLDASQtW7QXZ",
    "outputId": "921a119b-5fdd-4499-ab61-1432cc709e2b"
   },
   "outputs": [],
   "source": [
    "# Función .remove()\n",
    "mi_conjunto = {'mexico', 'chile', 'colombia', 'colombia', 'kenia'}\n",
    "mi_conjunto.remove('chile')\n",
    "\n",
    "print(mi_conjunto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SMFv-zoW8DhF"
   },
   "source": [
    "A pesar de que los métodos `remove()` y `discard()` sirven para eliminar elementos de un conjunto, a diferencia de `remove()`, `discard()` no retorna un error si el elemento a eliminar no pertenece al conjunto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 231,
     "status": "ok",
     "timestamp": 1705973386578,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "zuidXx6Y7jYJ",
    "outputId": "9e5c6d8b-d821-4c53-9e8c-b1856783ea84"
   },
   "outputs": [],
   "source": [
    "# Función .discard()\n",
    "mi_conjunto = {'mexico', 'chile', 'colombia', 'colombia', 'kenia'}\n",
    "# mi_conjunto.remove('uruguay')\n",
    "mi_conjunto.discard('uruguay')\n",
    "\n",
    "print(mi_conjunto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1705973520959,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "-4h6jnVS8aPV",
    "outputId": "98f1d553-9957-466c-a660-b651aa93b804"
   },
   "outputs": [],
   "source": [
    "# Función .clear()\n",
    "mi_conjunto = {'mexico', 'chile', 'colombia', 'colombia', 'kenia'}\n",
    "mi_conjunto.clear()\n",
    "\n",
    "print(mi_conjunto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1705973694309,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "HveR7rJn1zfe",
    "outputId": "84f756cf-1bed-49ef-a320-2b809f3b024a"
   },
   "outputs": [],
   "source": [
    "# Ejemplos de conversión de objetos iterables a conjuntos\n",
    "\n",
    "iterable_1 = 'Pepe Perez Martinez'\n",
    "iterable_2 = [1,2,3,4,5]\n",
    "iterable_3 = (10,20,30,40,50)\n",
    "\n",
    "conjunto_1 = set(iterable_1)\n",
    "conjunto_2 = set(iterable_2)\n",
    "conjunto_3 = set(iterable_3)\n",
    "\n",
    "print(conjunto_1)\n",
    "print(conjunto_2)\n",
    "print(conjunto_3)\n",
    "\n",
    "lista_1 = list(conjunto_1)\n",
    "lista_2 = list(conjunto_2)\n",
    "lista_3 = list(conjunto_3)\n",
    "\n",
    "print(lista_1)\n",
    "print(lista_2)\n",
    "print(lista_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6N-xdiof-BC6"
   },
   "source": [
    "### 2.4. Diccionarios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DQdQ3D0s-ECp"
   },
   "source": [
    "---\n",
    "Diccionarios\n",
    "\n",
    "---\n",
    "\n",
    "Los diccionarios son estructuras de datos flexibles que permiten almacenar y organizar la información de manera eficiente. Un diccionario es una estructura de datos que permite almacenar y organizar información en pares clave-valor, donde cada elemento del diccionario consiste en una clave única asociada a un valor correspondiente el cual puede ser un dato de cualquier tipo o una lista de datos. La clave es similar a un índice, pero en lugar de ser un número entero, puede ser cualquier tipo inmutable, como una cadena, número o tupla. Los valores de cada diccionario pueden ser incluso otros diccionarios. Las características escenciales de los diccionarios son:\n",
    "* **Estructura de Clave-valor**:  Los diccionarios son colecciones de pares clase-valor, donde cada clave es asociada a un valor.\n",
    "* **No Ordenados**:  Aunque a partir de Python 3.7, los diccionarios mantienen el orden de inserción, no se debe confiar en este comportamiento ya que no es una característica garantizada en los diccionarios.\n",
    "* **Claves únicas**: Cada clave en un diccionario es única, lo que significa que no puede haber duplicados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1705974344903,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "4EmpjELk_U3B",
    "outputId": "8f77b7b9-6482-4bb9-f22a-5cd89c5e5d43"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de un diccionario\n",
    "mi_diccionario = {\n",
    "    'nombre': 'Nicolas',\n",
    "    'apellido': 'Perez',\n",
    "    'edad': 27,\n",
    "    'numeros favoritos': [21,8,13,26,97]\n",
    "}\n",
    "\n",
    "print(type(mi_diccionario))\n",
    "print(mi_diccionario)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 180,
     "status": "ok",
     "timestamp": 1705974808677,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "iwZnb0G3_sRy",
    "outputId": "0c650d39-4476-4ce1-a0dc-df20a91d1d7f"
   },
   "outputs": [],
   "source": [
    "# Acceso a elementos de un diccionario\n",
    "mi_diccionario = {\n",
    "    'nombre': 'Nicolas',\n",
    "    'apellido': 'Pancracio',\n",
    "    'edad': 27,\n",
    "    'numeros favoritos': [21,8,13,26,97]\n",
    "}\n",
    "\n",
    "elemento_1 = mi_diccionario['numeros favoritos']\n",
    "elemento_2 = mi_diccionario['nombre']\n",
    "elemento_3 = mi_diccionario['apellido']\n",
    "\n",
    "print(elemento_1)\n",
    "print(elemento_2)\n",
    "print(elemento_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1705974704338,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "nrcQBN9wAKWC",
    "outputId": "d3f845ad-383c-4566-93dc-32dda59f49fc"
   },
   "outputs": [],
   "source": [
    "# Actualización simple de elementos de un diccionario\n",
    "mi_diccionario = {\n",
    "    'nombre': 'Nicolas',\n",
    "    'apellido': 'Pancracio',\n",
    "    'edad': 27,\n",
    "    'numeros favoritos': [21,8,13,26,97]\n",
    "}\n",
    "\n",
    "mi_diccionario['numeros favoritos'] = [13,21,7,46,86]\n",
    "mi_diccionario['edad'] -= 3\n",
    "\n",
    "# Actualización de elementos de un diccionario y uso de métodos propios del valor\n",
    "mi_diccionario['numeros favoritos'].append('Un numerito')\n",
    "mi_diccionario['numeros favoritos'].append('Otro numerito')\n",
    "mi_diccionario['numeros favoritos'].pop(-1)\n",
    "\n",
    "\n",
    "elemento_1 = mi_diccionario['numeros favoritos']\n",
    "elemento_2 = mi_diccionario['nombre']\n",
    "elemento_3 = mi_diccionario['apellido']\n",
    "\n",
    "print(elemento_1)\n",
    "print(elemento_2)\n",
    "print(elemento_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 170,
     "status": "ok",
     "timestamp": 1705974783845,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "kxwuAZjUBJsb",
    "outputId": "44cd7143-2ffc-4575-da05-8c3c437c33f8"
   },
   "outputs": [],
   "source": [
    "# Adición de elementos a un diccionario\n",
    "mi_diccionario = {\n",
    "    'nombre': 'Nicolas',\n",
    "    'apellido': 'Pancracio',\n",
    "    'edad': 27,\n",
    "    'numeros favoritos': [21,8,13,26,97]\n",
    "}\n",
    "\n",
    "mi_diccionario['deporte favorito'] = 'Quidditch'\n",
    "\n",
    "print(mi_diccionario)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gChU0T-wBmy0"
   },
   "source": [
    "Los métodos más comúnes para la manipulación de diccionarios son:\n",
    "* `len()`: Devuelve el número de pares clave-valor presentes en el diccionario.\n",
    "* `keys()`: Devuelve una vista de todas las claves presentes en el diccionario.\n",
    "* `values()`: Devuelve una vista de todos los valores en el diccionario.\n",
    "* `items()`: Devuelve una vista de todos los pares clave-valor en el diccionario.\n",
    "* `get()`: El método get() se utiliza para obtener el valor asociado a una clave. Si la clave no está presente, devuelve un valor predeterminado (o None si no se proporciona ningún valor predeterminado).\n",
    "* `del`: Elimina un elemento por clave indicada.\n",
    "* `pop()`:El método pop() se utiliza para eliminar y devolver el valor asociado a una clave. Si la clave no está presente, se puede proporcionar un valor predeterminado.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 189,
     "status": "ok",
     "timestamp": 1705975261603,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "GuG2yg4-DEEC",
    "outputId": "d1b4c9f9-2d7f-42c4-e9d9-65f394482b0a"
   },
   "outputs": [],
   "source": [
    "# Función len()\n",
    "mi_diccionario = {\n",
    "    'nombre': 'Nicolas',\n",
    "    'apellido': 'Pancracio',\n",
    "    'edad': 27,\n",
    "    'numeros favoritos': [21,8,13,26,97]\n",
    "}\n",
    "\n",
    "print(len(mi_diccionario))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1705975337020,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "sEsou0oXDL4S",
    "outputId": "881d1f9f-df6d-4708-9761-98cc3c475910"
   },
   "outputs": [],
   "source": [
    "# Función .keys()\n",
    "mi_diccionario = {\n",
    "    'nombre': 'Nicolas',\n",
    "    'apellido': 'Pancracio',\n",
    "    'edad': 27,\n",
    "    'numeros favoritos': [21,8,13,26,97]\n",
    "}\n",
    "\n",
    "llaves = mi_diccionario.keys()\n",
    "\n",
    "print(type(llaves))\n",
    "print(llaves)\n",
    "print(list(llaves))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1705975384298,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "mOy2QS3vDMga",
    "outputId": "3c8fbffa-96ce-4235-c629-7efb89fc0ed0"
   },
   "outputs": [],
   "source": [
    "# Función .values()\n",
    "mi_diccionario = {\n",
    "    'nombre': 'Nicolas',\n",
    "    'apellido': 'Pancracio',\n",
    "    'edad': 27,\n",
    "    'numeros favoritos': [21,8,13,26,97]\n",
    "}\n",
    "\n",
    "valores = mi_diccionario.values()\n",
    "\n",
    "print(type(valores))\n",
    "print(valores)\n",
    "print(list(valores))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1705975476547,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "ozBF8Y38DM-p",
    "outputId": "7646ea16-edbb-4bac-f7f9-f259ae282d22"
   },
   "outputs": [],
   "source": [
    "# Función .items()\n",
    "mi_diccionario = {\n",
    "    'nombre': 'Nicolas',\n",
    "    'apellido': 'Pancracio',\n",
    "    'edad': 27,\n",
    "    'numeros favoritos': [21,8,13,26,97]\n",
    "}\n",
    "\n",
    "items = mi_diccionario.items()\n",
    "\n",
    "print(type(items))\n",
    "print(items)\n",
    "print(list(items))\n",
    "print(type(list(items)[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1705975602157,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "fOHmUogLEEMJ",
    "outputId": "3b235f0b-055b-43be-ff17-6f89b0136abb"
   },
   "outputs": [],
   "source": [
    "# Función .get()\n",
    "mi_diccionario = {\n",
    "    'nombre': 'Nicolas',\n",
    "    'apellido': 'Pancracio',\n",
    "    'edad': 27,\n",
    "    'numeros favoritos': [21,8,13,26,97]\n",
    "}\n",
    "\n",
    "nombre = mi_diccionario.get('nombre','no existe tu campo')\n",
    "segundo_nombre = mi_diccionario.get('segundo_nombre','no existe tu campo')\n",
    "carrera = mi_diccionario.get('carrera')\n",
    "\n",
    "print(nombre)\n",
    "print(segundo_nombre)\n",
    "print(carrera)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1705975682713,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "qE_Z7XOrEg85",
    "outputId": "aff8f9a6-b700-4604-ff24-fae792512221"
   },
   "outputs": [],
   "source": [
    "# Función .pop()\n",
    "mi_diccionario = {\n",
    "    'nombre': 'Nicolas',\n",
    "    'apellido': 'Pancracio',\n",
    "    'edad': 27,\n",
    "    'numeros favoritos': [21,8,13,26,97]\n",
    "}\n",
    "\n",
    "fue_mi_nombre = mi_diccionario.pop('nombre')\n",
    "\n",
    "print('¿Cuál fué mi nombre? = ', fue_mi_nombre)\n",
    "print(mi_diccionario)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1705975727454,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "Z9kdSpr0E1qS",
    "outputId": "78838939-7452-4dcb-d62b-f9608841f42a"
   },
   "outputs": [],
   "source": [
    "# Función del\n",
    "mi_diccionario = {\n",
    "    'nombre': 'Nicolas',\n",
    "    'apellido': 'Pancracio',\n",
    "    'edad': 27,\n",
    "    'numeros favoritos': [21,8,13,26,97]\n",
    "}\n",
    "\n",
    "del mi_diccionario['apellido']\n",
    "\n",
    "print(mi_diccionario)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5GTp49_IGD15"
   },
   "source": [
    "### 2.5. Rangos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uB7CSiEqGIcw"
   },
   "source": [
    "---\n",
    "Rangos\n",
    "\n",
    "---\n",
    "\n",
    "En Python, un rango (range) es una estructura de datos que representa una secuencia inmutable de números. La principal característica de los rangos es su capacidad para representar secuencias de números de manera eficiente, sin almacenar todos los elementos en la memoria. Los rangos son especialmente útiles cuando necesitas trabajar con secuencias numéricas extensas, ya que generan los valores sobre la marcha en lugar de almacenarlos todos de antemano.\n",
    "\n",
    "La sintaxis básica para crear un rango es mediante la función `range(start, end, step)`, que toma uno, dos o tres argumentos. Los argumentos especifican el inicio, el fin (exclusivo) y el paso de la secuencia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 200,
     "status": "ok",
     "timestamp": 1705976277357,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "jW1fAoQrGZh8",
    "outputId": "97f8d969-36ae-48e9-c720-e0ac1139e655"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de un rango\n",
    "mi_rango = range(2, 20, 2)\n",
    "mi_rango_lista = list(mi_rango)\n",
    "\n",
    "print(type(mi_rango))\n",
    "print(mi_rango)\n",
    "print('Su rango en forma de lista es = ', mi_rango_lista )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wfxkZ2y5rNz6"
   },
   "source": [
    "# **3. Control de flujo**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "th9UI0EnIzxp"
   },
   "source": [
    "### 3.1. Condicionales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RyIS1hsxI3kI"
   },
   "source": [
    "---\n",
    "Condiconales\n",
    "\n",
    "---\n",
    "\n",
    "En programación, los condicionales son reguladores de flujo que nos permiten tomar diferentes caminos en la ejecución de un programa. Los condicionales hacen uso de operaciónes lógicas para dar permitir o impedir la ejecución de bloques de código, es decir, los condicionales son la manera de tomar decisiones. Python ofrece los condicionales `if`, `elif` (else if) y `else` para manejar situaciones basadas en lógica booleana."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "X6ZJIdGlJt-B"
   },
   "source": [
    "La indentación en Python se refiere a la sangría o espaciado que se utiliza para estructurar el código. A diferencia de muchos otros lenguajes de programación que utilizan llaves `{}` o palabras clave para definir bloques de código, Python utiliza la indentación como parte integral de su sintaxis. La indentación se realiza mediante espacios o tabulaciones al principio de las líneas de código y determina la jerarquía y la estructura del programa.\n",
    "\n",
    "La importancia de la indentación en Python radica en que se utiliza para delimitar bloques de código, como en las declaraciones `if`, `else`, `for`, `while`, funciones, clases y otros bloques estructurales. La indentación es un componente esencial de la legibilidad del código en Python y juega un papel fundamental en la determinación de qué líneas de código pertenecen a un bloque específico."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FdBCdkH9KSqI"
   },
   "source": [
    "La sintaxis de un condicional `if` básica es la siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jqRrdo_aJxqN"
   },
   "outputs": [],
   "source": [
    "# Sintaxis correcta\n",
    "\n",
    "if condicion:\n",
    "    # Código si la condición es verdadera\n",
    "\n",
    "# Sintaxis incorrecta\n",
    "\n",
    "if condicion:\n",
    "# Código si la condición es verdadera"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "44phbE48KksF"
   },
   "source": [
    "Un ejemplo de la incorporación de la lógica booleana en un condicional simple es el siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1705977201030,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "wSE6A7gnI2go",
    "outputId": "015d05ac-12b2-45c4-8d3f-2172733593ca"
   },
   "outputs": [],
   "source": [
    "edad = 20\n",
    "\n",
    "if edad >= 18:\n",
    "    print(\"Eres mayor de edad.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6OcEdXTUKzYh"
   },
   "source": [
    "Por otra parte, los condicionales tipo `if` - `else` permíten evaluar una condición de manera tal que en caso de no ser verdadera, un bloque de código será omitido mientras que otro bloque será ejecutado.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yxNNSRKpLYSD"
   },
   "source": [
    "La estructura básica de este tipo de condicionales es:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4nzlBqczK3bz"
   },
   "outputs": [],
   "source": [
    "if condicion:\n",
    "    # Código si la condición es verdadera\n",
    "else:\n",
    "    # Código si la condición no es verdadera"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 353,
     "status": "ok",
     "timestamp": 1705977446905,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "CDBlNqdHLcch",
    "outputId": "8801b3cb-03c5-4413-f33c-15d1ada0f98d"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de condicional tipo if-else\n",
    "numero = 17\n",
    "\n",
    "if numero % 2 == 0:\n",
    "    print(\"El número es par.\")\n",
    "else:\n",
    "    print(\"El número es impar.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W1hPvye0LjaA"
   },
   "source": [
    "En caso de que más de una condición necesite ser evaluada, sdebe implementar los condicionales tipo `if`- `elif` - `else` cuya sintaxis básica es la siguiente:\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mZ1BBJkjMHYh"
   },
   "outputs": [],
   "source": [
    "if condicion1:\n",
    "    # Código si la condicion1 es verdadera\n",
    "elif condicion2:\n",
    "    # Código si la condicion2 es verdadera\n",
    "else:\n",
    "    # Código si ninguna condición anterior es verdadera"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 212,
     "status": "ok",
     "timestamp": 1705977667140,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "x4shRpf8MQIj",
    "outputId": "90f703fe-f048-4d75-9d39-0120b1184bd1"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de condicional tipo if-elif-else\n",
    "\n",
    "puntuacion = 85\n",
    "\n",
    "if puntuacion >= 90:\n",
    "    print(\"Excelente\")\n",
    "elif puntuacion >= 70:\n",
    "    print(\"Buen trabajo\")\n",
    "else:\n",
    "    print(\"Necesitas mejorar\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uHDmvw4TMjy9"
   },
   "source": [
    "La ***anidación de condicionales*** se refiere a la práctica de colocar una estructura condicional dentro de otra, lo que permite evaluar condiciones de manera más detallada y jerárquica. Esto significa que dentro de un bloque condicional (como un `if`, `elif`, o `else`), se puede colocar otro bloque condicional. La anidación es útil cuando se requiere evaluar condiciones más específicas dentro de un contexto más amplio."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ouk4BE7oM7mV"
   },
   "source": [
    "Un ejemplo de anidación es el caso en donde se quiere clasificar la temperatura en tres niveles: \"frío\", \"templado\" y \"caliente\". Además, queremos agregar una categoría adicional para cuando la temperatura es \"extremadamente caliente\". Podemos utilizar la anidación de condicionales para lograr esto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1705978303776,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "dQD37mK1OYQh",
    "outputId": "69bd26d5-73c3-405f-b64b-7400d90624e8"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de clasificación de número en un rango\n",
    "numero = 16\n",
    "\n",
    "# Condicional externo\n",
    "if numero >= 0:\n",
    "\n",
    "    # Condicional interno\n",
    "    if numero == 0:\n",
    "      print('Su número es 0')\n",
    "\n",
    "    else:\n",
    "        print('Su número es positivo')\n",
    "\n",
    "else:\n",
    "    print('Su número es negativo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1705977916666,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "lSXU0zaMNB9U",
    "outputId": "8ba7c4d6-6791-47a4-90b2-dc5907dcc6cf"
   },
   "outputs": [],
   "source": [
    "# Clasificación de temperatura\n",
    "temperatura = 45\n",
    "\n",
    "if temperatura < 0:\n",
    "    print(\"Hace mucho frío.\")\n",
    "elif 0 <= temperatura < 20:\n",
    "    print(\"Está frío.\")\n",
    "elif 20 <= temperatura < 30:\n",
    "    print(\"Está templado.\")\n",
    "else:\n",
    "    print(\"Está caliente.\")\n",
    "    if temperatura > 40:\n",
    "        print(\"¡Es extremadamente caliente!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "stBqy1o1Nbts"
   },
   "source": [
    "Note que en el ejemplo anterior se ha hecho uso de diferentes operadores lógicos, lo que quiere decir que los condicionales solo tendrán en cuenta como criterio de validación la respuesta booleana producto de un operador lógico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 196,
     "status": "ok",
     "timestamp": 1705978040446,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "hEhL1DIINpQy",
    "outputId": "a5e44e30-b19d-43bf-ef49-a277c68f145b"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de condicionales y operador lógico 'and'\n",
    "\n",
    "edad = 25\n",
    "ingresos_mensuales = 3000\n",
    "\n",
    "if edad >= 18 and ingresos_mensuales > 2000:\n",
    "    print(\"Eres elegible para el préstamo.\")\n",
    "else:\n",
    "    print(\"No cumples con los requisitos para el préstamo.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 188,
     "status": "ok",
     "timestamp": 1705978081225,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "IZEKtaLCN1Eb",
    "outputId": "2adec166-1915-4e9f-d94f-87be5e84da1c"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de condicionales y operador lógico 'or'\n",
    "\n",
    "horas_estudio_diarias = 2\n",
    "dias_estudio_semana = 5\n",
    "\n",
    "if horas_estudio_diarias >= 3 or dias_estudio_semana >= 6:\n",
    "    print(\"Estás dedicando suficiente tiempo al estudio.\")\n",
    "else:\n",
    "    print(\"Deberías considerar aumentar el tiempo de estudio.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1705978108628,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "G9IEpTTsN-1B",
    "outputId": "566f0ff3-0747-4f77-9a43-3fbf4a3da4c2"
   },
   "outputs": [],
   "source": [
    "# Ejemplo de condicionales y operador lógico 'not'\n",
    "tiene_descuento = False\n",
    "\n",
    "if not tiene_descuento:\n",
    "    print(\"No tienes descuento aplicado.\")\n",
    "else:\n",
    "    print(\"Tienes un descuento aplicado.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_ZYrL6apNox5"
   },
   "source": [
    "### 3.2. Ciclo For"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0Mq1fdb-Vb2Y"
   },
   "source": [
    "---\n",
    "Ciclo For\n",
    "\n",
    "---\n",
    "\n",
    "Los ciclos \"for\" en Python son herramientas fundamentales para la iteración sobre secuencias de datos. Estos proporcionan una forma eficiente de realizar tareas repetitivas, permitiendo automatizar procesos y facilitar la manipulación de datos. En esta lección, exploraremos la sintaxis y el funcionamiento de los ciclos \"for\" en Python y veremos un caso práctico en el ámbito del procesamiento de datos y machine learning."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Mblj84k3V8FL"
   },
   "source": [
    "La sintaxis básica de un ciclo `for()` es la siguiente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Q5d2AJbnPGVZ"
   },
   "outputs": [],
   "source": [
    "# Sintaxis básica de un for()\n",
    "\n",
    "for variable in secuencia:\n",
    "  # Código a ejecutar en cada iteración"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "S1i3A8ajWWKr"
   },
   "source": [
    "Considerando esta sintaxis de iteración recordemos las estructuras de datos, las cuales se definen como entidades iterables o que pueden ser recorridos por un iterador."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 200,
     "status": "ok",
     "timestamp": 1706064499120,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "jC-IZpjPWyie",
    "outputId": "27cd840a-45ac-4299-f8e7-7697b05638be"
   },
   "outputs": [],
   "source": [
    "# iteración de un String\n",
    "mi_cadena = \"UnString\"\n",
    "\n",
    "for letra in mi_cadena:\n",
    "  print(letra)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 222,
     "status": "ok",
     "timestamp": 1706064633050,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "C7kjI0QwXwoV",
    "outputId": "f517bea5-f0ae-4de5-cbbc-2c8b1b10f761"
   },
   "outputs": [],
   "source": [
    "# iteración de una lista\n",
    "mi_lista = ['Martin', 'Claudio', 'Astrid']\n",
    "for nombre in mi_lista:\n",
    "  print(nombre)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1706064820751,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "Uj6rLYIEYHcU",
    "outputId": "b9452430-e58d-4543-ee1e-e313330e79b1"
   },
   "outputs": [],
   "source": [
    "# iteración con un diccionario\n",
    "mi_dic = {\n",
    "    'key1':12,'key2':71,'key3':62\n",
    "}\n",
    "for asociacion in mi_dic.values():\n",
    "  print(asociacion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 219,
     "status": "ok",
     "timestamp": 1706064838483,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "6Ar0yFZ8Y3eE",
    "outputId": "43b6281b-7066-46ab-e07f-f9b11fe40c4a"
   },
   "outputs": [],
   "source": [
    "# iteración con un diccionario con doble iterador\n",
    "mi_diccionario = {\"a\": 1, \"b\": 2, \"c\": 3}\n",
    "\n",
    "for clave, valor in mi_diccionario.items():\n",
    "    print(f\"Clave: {clave}, Valor: {valor}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EY1kLsqnWUnb"
   },
   "source": [
    "Los iteradores`for()` pueden identificar cuando un elemento iterable se encuentra disponible, pero son tambíen muy bien empleados con base al uso de rangos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 196,
     "status": "ok",
     "timestamp": 1706065021230,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "F01-ZsxFZT1r",
    "outputId": "b835d7aa-9998-4b6a-aeed-0f1a2b623cdd"
   },
   "outputs": [],
   "source": [
    "# for() y su uso con rangos\n",
    "for indice in range(3):\n",
    "  print('índice: ',indice)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tvp8Y-Q0ZnZS"
   },
   "source": [
    "Un ciclo `for()` al igual que otros controladores de flujo, permiten abarcar dentro de sí un bloque decódigo que será ejecutado deacuerdo a las políticas de sintaxis de la estructura de control. Al ser tan flexibles, permíten la incorporación de otros reguladores de flujo dentro de sí."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rotQ9XOGjvAs"
   },
   "source": [
    "#### Cíclos con condicionales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 250,
     "status": "ok",
     "timestamp": 1706065465870,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "rjVqMnibaM_k",
    "outputId": "d719cb83-56cf-4c46-a629-621e02995dc0"
   },
   "outputs": [],
   "source": [
    "# Iteración con condición\n",
    "numeros = [1, 2, 3, 4, 5]\n",
    "\n",
    "for numero in numeros:\n",
    "  if numero % 2 == 0:\n",
    "    print('Número par: ', numero)\n",
    "  else:\n",
    "    print('Número impar: ', numero)\n",
    "\n",
    "\n",
    "print('*'*20)\n",
    "\n",
    "\n",
    "for i in range(len(numeros) ):\n",
    "\n",
    "  numero = numeros[i]\n",
    "\n",
    "  if numero % 2 == 0:\n",
    "    print('Número par: ', numero)\n",
    "  else:\n",
    "    print('Número impar: ', numero)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1706066238383,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "Upytd6BecTfL",
    "outputId": "9e846b63-c3fa-49e2-b4f9-c2f4d555c1b2"
   },
   "outputs": [],
   "source": [
    "# Diccionario del número de palabras que hacen a una frase\n",
    "frases = [\"Los ciclos ayudan a construir estructuras\", \"Los ciclos ayudan a repetir procesos\", \"Los ciclos for facilitan el procesamiento de datos\"]\n",
    "longitudes_palabras = []\n",
    "\n",
    "# Calcular y almacenar la cantidad de palabras en cada frase\n",
    "for frase in frases:\n",
    "    # Dividir la frase en palabras\n",
    "    palabras = frase.split()\n",
    "\n",
    "    # Calcular la cantidad de palabras y agregar a la lista de características\n",
    "    cantidad_palabras = len(palabras)\n",
    "    longitudes_palabras.append(cantidad_palabras)\n",
    "\n",
    "# Construcción de un diccionario de palabras\n",
    "mis_palabras = {'Frase':'Número de palabras'}\n",
    "for i, frase in enumerate(frases):\n",
    "  mis_palabras[frase] = longitudes_palabras[i]\n",
    "\n",
    "mis_palabras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1706066730262,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "5yTuI1-ufeEb",
    "outputId": "fc68c4fb-de2a-4ff9-b8cf-026e3634fe31"
   },
   "outputs": [],
   "source": [
    "# Ciclo for() para la iteracción de una accion\n",
    "resultado = []\n",
    "cantidad_de_elementos = 4\n",
    "\n",
    "for _ in range(3):\n",
    "  fila = [0] * cantidad_de_elementos\n",
    "  resultado.append(fila)\n",
    "\n",
    "print(resultado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Dpnub-Xlj7ds"
   },
   "source": [
    "#### Cíclos anidados con condicionales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-seIhfnDgkOa"
   },
   "source": [
    "***Multiplicación de matrices***\n",
    "Para generar un multiplicador de matrices, revisaremos los conceptos aprendidos hasta este punto, desde manejo de estructuras, condicionales e iteradores\n",
    "`for()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1706067602190,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "jBUQv2uHeaxU",
    "outputId": "5e7b44e1-02a0-49f1-ceed-94eb9b162e19"
   },
   "outputs": [],
   "source": [
    "# Definir una matriz\n",
    "matriz_a = [\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9]\n",
    "]\n",
    "\n",
    "matriz_b = [\n",
    "    [1, 2, 1],\n",
    "    [13, 0, 16],\n",
    "    [4, 8, 23]\n",
    "]\n",
    "\n",
    "# Parámetros del ciclo\n",
    "filas_a, columnas_a = len(matriz_a), len(matriz_a[0])\n",
    "filas_b, columnas_b = len(matriz_b), len(matriz_b[0])\n",
    "\n",
    "# Multiplicador de matrices\n",
    "for i in range(filas_a):\n",
    "  for j in range(columnas_b):\n",
    "\n",
    "    if filas_a != columnas_b:\n",
    "      print('El número de filas debe ser igual al numero de columnas, las dimensiones de sus matrices no son compatibles')\n",
    "    else:\n",
    "\n",
    "      resultado = []\n",
    "      # Inicialización de una matriz de ceros\n",
    "      for _ in range(filas_a):\n",
    "        fila = [0] * columnas_b\n",
    "        resultado.append(fila)\n",
    "\n",
    "      # Multiplicación de elementos\n",
    "      for i in range(filas_a):\n",
    "        for j in range(columnas_b):\n",
    "          for k in range(columnas_a):\n",
    "\n",
    "            resultado[i][j] += matriz_a[i][k] * matriz_b[j][k] # k es el iterador que permite coincidir elemento a elemento\n",
    "\n",
    "print(type(resultado))\n",
    "print(resultado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dJ23b8nUj_Ns"
   },
   "source": [
    "#### Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oFEkb7oFkYHj"
   },
   "source": [
    "En Python, las comprehensions o comprensiones son construcciones sintácticas que permiten la creación concisa y eficiente de listas, conjuntos y diccionarios mediante la aplicación de expresiones a elementos de iterables, filtrado condicional y la inclusión de estructuras de control en una única línea de código. Las comprensiones facilitan la escritura de código más legible, expresivo y eficiente, al tiempo que mantienen la flexibilidad y claridad del lenguaje Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "h1vxwQSDm8hs"
   },
   "source": [
    "* Comprensión de listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8PN1QmGpkv5H"
   },
   "outputs": [],
   "source": [
    "# Sintaxis básica de una comprehension de listas\n",
    "\n",
    "lista = [ expresion for elemento in iterable ]\n",
    "\n",
    "lista = []\n",
    "for elemento in iterable:\n",
    "  lista.append(expresion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1706068288025,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "aX1d5prilARc",
    "outputId": "a0476163-b4ed-4e36-e4e2-b6030d2c6ecf"
   },
   "outputs": [],
   "source": [
    "# Comprensión de listas\n",
    "\n",
    "numeros = [1, 3, 4, 2, 7, 1]\n",
    "cuadrados_comp = [ elemento**2 for elemento in numeros ]\n",
    "\n",
    "cuadrados_classic = []\n",
    "for elemento in numeros:\n",
    "  cuadrados_classic.append(elemento**2)\n",
    "\n",
    "print(cuadrados_comp == cuadrados_classic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TzREamLCm_M-"
   },
   "source": [
    "* Comprensión de diccionarios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xet_WPnfnCND"
   },
   "outputs": [],
   "source": [
    "# Sintaxis básica de comprension de diccionarios\n",
    "\n",
    "diccionario = { llave:valor for llave, valor in pares_llave_valor }\n",
    "\n",
    "diccionario = {}\n",
    "for llave, valor in pares_llave_valor:\n",
    "   diccionario[ llave ] = valor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 205,
     "status": "ok",
     "timestamp": 1706068735403,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "w8HuPaxgnVs8",
    "outputId": "345ba3b1-853a-42d4-dff7-43b329f8d828"
   },
   "outputs": [],
   "source": [
    "# Comprensión de diccionario para crear un diccionario de cuadrados\n",
    "nombres = ['Alice', 'Bob', 'Charlie']\n",
    "\n",
    "cuadrados_nombres = {nombre: len(nombre) for nombre in nombres}\n",
    "\n",
    "print(cuadrados_nombres)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1706068747311,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "FouUjMyrnaYr",
    "outputId": "99494cfc-7ed3-4944-ff5e-124e2135a763"
   },
   "outputs": [],
   "source": [
    "# Comprensión de diccionario para crear un diccionario de cuadrados\n",
    "nombres = ['Alice', 'Bob', 'Charlie']\n",
    "edades = [27 , 34, 24]\n",
    "\n",
    "id = {nombre: edad for nombre, edad in zip(nombres, edades)}\n",
    "\n",
    "print(id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rVmeejZknzDs"
   },
   "source": [
    "* \"Comprensión\"  de tuplas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1706068351079,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "pmxNYd-PmRFc",
    "outputId": "6bb0c219-9304-4ad6-d73c-95c30c20d4cb"
   },
   "outputs": [],
   "source": [
    "# Comprensión de lista que genera una tupla\n",
    "mi_tupla = tuple(x**2 for x in range(5))\n",
    "\n",
    "print(mi_tupla)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "N3p_9_jPnzAt"
   },
   "source": [
    "* \"Comprensión\" de conjuntos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 217,
     "status": "ok",
     "timestamp": 1706068445482,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "jW4R1LXdmZdr",
    "outputId": "d111a0b1-a7d0-48aa-8237-8f53dddbc9ea"
   },
   "outputs": [],
   "source": [
    "# Comprensión de lista que genera una set\n",
    "numeros = [1,4,2,3,1,1,3,1,2]\n",
    "mi_dict = {x**2 for x in numeros}\n",
    "\n",
    "print(mi_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ohTitfUboB8F"
   },
   "source": [
    "#### Comprehensions con condicionales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oenxa4n1o7Y1"
   },
   "source": [
    "* Comprensiones condicionadas de listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "EoRUROnqoBNv"
   },
   "outputs": [],
   "source": [
    "# Sintaxis básica de comprensión con condicional\n",
    "lista = [ expresion for elemento in iterable if condicion ]\n",
    "\n",
    "lista = []\n",
    "for elemento in interable:\n",
    "  if condicion:\n",
    "    lista.append(expresion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1706069019771,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "7nbPYT7Zoggn",
    "outputId": "17722db7-b590-4bf5-e407-0f079bf3ef3e"
   },
   "outputs": [],
   "source": [
    "# Ejemplo: Crear una lista de cuadrados solo para números pares\n",
    "numeros = [1, 2, 3, 4, 5, 6]\n",
    "cuadrados_pares = [x**2 for x in numeros if x % 2 == 0]\n",
    "\n",
    "cuadrados_pares_classic = []\n",
    "for x in numeros:\n",
    "  if x % 2 == 0:\n",
    "    cuadrados_pares_classic.append(x**2)\n",
    "\n",
    "print(cuadrados_pares)\n",
    "print(cuadrados_pares_classic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "w0glAPw2o7Vr"
   },
   "source": [
    "* Comprension condicionada de diccionarios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NbQRC2kzpiZb"
   },
   "outputs": [],
   "source": [
    "# Sintaxis básica de comprension condicionada de diccionarios\n",
    "\n",
    "diccionario = { llave:valor for llave, valor in pares_llave_valor if condicion}\n",
    "\n",
    "diccionario = {}\n",
    "for llave, valor in pares_llave_valor:\n",
    "  if condicion:\n",
    "    diccionario[ llave ] = valor\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 352,
     "status": "ok",
     "timestamp": 1706069471534,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "xtqmxXBgpE-b",
    "outputId": "6e13b2c5-bf57-4559-c6aa-456d477ddd73"
   },
   "outputs": [],
   "source": [
    "# Ejemplo: Crear un diccionario de cuadrados solo para números mayores que 2\n",
    "numeros = {'a': 1, 'b': 2, 'c': 3, 'd': 4}\n",
    "cuadrados_mayores_que_dos = {llave: valor**2 for llave, valor in numeros.items() if valor > 2 and llave !='c'}\n",
    "\n",
    "cuadrados_mayores_que_dos_classic = {}\n",
    "for llave, valor in numeros.items():\n",
    "  if valor > 2 and llave !='c':\n",
    "    cuadrados_mayores_que_dos_classic[ llave ] = valor**2\n",
    "\n",
    "print(cuadrados_mayores_que_dos)\n",
    "print(cuadrados_mayores_que_dos_classic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ONhAHs3_msmj"
   },
   "outputs": [],
   "source": [
    "# Comprensión de diccionarios\n",
    "transacciones = [\n",
    "    {'cliente': 'Alice', 'monto': 100},\n",
    "    {'cliente': 'Bob', 'monto': 150},\n",
    "    {'cliente': 'Alice', 'monto': 200},\n",
    "    # ... más transacciones ...\n",
    "]\n",
    "\n",
    "gastos_por_cliente = {cliente: sum(trans['monto'] for trans in transacciones if trans['cliente'] == cliente) for cliente in set(trans['cliente'] for trans in transacciones)}\n",
    "\n",
    "print(gastos_por_cliente)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GgK0NCwDpKJr"
   },
   "source": [
    "* Comprension condicionada de conjuntos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 209,
     "status": "ok",
     "timestamp": 1706069545817,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "HY_Z0ZbVqxdO",
    "outputId": "e71a18e0-731c-454c-b9df-fd834b755f96"
   },
   "outputs": [],
   "source": [
    "# Comprensión de lista que genera una set\n",
    "numeros = [1,4,2,3,1,1,3,1,2]\n",
    "mi_dict = {x**2 for x in numeros if x != 2}\n",
    "\n",
    "print(mi_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7_jeIaQuO5rS"
   },
   "source": [
    "### 3.3. Ciclo While"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "T3-B-KMxsEpz"
   },
   "source": [
    "---\n",
    "Ciclo While\n",
    "\n",
    "---\n",
    "\n",
    "Los ciclos `while()` en Python proporcionan una estructura de control que permite repetir un bloque de código mientras una condición sea verdadera. A diferencia de los ciclos for, los ciclos while no están limitados por un rango específico y pueden ejecutarse indefinidamente hasta que la condición se vuelva falsa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "g0tAjpJer-Wf"
   },
   "source": [
    "La sintaxis básica de un ciclo `while()` es la siguiente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uNdz89qer7n7"
   },
   "outputs": [],
   "source": [
    "# Sintaxis básica de un while()\n",
    "\n",
    "while condicion\n",
    "  # Código a ejecutar en cada iteración"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 217,
     "status": "ok",
     "timestamp": 1706069925569,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "XiMLdSoFPFyJ",
    "outputId": "47fc3d0c-938e-462f-c4ab-712d02fcac47"
   },
   "outputs": [],
   "source": [
    "# Contador simple con un ciclo while\n",
    "contador = 0\n",
    "while contador < 5:\n",
    "    print(contador)\n",
    "    contador += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4135,
     "status": "ok",
     "timestamp": 1706069942577,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "xZQ_E6SOsUI7",
    "outputId": "d9323fa9-1435-4de2-f9e4-25d55a0ad464"
   },
   "outputs": [],
   "source": [
    "# Validación de entrada con un ciclo while\n",
    "numero = 0\n",
    "while numero <= 0:\n",
    "    numero = int(input(\"Ingrese un número positivo: \"))\n",
    "print(f\"Ha ingresado el número {numero}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 198,
     "status": "ok",
     "timestamp": 1706070334889,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "2DN2Q55rslNj",
    "outputId": "e6a273b0-9b05-4cf1-9917-8f3261615bda"
   },
   "outputs": [],
   "source": [
    "# Generación de la secuencia de Fibonacci\n",
    "a, b = 0, 1\n",
    "limite = 10\n",
    "secuencia = [a,b]\n",
    "\n",
    "while a < limite:\n",
    "  a, b = b, a + b\n",
    "  secuencia.append(b)\n",
    "\n",
    "secuencia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LCwTqglUumnn"
   },
   "source": [
    "#### Ciclos while condicionados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1706070630686,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "AXUlLfPxuZ7i",
    "outputId": "25bc8a7c-8188-4891-aab9-0cbeea3059e4"
   },
   "outputs": [],
   "source": [
    "# Variables del juego\n",
    "nivel_actual = 1\n",
    "nivel_final = 4\n",
    "nivel_completado = True\n",
    "\n",
    "# Iteración hasta el último nivel\n",
    "while nivel_actual  <= nivel_final:\n",
    "    if nivel_completado:\n",
    "        print(f'Bienvenido al nivel {nivel_actual }')\n",
    "        nivel_actual  += 1\n",
    "\n",
    "print('Game Over!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 213,
     "status": "ok",
     "timestamp": 1706070656518,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "sXtAC6CkvCEk",
    "outputId": "13dc5edb-de0d-491f-e01d-5e2716c3bd2a"
   },
   "outputs": [],
   "source": [
    "# Juego de dados con un ciclo while y condicional\n",
    "import random\n",
    "\n",
    "puntuacion_objetivo = 20\n",
    "puntuacion_jugador = 0\n",
    "\n",
    "while puntuacion_jugador < puntuacion_objetivo:\n",
    "    lanzamiento = random.randint(1, 6)\n",
    "    print(f\"Has lanzado un {lanzamiento}\")\n",
    "\n",
    "    if lanzamiento == 1:\n",
    "        print(\"¡Perdiste! Sacaste un 1.\")\n",
    "        break  # El juego termina si se saca un 1\n",
    "    else:\n",
    "        puntuacion_jugador += lanzamiento\n",
    "        print(f\"Puntuación actual: {puntuacion_jugador}\")\n",
    "\n",
    "print(\"¡Ganaste!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 286,
     "status": "ok",
     "timestamp": 1706070795654,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "HbVsMmKEvIBE",
    "outputId": "90d68be5-14f5-454b-a07b-d1cf1cf899d0"
   },
   "outputs": [],
   "source": [
    "# Aproximación de Pi mediante una serie con un ciclo while condicioando\n",
    "pi = 0\n",
    "termino_actual = 1\n",
    "signo = 1\n",
    "\n",
    "while abs(4 / termino_actual) > 1e-5:\n",
    "  pi += signo * ( 4 / termino_actual )\n",
    "  termino_actual += 2\n",
    "  signo *= -1\n",
    "\n",
    "print(f\"Aproximación de Pi: {pi}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DWmTIRzaO-x8"
   },
   "source": [
    "### 3.4. Break, continue, pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VjWDvBo8wcP9"
   },
   "source": [
    "---\n",
    "Break, continue, pass\n",
    "\n",
    "---\n",
    "\n",
    "Las declaraciones break, continue y pass son herramientas fundamentales en Python para controlar el flujo de ejecución en bucles y condicionales.\n",
    "\n",
    "* `break`: La declaración `break` se utiliza en Python para salir inmediatamente de un bucle o condicional, ya sea un bucle for o while, interrumpiendo su ejecución. Cuando se encuentra la instrucción `break`, el control del programa se transfiere fuera del bucle, y la ejecución continúa con la primera instrucción después del bucle.\n",
    "\n",
    "* `continue`: La declaración `continue` se utiliza para pasar a la siguiente iteración de un bucle, omitiendo el resto del código dentro del bucle para la iteración actual. Cuando se encuentra la instrucción continue, el programa salta directamente al comienzo del bucle para la siguiente iteración.\n",
    "\n",
    "* `pass`: La declaración `pass` no realiza ninguna acción y simplemente actúa como un marcador de posición. Es útil cuando la sintaxis de Python requiere alguna instrucción, pero no se desea realizar ninguna acción. `pass` se utiliza comúnmente para evitar errores de sintaxis cuando aún no se ha implementado el código real."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1706071187843,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "QuHz-JsmO-Eh",
    "outputId": "77df545f-1024-4098-dc0f-9e147db5783f"
   },
   "outputs": [],
   "source": [
    "# Ejemplo sentencia break\n",
    "for i in range(5):\n",
    "    if i == 3:\n",
    "        break\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 198,
     "status": "ok",
     "timestamp": 1706071208574,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "RHr2UgwZxIjE",
    "outputId": "05d84c11-06bd-46ac-b053-70dfc19692d5"
   },
   "outputs": [],
   "source": [
    "# Ejemplo sentencia continue\n",
    "for i in range(5):\n",
    "    if i == 2:\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1706071225749,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "Ohc9d8t2xNNE",
    "outputId": "6bfcd929-7342-4ec9-81c4-a062d1a20675"
   },
   "outputs": [],
   "source": [
    "# Ejemplo sentencia pass\n",
    "for i in range(5):\n",
    "    if i == 2:\n",
    "        pass  # Aquí se podría agregar código en el futuro\n",
    "    else:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1706071249106,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "Eu86j5ZQxPNM",
    "outputId": "2141479f-521a-4174-977d-1db82e292553"
   },
   "outputs": [],
   "source": [
    "# Uso de break para salir de un bucle cuando se encuentra un elemento\n",
    "elemento_a_buscar = 3\n",
    "lista = [1, 2, 3, 4, 5]\n",
    "\n",
    "for numero in lista:\n",
    "    if numero == elemento_a_buscar:\n",
    "        print(\"Elemento encontrado\")\n",
    "        break\n",
    "else:\n",
    "    print(\"Elemento no encontrado\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1706071258887,
     "user": {
      "displayName": "Nicolas Castillo Ojeda",
      "userId": "07071882850745015721"
     },
     "user_tz": 300
    },
    "id": "5dogb88AxU6L",
    "outputId": "7a5d11ad-5c04-4871-8b10-44819ca9a284"
   },
   "outputs": [],
   "source": [
    "# Uso de continue para omitir la impresión de números pares\n",
    "limite = 10\n",
    "\n",
    "for i in range(1, limite + 1):\n",
    "    if i % 2 == 0:\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aC8Ta0iSmPhX"
   },
   "source": [
    "# **Créditos**\n",
    "---\n",
    "\n",
    "**Docente:** Nicolás Castillo Ojeda\n",
    "\n",
    "**Universidad Pedagógica y Tecnológica de Colombia** - *Diplomado en Data Science - Choorte I - 2024*\n",
    "\n",
    "\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "authorship_tag": "ABX9TyM9Vm0cPwZNGtA9KO2Gj/eM",
   "collapsed_sections": [
    "aMkZsHY5tzQv",
    "ZdqDbnr-uX94",
    "mGcsKdYg3EZc",
    "hdrhotSgiDl0",
    "CTtuKyPCyzl6",
    "e3xXlj50t5--",
    "Hdg8gL8Bz4QR",
    "W4R5W9uYF9iK",
    "4a37VuYf1vC6",
    "6N-xdiof-BC6",
    "5GTp49_IGD15",
    "wfxkZ2y5rNz6",
    "th9UI0EnIzxp",
    "_ZYrL6apNox5",
    "rotQ9XOGjvAs",
    "Dpnub-Xlj7ds",
    "dJ23b8nUj_Ns",
    "ohTitfUboB8F",
    "7_jeIaQuO5rS",
    "DWmTIRzaO-x8"
   ],
   "mount_file_id": "19iXRvnqKue-0kstpQ_9wQT0sOVW37IZg",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}