8_arrays.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listas, Tuplas, Sets y Diccionarios en Python (Arrays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listas\n",
    "\n",
    "Las listas son un tipo de variable que permite almacenar una colección de datos en una sola variable (Array). Las listas permiten tener la colección de datos de forma ordenada, es modificable y permite tener valores repetidos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "lista = [1,2,3,4]\n",
    "\n",
    "print(lista)\n",
    "print(type(lista))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tambien podemos utilizar el constructor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "lista = list((1, 2, 3, 4))\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas pueden incluir cualquier tipo de variable en cada una de sus entradas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Esta', 'es', 'una', 'lista']\n",
      "[1, 2, 3, 4]\n",
      "[1.1, 1.5, 3.2]\n",
      "[True, False, False, True]\n"
     ]
    }
   ],
   "source": [
    "lista_str = [\"Esta\", \"es\", \"una\", \"lista\"]\n",
    "lista_int = [1, 2, 3, 4]\n",
    "lista_f = [1.1, 1.5, 3.2]\n",
    "lista_bool = [True, False, False, True]\n",
    "\n",
    "print(lista_str)\n",
    "print(lista_int)\n",
    "print(lista_f)\n",
    "print(lista_bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Incluso puede incluir datos de diferentes tipos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'string', False, 2.5, 1]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "lista = [1, \"string\", False, 2.5, 1]\n",
    "\n",
    "print(lista)\n",
    "print(type(lista))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos tener una lista de listas para obtener un array de dos dimensiones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2], [3, 4], [5, 6]]\n"
     ]
    }
   ],
   "source": [
    "lista = [[1, 2], [3, 4], [5, 6]]\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Longitud de una lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3, 4]\n",
    "\n",
    "print(len(lista))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acceder a los elementos de una lista basta con indicar el indice del elemento que queremos obtener. Las listas en python utilizan indice 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "6\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "print(lista[0]) ## Primer elemento\n",
    "print(lista[1]) ## Segundo elemento\n",
    "print(lista[3]) ## Cuarto elemento\n",
    "print(lista[-1]) ## Último elemento\n",
    "print(lista[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acceder tambien a tramos o slices de la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[5, 6]\n",
      "[3, 4, 5]\n",
      "[4, 5]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "print(lista[:3]) ## Del primer al tercer elemento\n",
    "print(lista[4:]) ## Del quinto al ultimo elemento\n",
    "print(lista[2:5]) ## Del tercer al quinto elemento\n",
    "print(lista[-3:-1]) ## Del antepenultimo al penultimo elemento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "lista = [[1, 2], [3, 4], [5, 6]]\n",
    "\n",
    "print(lista[0])\n",
    "print(lista[1][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos verificar si existe un elemento en la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La palabra 'Esta' esta en la variable lista\n",
      "La palabra 'lista' esta en la variable lista\n"
     ]
    }
   ],
   "source": [
    "lista = [\"Esta\", \"es\", \"una\", \"lista\"]\n",
    "\n",
    "if \"Esta\" in lista:\n",
    "    print(\"La palabra 'Esta' esta en la variable lista\")\n",
    "\n",
    "if \"lista\" in lista:\n",
    "    print(\"La palabra 'lista' esta en la variable lista\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos modificar los valores dentro de la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista original:\n",
      "[1, 2, 3, 4]\n",
      "Lista modificada:\n",
      "[1, 2, 10, 4]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3, 4]\n",
    "\n",
    "print(\"Lista original:\")\n",
    "print(lista)\n",
    "\n",
    "lista[2] = 10\n",
    "\n",
    "print(\"Lista modificada:\")\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista original:\n",
      "[1, 2, 3, 4]\n",
      "Lista modificada:\n",
      "[1, 15, 13, 4]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3, 4]\n",
    "\n",
    "print(\"Lista original:\")\n",
    "print(lista)\n",
    "\n",
    "lista[1:3] = [15, 13]\n",
    "\n",
    "print(\"Lista modificada:\")\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista original:\n",
      "[1, 2, 3, 4]\n",
      "Lista modificada:\n",
      "[1, 22, 4]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3, 4]\n",
    "\n",
    "print(\"Lista original:\")\n",
    "print(lista)\n",
    "\n",
    "lista[1:3] = [22]\n",
    "\n",
    "print(\"Lista modificada:\")\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos añadir elementos a la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista original:\n",
      "[1, 2]\n",
      "Lista con nuevo elemento:\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2]\n",
    "\n",
    "print(\"Lista original:\")\n",
    "print(lista)\n",
    "\n",
    "lista.append(3)\n",
    "\n",
    "print(\"Lista con nuevo elemento:\")\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos insertar un elemento en un indice especifico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista original:\n",
      "[1, 2]\n",
      "Lista con nuevo elemento:\n",
      "[1, 10, 2]\n",
      "Lista con nuevo elemento:\n",
      "[1, 12, 10, 2]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2]\n",
    "\n",
    "print(\"Lista original:\")\n",
    "print(lista)\n",
    "\n",
    "lista.insert(1, 10)\n",
    "\n",
    "print(\"Lista con nuevo elemento:\")\n",
    "print(lista)\n",
    "\n",
    "lista.insert(1, 12)\n",
    "\n",
    "print(\"Lista con nuevo elemento:\")\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos expandir la lista combinando los datos con otra lista (El método extend permite combinar con cualquier iterable, no solo listas, por lo que se pueden exterder tuplas, y sets)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista 1:\n",
      "[1, 2]\n",
      "Lista 2:\n",
      "[3, 4]\n",
      "Lista extendida:\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "lista_1 = [1, 2]\n",
    "lista_2 = [3, 4]\n",
    "\n",
    "print(\"Lista 1:\")\n",
    "print(lista_1)\n",
    "print(\"Lista 2:\")\n",
    "print(lista_2)\n",
    "\n",
    "lista_1.extend(lista_2)\n",
    "\n",
    "print(\"Lista extendida:\")\n",
    "print(lista_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista 1:\n",
      "[1, 2]\n",
      "Lista 2:\n",
      "[3, 4]\n",
      "Lista extendida:\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "lista_1 = [1, 2]\n",
    "lista_2 = [3, 4]\n",
    "\n",
    "print(\"Lista 1:\")\n",
    "print(lista_1)\n",
    "print(\"Lista 2:\")\n",
    "print(lista_2)\n",
    "\n",
    "lista_extendida = lista_1 + lista_2\n",
    "\n",
    "print(\"Lista extendida:\")\n",
    "print(lista_extendida)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos eliminar elementos de la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista original:\n",
      "['Esta', 'es', 'una', 'lista']\n",
      "Lista con elemento eliminado:\n",
      "['es', 'una', 'lista']\n"
     ]
    }
   ],
   "source": [
    "lista = [\"Esta\", \"es\", \"una\", \"lista\"]\n",
    "\n",
    "print(\"Lista original:\")\n",
    "print(lista)\n",
    "\n",
    "lista.remove(\"Esta\")\n",
    "\n",
    "print(\"Lista con elemento eliminado:\")\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos eliminar elementos en un indice especifico (Por defecto el método pop elimina el último elemento de la lista)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista original:\n",
      "['Esta', 'es', 'una', 'lista']\n",
      "Lista con elemento eliminado:\n",
      "['Esta', 'una', 'lista']\n"
     ]
    }
   ],
   "source": [
    "lista = [\"Esta\", \"es\", \"una\", \"lista\"]\n",
    "\n",
    "print(\"Lista original:\")\n",
    "print(lista)\n",
    "\n",
    "lista.pop(1)\n",
    "\n",
    "print(\"Lista con elemento eliminado:\")\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista original:\n",
      "['Esta', 'es', 'una', 'lista']\n",
      "Lista con elemento eliminado:\n",
      "['Esta', 'una', 'lista']\n"
     ]
    }
   ],
   "source": [
    "lista = [\"Esta\", \"es\", \"una\", \"lista\"]\n",
    "\n",
    "print(\"Lista original:\")\n",
    "print(lista)\n",
    "\n",
    "del lista[1]\n",
    "\n",
    "print(\"Lista con elemento eliminado:\")\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos eliminar toda la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista original:\n",
      "['Esta', 'es', 'una', 'lista']\n",
      "La lista no existe\n"
     ]
    }
   ],
   "source": [
    "lista = [\"Esta\", \"es\", \"una\", \"lista\"]\n",
    "\n",
    "print(\"Lista original:\")\n",
    "print(lista)\n",
    "\n",
    "del lista\n",
    "\n",
    "try:\n",
    "    print(lista)\n",
    "except:\n",
    "    print(\"La lista no existe\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O podemos vaciar la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista original:\n",
      "['Esta', 'es', 'una', 'lista']\n",
      "Lista vacia:\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "lista = [\"Esta\", \"es\", \"una\", \"lista\"]\n",
    "\n",
    "print(\"Lista original:\")\n",
    "print(lista)\n",
    "\n",
    "lista.clear()\n",
    "\n",
    "print(\"Lista vacia:\")\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dependiendo del tipo de la lista, tambien la podemos ordenar de forma alfabetica o numerica."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista original:\n",
      "['Manzana', 'Elefante', 'Arbol', 'Naranja', 'Piña']\n",
      "Lista en orden alfabético:\n",
      "['Arbol', 'Elefante', 'Manzana', 'Naranja', 'Piña']\n",
      "Lista en orden alfabético invertido:\n",
      "['Piña', 'Naranja', 'Manzana', 'Elefante', 'Arbol']\n"
     ]
    }
   ],
   "source": [
    "lista = [\"Manzana\", \"Elefante\", \"Arbol\", \"Naranja\", \"Piña\"]\n",
    "\n",
    "print(\"Lista original:\")\n",
    "print(lista)\n",
    "\n",
    "lista.sort()\n",
    "\n",
    "print(\"Lista en orden alfabético:\")\n",
    "print(lista)\n",
    "\n",
    "lista.sort(reverse=True)\n",
    "\n",
    "print(\"Lista en orden alfabético invertido:\")\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista original:\n",
      "[10, 5, 2, 3, 1, 8]\n",
      "Lista en orden ascendente:\n",
      "[1, 2, 3, 5, 8, 10]\n",
      "Lista en orden descendente:\n",
      "[10, 8, 5, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "lista = [10, 5, 2, 3, 1, 8]\n",
    "\n",
    "print(\"Lista original:\")\n",
    "print(lista)\n",
    "\n",
    "lista.sort()\n",
    "\n",
    "print(\"Lista en orden ascendente:\")\n",
    "print(lista)\n",
    "\n",
    "lista.sort(reverse=True)\n",
    "\n",
    "print(\"Lista en orden descendente:\")\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos realizar una copia de nuestra lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3]\n",
    "\n",
    "print(lista)\n",
    "\n",
    "copia = lista.copy()\n",
    "\n",
    "print(copia)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 3]\n",
    "\n",
    "print(lista)\n",
    "\n",
    "copia = list(lista)\n",
    "\n",
    "print(copia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Comprehension\n",
    "\n",
    "El método de list comprehension permite acortar la sintaxis cuando queremos crear una nueva lista utilizando una estructura ciclica o a partir de otra lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['arbol', 'alcoba', 'atleta']\n"
     ]
    }
   ],
   "source": [
    "palabras = [\"arbol\", \"naranja\", \"alcoba\", \"blanco\", \"elefante\", \"manzana\", \"atleta\"]\n",
    "\n",
    "lista = []\n",
    "\n",
    "for palabra in palabras:\n",
    "    if \"a\" in palabra[0]:\n",
    "        lista.append(palabra)\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['arbol', 'alcoba', 'atleta']\n"
     ]
    }
   ],
   "source": [
    "palabras = [\"arbol\", \"naranja\", \"alcoba\", \"blanco\", \"elefante\", \"manzana\", \"atleta\"]\n",
    "\n",
    "lista = [palabra for palabra in palabras if \"a\" in palabra[0]]\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuplas\n",
    "\n",
    "Las tuplas son similares a las listas en el sentido de que permiten almacenar una colección de datos. Sin embargo, las tuplas son inmutables, es decir no pueden ser modificadas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "tupla = (1, 2, 3, 4)\n",
    "\n",
    "print(tupla)\n",
    "print(type(tupla))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acceder a sus valores igual que en una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "tupla = (1, 2, 3, 4)\n",
    "\n",
    "print(tupla[0])\n",
    "print(tupla[1])\n",
    "print(tupla[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos extraer los valores individualmente (Unpacking)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "manzana\n",
      "pera\n",
      "naranja\n"
     ]
    }
   ],
   "source": [
    "tupla = (\"manzana\", \"pera\", \"naranja\")\n",
    "\n",
    "(manzana, pera, naranja) = tupla\n",
    "\n",
    "print(manzana)\n",
    "print(pera)\n",
    "print(naranja)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "manzana\n",
      "['pera', 'naranja', 'mora']\n"
     ]
    }
   ],
   "source": [
    "tupla = (\"manzana\", \"pera\", \"naranja\", \"mora\")\n",
    "\n",
    "(manzana, *frutas) = tupla\n",
    "\n",
    "print(manzana)\n",
    "print(frutas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "manzana\n",
      "['pera', 'naranja']\n",
      "mora\n"
     ]
    }
   ],
   "source": [
    "tupla = (\"manzana\", \"pera\", \"naranja\", \"mora\")\n",
    "\n",
    "(manzana, *frutas, mora) = tupla\n",
    "\n",
    "print(manzana)\n",
    "print(frutas)\n",
    "print(mora)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos unir tuplas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tupla 1:\n",
      "(1, 2)\n",
      "Tupla 2:\n",
      "(3, 4)\n",
      "Tupla extendida:\n",
      "(1, 2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "tupla_1 = (1, 2)\n",
    "tupla_2 = (3, 4)\n",
    "\n",
    "print(\"Tupla 1:\")\n",
    "print(tupla_1)\n",
    "print(\"Tupla 2:\")\n",
    "print(tupla_2)\n",
    "\n",
    "tupla_extendida = tupla_1 + tupla_2\n",
    "\n",
    "print(\"Tupla extendida:\")\n",
    "print(tupla_extendida)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets\n",
    "\n",
    "Los sets son similares a las listas y tuplas, estos permiten almacenar una colección de datos. La diferencia con las listas y tuplas es que los sets no tienen orden, sus elementos no pueden ser modificados (solo se pueden añadir o eliminar elementos), no permiten elementos duplicados, y no tienen indexación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "mi_set = {1, 2, 3, 4}\n",
    "\n",
    "print(mi_set)\n",
    "print(type(mi_set))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "mi_set = {1, 2, 2, 3, 4, 5, 1}\n",
    "\n",
    "print(mi_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'manzana', 'mora', 'fresa', 'piña'}\n"
     ]
    }
   ],
   "source": [
    "mi_set = {\"manzana\", \"piña\", \"manzana\", \"mora\", \"mora\", \"fresa\"}\n",
    "\n",
    "print(mi_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos añadir elementos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set original:\n",
      "{1, 2, 3}\n",
      "Set con nuevo elemento:\n",
      "{1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "mi_set = {1, 2, 3}\n",
    "\n",
    "print(\"Set original:\")\n",
    "print(mi_set)\n",
    "\n",
    "mi_set.add(4)\n",
    "\n",
    "print(\"Set con nuevo elemento:\")\n",
    "print(mi_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos eliminar elementos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set original:\n",
      "{1, 2, 3}\n",
      "Set con elemento eliminado:\n",
      "{2, 3}\n"
     ]
    }
   ],
   "source": [
    "mi_set = {1, 2, 3}\n",
    "\n",
    "print(\"Set original:\")\n",
    "print(mi_set)\n",
    "\n",
    "mi_set.remove(1)\n",
    "\n",
    "print(\"Set con elemento eliminado:\")\n",
    "print(mi_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set original:\n",
      "{1, 2, 3}\n",
      "Set con elemento eliminado:\n",
      "{1, 3}\n"
     ]
    }
   ],
   "source": [
    "mi_set = {1, 2, 3}\n",
    "\n",
    "print(\"Set original:\")\n",
    "print(mi_set)\n",
    "\n",
    "mi_set.discard(2)\n",
    "\n",
    "print(\"Set con elemento eliminado:\")\n",
    "print(mi_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos vaciar el set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set original:\n",
      "{1, 2, 3}\n",
      "Set vacio:\n",
      "set()\n"
     ]
    }
   ],
   "source": [
    "mi_set = {1, 2, 3}\n",
    "\n",
    "print(\"Set original:\")\n",
    "print(mi_set)\n",
    "\n",
    "mi_set.clear()\n",
    "\n",
    "print(\"Set vacio:\")\n",
    "print(mi_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos extenderlo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1:\n",
      "{1, 2}\n",
      "Set 2:\n",
      "{3, 4}\n",
      "Set extendido:\n",
      "{1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "mi_set_1 = {1, 2}\n",
    "mi_set_2 = {3, 4}\n",
    "\n",
    "print(\"Set 1:\")\n",
    "print(mi_set_1)\n",
    "print(\"Set 2:\")\n",
    "print(mi_set_2)\n",
    "\n",
    "mi_set_1.update(mi_set_2)\n",
    "\n",
    "print(\"Set extendido:\")\n",
    "print(mi_set_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1:\n",
      "{1, 2}\n",
      "Set 2:\n",
      "{3, 4}\n",
      "Set extendido:\n",
      "{1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "mi_set_1 = {1, 2}\n",
    "mi_set_2 = {3, 4}\n",
    "\n",
    "print(\"Set 1:\")\n",
    "print(mi_set_1)\n",
    "print(\"Set 2:\")\n",
    "print(mi_set_2)\n",
    "\n",
    "mi_set_3 = mi_set_1 | mi_set_2\n",
    "\n",
    "print(\"Set extendido:\")\n",
    "print(mi_set_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1:\n",
      "{1, 2}\n",
      "Set 2:\n",
      "{3, 4}\n",
      "Set 3:\n",
      "{5, 6}\n",
      "Set extendido:\n",
      "{1, 2, 3, 4, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "mi_set_1 = {1, 2}\n",
    "mi_set_2 = {3, 4}\n",
    "mi_set_3 = {5, 6}\n",
    "\n",
    "print(\"Set 1:\")\n",
    "print(mi_set_1)\n",
    "print(\"Set 2:\")\n",
    "print(mi_set_2)\n",
    "print(\"Set 3:\")\n",
    "print(mi_set_3)\n",
    "\n",
    "mi_set_4 = mi_set_1.union(mi_set_2, mi_set_3)\n",
    "\n",
    "print(\"Set extendido:\")\n",
    "print(mi_set_4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos conservar solo los valores duplicados entre 2 sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1:\n",
      "{1, 2, 3}\n",
      "Set 2:\n",
      "{1, 3, 4}\n",
      "Valores duplicados:\n",
      "{1, 3}\n"
     ]
    }
   ],
   "source": [
    "mi_set_1 = {1, 2, 3}\n",
    "mi_set_2 = {1, 3, 4}\n",
    "\n",
    "print(\"Set 1:\")\n",
    "print(mi_set_1)\n",
    "print(\"Set 2:\")\n",
    "print(mi_set_2)\n",
    "\n",
    "mi_set_3 = mi_set_1.intersection(mi_set_2)\n",
    "\n",
    "print(\"Valores duplicados:\")\n",
    "print(mi_set_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1:\n",
      "{1, 2, 3}\n",
      "Set 2:\n",
      "{1, 3, 4}\n",
      "Valores duplicados:\n",
      "{1, 3}\n"
     ]
    }
   ],
   "source": [
    "mi_set_1 = {1, 2, 3}\n",
    "mi_set_2 = {1, 3, 4}\n",
    "\n",
    "print(\"Set 1:\")\n",
    "print(mi_set_1)\n",
    "print(\"Set 2:\")\n",
    "print(mi_set_2)\n",
    "\n",
    "mi_set_3 = mi_set_1 & mi_set_2\n",
    "\n",
    "print(\"Valores duplicados:\")\n",
    "print(mi_set_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1:\n",
      "{1, 2, 3}\n",
      "Set 2:\n",
      "{1, 3, 4}\n",
      "Valores duplicados:\n",
      "{1, 3}\n"
     ]
    }
   ],
   "source": [
    "mi_set_1 = {1, 2, 3}\n",
    "mi_set_2 = {1, 3, 4}\n",
    "\n",
    "print(\"Set 1:\")\n",
    "print(mi_set_1)\n",
    "print(\"Set 2:\")\n",
    "print(mi_set_2)\n",
    "\n",
    "mi_set_1.intersection_update(mi_set_2) ## Modifica el set existente\n",
    "\n",
    "print(\"Valores duplicados:\")\n",
    "print(mi_set_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos conservar los valores de un set que no estan presentes en otro set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1:\n",
      "{1, 2, 3}\n",
      "Set 2:\n",
      "{1, 3, 4}\n",
      "Valores duplicados:\n",
      "{2}\n"
     ]
    }
   ],
   "source": [
    "mi_set_1 = {1, 2, 3}\n",
    "mi_set_2 = {1, 3, 4}\n",
    "\n",
    "print(\"Set 1:\")\n",
    "print(mi_set_1)\n",
    "print(\"Set 2:\")\n",
    "print(mi_set_2)\n",
    "\n",
    "mi_set_3 = mi_set_1.difference(mi_set_2)\n",
    "\n",
    "print(\"Valores unicos:\")\n",
    "print(mi_set_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1:\n",
      "{1, 2, 3}\n",
      "Set 2:\n",
      "{1, 3, 4}\n",
      "Valores duplicados:\n",
      "{2}\n"
     ]
    }
   ],
   "source": [
    "mi_set_1 = {1, 2, 3}\n",
    "mi_set_2 = {1, 3, 4}\n",
    "\n",
    "print(\"Set 1:\")\n",
    "print(mi_set_1)\n",
    "print(\"Set 2:\")\n",
    "print(mi_set_2)\n",
    "\n",
    "mi_set_3 = mi_set_1 - mi_set_2\n",
    "\n",
    "print(\"Valores unicos:\")\n",
    "print(mi_set_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1:\n",
      "{1, 2, 3}\n",
      "Set 2:\n",
      "{1, 3, 4}\n",
      "Valores duplicados:\n",
      "{2}\n"
     ]
    }
   ],
   "source": [
    "mi_set_1 = {1, 2, 3}\n",
    "mi_set_2 = {1, 3, 4}\n",
    "\n",
    "print(\"Set 1:\")\n",
    "print(mi_set_1)\n",
    "print(\"Set 2:\")\n",
    "print(mi_set_2)\n",
    "\n",
    "mi_set_1.difference_update(mi_set_2) ## Modifica el set existente\n",
    "\n",
    "print(\"Valores unicos:\")\n",
    "print(mi_set_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos conservar los elementos que no se repiten en los 2 sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1:\n",
      "{1, 2, 3}\n",
      "Set 2:\n",
      "{1, 3, 4}\n",
      "Valores no repetidos:\n",
      "{2, 4}\n"
     ]
    }
   ],
   "source": [
    "mi_set_1 = {1, 2, 3}\n",
    "mi_set_2 = {1, 3, 4}\n",
    "\n",
    "print(\"Set 1:\")\n",
    "print(mi_set_1)\n",
    "print(\"Set 2:\")\n",
    "print(mi_set_2)\n",
    "\n",
    "mi_set_3 = mi_set_1.symmetric_difference(mi_set_2)\n",
    "\n",
    "print(\"Valores no repetidos:\")\n",
    "print(mi_set_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1:\n",
      "{1, 2, 3}\n",
      "Set 2:\n",
      "{1, 3, 4}\n",
      "Valores no repetidos:\n",
      "{2, 4}\n"
     ]
    }
   ],
   "source": [
    "mi_set_1 = {1, 2, 3}\n",
    "mi_set_2 = {1, 3, 4}\n",
    "\n",
    "print(\"Set 1:\")\n",
    "print(mi_set_1)\n",
    "print(\"Set 2:\")\n",
    "print(mi_set_2)\n",
    "\n",
    "mi_set_3 = mi_set_1 ^ mi_set_2\n",
    "\n",
    "print(\"Valores no repetidos:\")\n",
    "print(mi_set_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set 1:\n",
      "{1, 2, 3}\n",
      "Set 2:\n",
      "{1, 3, 4}\n",
      "Valores no repetidos:\n",
      "{2, 4}\n"
     ]
    }
   ],
   "source": [
    "mi_set_1 = {1, 2, 3}\n",
    "mi_set_2 = {1, 3, 4}\n",
    "\n",
    "print(\"Set 1:\")\n",
    "print(mi_set_1)\n",
    "print(\"Set 2:\")\n",
    "print(mi_set_2)\n",
    "\n",
    "mi_set_1.symmetric_difference_update(mi_set_2) ## Modifica el set existente\n",
    "\n",
    "print(\"Valores no repetidos:\")\n",
    "print(mi_set_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diccionarios\n",
    "\n",
    "Los diccionarios son otro tipo de variable que permite almacenar una colección de datos. La particularidad de estos es que utilizan un fofrma en key-value pairs. Los diccionarios son ordenados, permiten modificaciones y no permiten valores repetidos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'item1': 1, 'item2': 'dos', 'item3': True}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": \"dos\", \"item3\": True}\n",
    "\n",
    "print(dic)\n",
    "print(type(dic))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'item1': 1, 'item2': 'dos', 'item3': True}\n"
     ]
    }
   ],
   "source": [
    "dic = dict(item1 = 1, item2 = \"dos\", item3 = True)\n",
    "\n",
    "print(dic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'item1': 1, 'item2': 2000}\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": 2024, \"item2\": 2000}\n",
    "\n",
    "print(dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos el numero de key-value pairs como si fuera una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": \"dos\", \"item3\": True}\n",
    "\n",
    "print(len(dic))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acceder facilmente a cada valor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dos\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": \"dos\", \"item3\": True}\n",
    "\n",
    "print(dic[\"item2\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": \"dos\", \"item3\": True}\n",
    "\n",
    "print(dic.get(\"item1\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acceder a todas las keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['item1', 'item2', 'item3'])\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": \"dos\", \"item3\": True}\n",
    "\n",
    "print(dic.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos accedes a todos los valores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values([1, 'dos', True])\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": \"dos\", \"item3\": True}\n",
    "\n",
    "print(dic.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos obtener los key-value pairs como tuplas en una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('item1', 1), ('item2', 'dos'), ('item3', True)])\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": \"dos\", \"item3\": True}\n",
    "\n",
    "print(dic.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos verificar si existe un elemento (key) en el diccionario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El 'item1' existe en el diccionario\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": \"dos\", \"item3\": True}\n",
    "\n",
    "if \"item1\" in dic:\n",
    "\n",
    "    print(\"El 'item1' existe en el diccionario\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos modificar los valores del diccionario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'item1': 1, 'item2': 'dos', 'item3': 10}\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": \"dos\", \"item3\": True}\n",
    "\n",
    "dic[\"item3\"] = 10\n",
    "\n",
    "print(dic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'item1': 1, 'item2': 'dos', 'item3': 10}\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": \"dos\", \"item3\": True}\n",
    "\n",
    "dic.update({\"item3\": 10})\n",
    "\n",
    "print(dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al igual que como modificamos los elementos podemos añadir elementos al diccionario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'item1': 1, 'item2': 'dos', 'item3': True, 'item4': 10}\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": \"dos\", \"item3\": True}\n",
    "\n",
    "dic[\"item4\"] = 10\n",
    "\n",
    "print(dic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'item1': 1, 'item2': 'dos', 'item3': True, 'item4': 10}\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": \"dos\", \"item3\": True}\n",
    "\n",
    "dic.update({\"item4\": 10})\n",
    "\n",
    "print(dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos eliminar elementos del diccionario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'item1': 1, 'item3': True}\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": \"dos\", \"item3\": True}\n",
    "\n",
    "dic.pop(\"item2\")\n",
    "\n",
    "print(dic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'item1': 1, 'item2': 'dos'}\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": \"dos\", \"item3\": True}\n",
    "\n",
    "dic.popitem() ## Remueve el ultimo elemento python > 3.7\n",
    "\n",
    "print(dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos vaciar el diccionario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": \"dos\", \"item3\": True}\n",
    "\n",
    "dic.clear()\n",
    "\n",
    "print(dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos tener diccionario anidados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'edad': 20, 'nota': 4}\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "estudiantes = {\n",
    "    \"estudiante1\": {\n",
    "        \"edad\": 20,\n",
    "        \"nota\": 4\n",
    "    },\n",
    "    \"estudiante2\": {\n",
    "        \"edad\": 22,\n",
    "        \"nota\": 5\n",
    "    },\n",
    "    \"estudiante3\": {\n",
    "        \"edad\": 19,\n",
    "        \"nota\": 1\n",
    "    },\n",
    "}\n",
    "\n",
    "print(estudiantes[\"estudiante1\"])\n",
    "print(estudiantes[\"estudiante1\"][\"nota\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterar sobre arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------ Lista ------\n",
      "1\n",
      "2\n",
      "1\n",
      "3\n",
      "3\n",
      "4\n",
      "------ Tupla ------\n",
      "1\n",
      "2\n",
      "1\n",
      "3\n",
      "3\n",
      "4\n",
      "------ Set ------\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, 1, 3, 3, 4]\n",
    "tupla = (1, 2, 1, 3, 3, 4)\n",
    "mi_set = {1, 2, 1, 3, 3, 4}\n",
    "\n",
    "print(\"------ Lista ------\")\n",
    "\n",
    "for i in lista:\n",
    "    print(i)\n",
    "\n",
    "print(\"------ Tupla ------\")\n",
    "\n",
    "for i in tupla:\n",
    "    print(i)\n",
    "\n",
    "print(\"------ Set ------\")\n",
    "\n",
    "for i in mi_set:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para los diccionarios tenemos varias opciones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "item1\n",
      "item2\n",
      "item3\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": 2, \"item3\": 3}\n",
    "\n",
    "for i in dic:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "item1\n",
      "item2\n",
      "item3\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": 2, \"item3\": 3}\n",
    "\n",
    "for i in dic.keys():\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": 2, \"item3\": 3}\n",
    "\n",
    "for i in dic:\n",
    "    print(dic[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": 2, \"item3\": 3}\n",
    "\n",
    "for i in dic.values():\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "item1  ->  1\n",
      "item2  ->  2\n",
      "item3  ->  3\n"
     ]
    }
   ],
   "source": [
    "dic = {\"item1\": 1, \"item2\": 2, \"item3\": 3}\n",
    "\n",
    "for key, value in dic.items():\n",
    "    print(key, \" -> \", value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conversion de tipos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 3, 4]\n",
      "<class 'list'>\n",
      "(1, 1, 2, 3, 4)\n",
      "<class 'tuple'>\n",
      "{1, 2, 3, 4}\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 1, 2, 3, 4]\n",
    "\n",
    "print(lista)\n",
    "print(type(lista))\n",
    "\n",
    "tupla = tuple(lista)\n",
    "\n",
    "print(tupla)\n",
    "print(type(tupla))\n",
    "\n",
    "#mi_set = set(lista)\n",
    "mi_set = set(tupla)\n",
    "\n",
    "print(mi_set)\n",
    "print(type(mi_set))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}