03_Estructuras_de_Datos.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/rubuntu/uaa-417-sistemas-de-gestion-de-bases-de-datos-avanzados/blob/main/03_Estructuras_de_Datos.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ftrq8ik40p32"
      },
      "outputs": [],
      "source": [
        "!pip install expectexception\n",
        "import expectexception"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JKziKq980p31"
      },
      "outputs": [],
      "source": [
        "%matplotlib inline\n",
        "import matplotlib\n",
        "import seaborn as sns\n",
        "matplotlib.rcParams['savefig.dpi'] = 144"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "saTRyRHT0p32",
        "title": "[rebaja] [markdown] [markdown]"
      },
      "source": [
        "# Tipos de datos y estructuras de Python\n",
        "\n",
        "  <!-- requirement: images/list_illustration.png -->\n",
        "  <!-- requirement: images/hash_illustration.png -->\n",
        "  <!-- requirement: images/set_operations.png -->\n",
        "\n",
        "En [Flujo de Programas](02_Fujo_de_Programas.ipynb), presentamos la idea de las variables, que podríamos usar para almacenar diferentes tipos de información. Podríamos almacenar texto, números o valores de verdad. Estos diferentes tipos de información se corresponden con los diferentes tipos de datos de Python."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zJI_hw100p33"
      },
      "outputs": [],
      "source": [
        "print(type('some text'))\n",
        "print(type(10))\n",
        "print(type(10.3))\n",
        "print(type(True))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DXYC-Fws0p34",
        "title": "[rebaja] [markdown] [markdown]"
      },
      "source": [
        "También presentamos brevemente la 'lista' de Python, que se puede utilizar para almacenar una recopilación de datos."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "K2vFYptw0p34"
      },
      "outputs": [],
      "source": [
        "# Una lista de ejemplo\n",
        "beans_recipe = ['Remojar los porotos en agua', 'Disolver la sal en agua', 'Calentar el agua y los frijoles a hervir',\n",
        "                \"Escurra los porotos cuando termine de cocinar\"]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RoSez_XF0p34",
        "title": "[rebaja] [markdown] [markdown]"
      },
      "source": [
        "A veces almacenamos información en variables individuales, pero a menudo trabajamos con varias piezas de información que queremos agrupar debido a su relación o similitud. Por ejemplo, si estuviéramos comprando comestibles, podríamos almacenar cada artículo que vamos a comprar en variables separadas o podríamos almacenar todos los artículos en una lista."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MSB9610N0p34"
      },
      "outputs": [],
      "source": [
        "grocery_a = 'pollo'\n",
        "grocery_b = 'cebollas'\n",
        "grocery_c = 'arroz'\n",
        "grocery_d = 'locote'\n",
        "grocery_e = 'bananas'\n",
        "\n",
        "grocery_list = ['pollo', 'cebollas', 'arroz', 'locote', 'bananas']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1fDvPPge0p34",
        "title": "[rebaja] [markdown] [markdown]"
      },
      "source": [
        "¿Cuál de estos enfoques te parece más útil? Escribamos una breve función de ejemplo que \"compre\" cada una de las compras que necesitamos."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DB_myqfa0p34"
      },
      "outputs": [],
      "source": [
        "def buy_groceries_individual(item_a, item_b, item_c, item_d, item_e):\n",
        "    print( 'Buying %s...' % item_a)\n",
        "    print( 'Buying %s...' % item_b)\n",
        "    print( 'Buying %s...' % item_c)\n",
        "    print( 'Buying %s...' % item_d)\n",
        "    print( 'Buying %s...' % item_e)\n",
        "\n",
        "def buy_grocery_list(items):\n",
        "    for item in items:\n",
        "        print(\"Buying %s...\" % item )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "E4Nd1W0x0p35"
      },
      "outputs": [],
      "source": [
        "buy_groceries_individual (grocery_a, grocery_b, grocery_c, grocery_d, grocery_e)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lxU6QKwJ0p35"
      },
      "outputs": [],
      "source": [
        "buy_grocery_list (grocery_list)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HLREtQ2K0p35",
        "title": "[rebaja] [markdown] [markdown]"
      },
      "source": [
        "Al usar una `list`, podríamos usar un bucle` for` para escribir una función mucho más corta. Pero aún más importante, `buy_grocery_list` es mucho más flexible. ¿Y si en lugar de comprar cinco artículos, quisiéramos comprar más o menos?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T2wIR9YQ0p35",
        "title": "expect_exception TypeError"
      },
      "outputs": [],
      "source": [
        "%%expect_exception TypeError\n",
        "\n",
        "# tratemos de comprar solo tres artículos\n",
        "buy_groceries_individual (grocery_a, grocery_b, grocery_c)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tTBPghbW0p35",
        "title": "expect_exception TypeError"
      },
      "outputs": [],
      "source": [
        "%%expect_exception TypeError\n",
        "\n",
        "# tratemos de comprar un sexto artículo\n",
        "\n",
        "grocery_f = 'squash'\n",
        "\n",
        "buy_groceries_individual (grocery_a, grocery_b, grocery_c, grocery_d, grocery_e, grocery_f)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rlTGyTB90p35",
        "title": "[rebaja] [markdown] [markdown]"
      },
      "outputs": [],
      "source": [
        "# Nos encontramos con un error cuando intentamos usar `buy_groceries_individual` porque está esperando\" exactamente 5 argumentos \". No encontramos ese problema con `buy_grocery_list`, porque nuestro bucle` for` puede funcionar con listas de cualquier longitud."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qUY1S80x0p36"
      },
      "outputs": [],
      "source": [
        "short_grocery_list = ['pollo', 'cebollas', 'arroz']\n",
        "\n",
        "buy_grocery_list (short_grocery_list)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bU56MyR70p36"
      },
      "outputs": [],
      "source": [
        "long_grocery_list = ['pollo', 'cebollas', 'arroz', 'locote', 'bananas', 'calabaza']\n",
        "\n",
        "buy_grocery_list (long_grocery_list)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qKWaR3Y20p36",
        "title": "[rebaja] [markdown] [markdown]"
      },
      "source": [
        " Vemos que tratamos con éxito tanto una lista más corta como una más larga.\n",
        "\n",
        " Colecciones (o [**containers**](https://stackoverflow.com/questions/11575925/what-exactly-are-containers-in-python-and-what-are-all-the-python-container) como se les conoce en Python) pueden ser muy útiles para abordar problemas de datos complejos. Python proporciona varios tipos de contenedores, que exploraremos. Cada una tiene diferentes propiedades y estructuras que las hacen útiles para tareas específicas. Más adelante en el curso, también presentaremos contenedores poderosos y altamente estructurados que los usuarios de Python han inventado y compartido con la comunidad de Python.\n",
        "\n",
        " En el contexto de la ciencia de datos, a menudo llamaremos una recopilación de datos que lógicamente pertenecen a un **conjunto de datos**, y al tipo de variable que usamos para almacenarlo en Python a **estructura de datos**. Estos términos pretenden enfatizar las relaciones entre las piezas individuales de información que crean su significado como un todo.\n",
        "\n",
        " ### Ejercicios\n",
        "\n",
        " 1. ¿Qué tipo de datos se pueden representar naturalmente en una `lista`? ¿Qué tal un `list` compuesto de objetos` list`?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fizws3yR0p36",
        "title": "[rebaja] [markdown] [markdown]"
      },
      "source": [
        " ## `lista`\n",
        "\n",
        " Hemos creado listas utilizando corchetes `[]` alrededor de los datos que queremos que contenga la lista. También podemos crear listas de variables, en lugar de escribir los datos directamente."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qPrYSOsn0p36"
      },
      "outputs": [],
      "source": [
        "grocery_a = 'pollo'\n",
        "grocery_b = 'cebolla'\n",
        "grocery_c = 'arroz'\n",
        "grocery_d = 'locote'\n",
        "grocery_e = 'bananas'\n",
        "\n",
        "grocery_list = ['pollo', 'cebolla', 'arroz', 'locote', 'bananas']\n",
        "print( grocery_list )\n",
        "\n",
        "grocery_list = [grocery_a, grocery_b, grocery_c, grocery_d, grocery_e]\n",
        "print( grocery_list )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5XpfGWhW0p36"
      },
      "source": [
        "Hasta ahora hemos trabajado con lists of strings (yrange), pero no estamos limitados solo a ese tipo de datos."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gD92aks10p36"
      },
      "outputs": [],
      "source": [
        "int_list = [2, 6, 3049, 18, 37]\n",
        "float_list = [3.7, 8.2, 178.245, 63.1]\n",
        "mixed_list = [26, False, 'some words', 1.264]\n",
        "\n",
        "print( int_list )\n",
        "print( float_list )\n",
        "print( mixed_list )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mslR-Yq-0p36"
      },
      "source": [
        "Podemos almacenar cualquier tipo de datos en unalista. Incluso podemos poner una lista dentro de una lista."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "McKA1h580p36"
      },
      "outputs": [],
      "source": [
        "list_of_lists = [['a', 'list', 'of', 'words'], [1, 5, 209], [True, True, False]]\n",
        "print( list_of_lists )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zaUnRUUh0p37"
      },
      "source": [
        "Hay muy pocas restricciones sobre cómo estructuramos una lista o lo que ponemos en ella. Esto puede llevar a una estructura anidada muy complicada."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zROZ-46N0p37"
      },
      "outputs": [],
      "source": [
        "confusing_list = [[23, 73, 50], 'some words', 12.308, [[False, True], 'more words']]\n",
        "print( confusing_list )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pta2L8OI0p37"
      },
      "source": [
        "Describimos la lista de Python como heterogénea porque puede contener una colección de objetos mixtos. Esta es una de las principales propiedades definitorias de la 'lista' de Python.\n",
        "\n",
        "Es posible que también haya notado que cuando colocamos los datos en una lista en un orden particular, permanece en ese orden cuandoimprimimos o usamos la lista en un buclefor. Como list conserva el orden, decimos que está ordered. Podemos usar esta propiedad para recuperar elementos particulares de una lista en función de su posición (o **index**) en la lista."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4MONqswP0p37"
      },
      "outputs": [],
      "source": [
        "print( grocery_list )\n",
        "print( grocery_list[2] )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XJBBjSI60p37"
      },
      "source": [
        "Imprimiendo `grocery_list [2]` devolvió el tercer elemento de la lista: 'arroz'. ¿Por qué devolvió el tercer artículo si solicitamos el artículo en el índice 2? Python `list`s están _cero-indexados_."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iLz7PeaB0p37"
      },
      "outputs": [],
      "source": [
        "print( grocery_list[0] )\n",
        "print( grocery_list[1] )\n",
        "print( grocery_list[2] )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pXdN71oS0p37"
      },
      "source": [
        "También podemos recuperar una _slice_ de elementos de una lista."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6f_YoDM20p37"
      },
      "outputs": [],
      "source": [
        "print( grocery_list[1:4] )\n",
        "print( grocery_list[3:] )\n",
        "print( grocery_list[:3] )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "11-DecKS0p38"
      },
      "source": [
        "Python también tiene una sintaxis de indexación negativa, lo que nos permite acceder a la lista desde el final en lugar del principio. El último elemento está indexado por -1."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tLptLp-x0p38"
      },
      "outputs": [],
      "source": [
        "print( grocery_list[-1] )\n",
        "print( grocery_list[-3:] )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Embdvh730p38"
      },
      "source": [
        "También podemos dividir una lista utilizando un tamaño de paso distinto de 1. Por ejemplo, podemos dividir todos los demás elementos de la lista, o incluso revertir la lista haciendo pasos negativos."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "H_eWDrcG0p38"
      },
      "outputs": [],
      "source": [
        "print( grocery_list[::2] )\n",
        "print( grocery_list[4:1:-1] )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5siLOyba0p38"
      },
      "source": [
        "Por supuesto, también podemos recuperar información de una lista usando un bucle `for`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hsXQLyR60p38"
      },
      "outputs": [],
      "source": [
        "for item in grocery_list:\n",
        "    print( item )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m-SVsnBk0p4A"
      },
      "source": [
        "Mientras que generalmente usaremos la sintaxis `para el elemento en la lista`, a veces combinaremos un bucle` for` con la indexación. La función `range` (que usamos en el último cuaderno) es útil para esto. Por ejemplo, podemos seleccionar todos los demás elementos de la lista."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zRM4i2ic0p4A"
      },
      "outputs": [],
      "source": [
        "for i in range(0, len(grocery_list), 2):\n",
        "    print( i, grocery_list[i] )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YzjPvJ4e0p4A"
      },
      "source": [
        "La función range crea una lista de enteros entre el primer y el segundo argumento, utilizando el tercer argumento como el tamaño del paso. Observe que el límite superior (es decir, el segundo argumento) no se incluye en la salida.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8TsujUdb0p4A"
      },
      "outputs": [],
      "source": [
        "print( range(0, 10, 3) )\n",
        "print( range(104, 100, -1) )\n",
        "print( range(5) ) # starts at 0 and counts by 1 by default"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h5L-wfub0p4B"
      },
      "source": [
        "También podemos usar la indexación / división para reemplazar elementos en la lista."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Plh7vGrt0p4B"
      },
      "outputs": [],
      "source": [
        "grocery_list = ['pollo', 'cebolla', 'arroz', 'locote', 'bananas']\n",
        "print( grocery_list )\n",
        "grocery_list[-1] = 'naranjas' # reemplazar bananas con naranjas\n",
        "print( grocery_list )\n",
        "grocery_list[1:3] = ['zanahoria', 'couscous'] #reemplazar cebolla y arroz con zanahoria and couscous\n",
        "print( grocery_list )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AcbZpwLE0p4B"
      },
      "source": [
        "Ya que podemos modificar las listas después de crearlas, las llamamos _mutable_ (las modificaciones se llaman _mutations_). Algunos tipos de datos de Python son _inmutables_, lo que significa que una vez que se crean no pueden modificarse. Exploraremos esto más a medida que introduzcamos más tipos de datos.\n",
        "\n",
        "Otra forma en la que podemos mutar una `lista` es` agregar 'nuevos elementos."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KtCBFGlf0p4B"
      },
      "outputs": [],
      "source": [
        "grocery_list = ['pollo', 'cebolla', 'arroz', 'locote', 'bananas']\n",
        "print( grocery_list )\n",
        "grocery_list.append('calabaza')\n",
        "print( grocery_list )\n",
        "grocery_list.append(['pan', 'sal'])\n",
        "print( grocery_list ) # que pasó?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8iQO6Td60p4B"
      },
      "source": [
        "Dado que las listas pueden contener listas, debemos tener cuidado al agregar varios elementos a nuestra lista. En lugar de `append`, podríamos usar` extend`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6lEdexd20p4B"
      },
      "outputs": [],
      "source": [
        "grocery_list = ['pollo', 'cebolla', 'arroz', 'locote', 'bananas', 'calabaza']\n",
        "print( grocery_list )\n",
        "grocery_list.extend(['pan', 'sal'])\n",
        "print( grocery_list )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6KQe6LWu0p4B"
      },
      "source": [
        "También podemos eliminar elementos de una lista."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pIW6JaAK0p4B"
      },
      "outputs": [],
      "source": [
        "print( grocery_list )\n",
        "del grocery_list[-1] # delete the last item\n",
        "print( grocery_list )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "r6BmA_Pv0p4C"
      },
      "outputs": [],
      "source": [
        "print( grocery_list )\n",
        "print( grocery_list.pop(-1)) # remove the last item from the list and return it\n",
        "print( grocery_list )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a9JzdQyv0p4C"
      },
      "source": [
        "Otra mutación que podemos hacer a una lista es ordenarla."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CTOhriVV0p4C"
      },
      "outputs": [],
      "source": [
        "grocery_list.sort()\n",
        "print( grocery_list )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "82Na7bG10p4C"
      },
      "source": [
        "Las tres propiedades definitorias principales de la lista de Python son ordenadas, heterogéneas y mutables. Debido a que es heterogéneo y mutable, la lista es muy flexible. Debemos tener cuidado con los cambios que hacemos en una lista, porque pueden ser muy impredecibles. ¡Podríamos romper nuestro código o perder datos!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CeM1v-pK0p4C"
      },
      "source": [
        "### Ejercicios\n",
        "\n",
        "1. Haz una lista de 10 elementos y selecciona solo los últimos 2 elementos\n",
        "2. Tome la misma lista de 10 elementos y seleccione cada otro elemento comenzando con el primer elemento.\n",
        "3. Seleccione cada otro elemento comenzando con el segundo elemento."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F-OoIETQ0p4C"
      },
      "source": [
        "### Atención (Nombres)\n",
        "Las variables y los nombres no son lo mismo en Python. Por ejemplo, ejecute el siguiente código"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NTofRRS00p4C"
      },
      "outputs": [],
      "source": [
        "a = 4\n",
        "b = a\n",
        "print( a, b )\n",
        "a = 5\n",
        "print( a, b )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HXef53Eg0p4D"
      },
      "source": [
        "Aquí asignamos el nombre `a` al valor 4 y luego` b` para que sea igual a `a`. Pero, `b` no apunta a` a`, apunta a la variable que tiene el nombre `a`. Por lo tanto, asignar el nombre `b` al valor de` a` no causa que el valor de `b` cambie cuando el valor de` a` cambia.\n",
        "\n",
        "Veamos otro ejemplo, aquí usaremos una 'lista' de Python. Vamos a repasar más sobre las listas en la próxima conferencia, por ahora, piense en esto como una colección ordenada de variables de Python (técnicamente objetos). En este caso, haremos exactamente lo que hicimos antes, pero en lugar de modificar dónde apunta `a`, modificaremos el objeto al que apunta. En este caso, veremos que 'b' cambia de hecho. ¡Esto se debe a que ambos apuntan a la misma variable en la memoria!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_J76lIoo0p4D"
      },
      "outputs": [],
      "source": [
        "a = [3, 2, 1]\n",
        "b = a\n",
        "print( a, b )\n",
        "a[1] = 5\n",
        "print( a, b )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IuUiqxRx0p4D"
      },
      "source": [
        "### Exercicios\n",
        "\n",
        "1. Explica la diferencia entre un nombre y una variable."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "plFm3bA20p4D"
      },
      "source": [
        "## `tupla`\n",
        "\n",
        "Una `tupla` de Python es muy similar a un` lista` con una gran diferencia: es inmutable. Creamos un `tupla` usando paréntesis` () `."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xUUbIGv90p4D"
      },
      "outputs": [],
      "source": [
        "example_tuple = ('Dylan', 26, 167.6, True)\n",
        "print( example_tuple )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WbAPb_7m0p4D"
      },
      "source": [
        "Si bien podemos recuperar datos a través de la indexación (porque una tupla está ordenada), no podemos modificarla (porque una tupla es inmutable)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FSUBIT6c0p4D"
      },
      "outputs": [],
      "source": [
        "print( example_tuple[2] )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b7OYgFCX0p4D"
      },
      "outputs": [],
      "source": [
        "%%expect_exception TypeError\n",
        "\n",
        "\n",
        "example_tuple[2] = 169.3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lI5FKYmh0p4D"
      },
      "outputs": [],
      "source": [
        "%%expect_exception TypeError\n",
        "\n",
        "# deletion also fails\n",
        "del example_tuple[-1]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "naqCMv_O0p4E"
      },
      "source": [
        "Si bien, para mayor claridad, debemos encerrar las tuplas con `()`, Python asumirá que queremos una `tupla` si no usamos ningún símbolo para encerrar valores separados por comas."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tTB8Q1Xn0p4E"
      },
      "outputs": [],
      "source": [
        "another_example_tuple = 'Jill', 36, 162.3, True\n",
        "print( another_example_tuple )\n",
        "print( type(another_example_tuple) )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TjXAjoDD0p4E"
      },
      "source": [
        "Esta \"tupla\" implícita aparece con mayor frecuencia cuando se trabaja con funciones que generan múltiples salidas. Por ejemplo, podríamos tener una función que devuelva la primera y la última letra de una cadena."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qQgAMI0f0p4E"
      },
      "outputs": [],
      "source": [
        "def first_last(s):\n",
        "    return s[0], s[-1]\n",
        "\n",
        "chars = first_last('hola!')\n",
        "print( chars )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wB2J_c5w0p4E"
      },
      "source": [
        "En tales casos, a veces querremos almacenar las múltiples salidas en variables separadas."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "835Q8lDf0p4E"
      },
      "outputs": [],
      "source": [
        "first_char, last_char = first_last('hola!')\n",
        "\n",
        "print( first_char )\n",
        "print( last_char )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZohLWEGd0p4E"
      },
      "source": [
        "Esta sintaxis se llama _unpacking_. Podemos usarlo con cualquier `tuple`, ya sea que haya sido devuelto por una función o no."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0WxfgBmF0p4F"
      },
      "outputs": [],
      "source": [
        "name, age, height, has_dog = example_tuple\n",
        "\n",
        "print( name )\n",
        "print( age )\n",
        "print( height )\n",
        "print( has_dog )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XWf7vWBK0p4F"
      },
      "source": [
        "Tanto Python `list` como` tuple` están ordenados y son heterogéneos. Sin embargo, a diferencia de `list`, la` tuple` es inmutable, lo que significa que no se puede modificar después de crearla. Por lo tanto, una 'lista' podría ser mejor para representar datos que se espera que cambien en el transcurso de un programa, como una lista de tareas pendientes. Un `tuple` podría ser mejor para representar datos que se espera que sean fijos, como las respuestas de un sujeto individual a una encuesta.\n",
        "\n",
        "#### Atención\n",
        "\n",
        "Un error común que las personas cometen con la inmutabilidad y especialmente con las tuplas es asumir que las estructuras de datos dentro de la tupla son inmutables porque la tupla es inmutable. Veamos un ejemplo."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3PfCejye0p4F"
      },
      "outputs": [],
      "source": [
        "tup = tuple([[], 'a'])\n",
        "print( tup )\n",
        "tup[0].append(1)\n",
        "print( tup )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ultWOwHT0p4F"
      },
      "source": [
        "A pesar de que la tupla en sí es inmutable, no podemos cambiar los objetos exactos que contiene, esos objetos pueden mutarse si son mutables. Al igual que con la mutabilidad que aparece, esto requiere que el programador tenga cuidado y no asuma que los datos no se han modificado en algún contexto."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HbTGrQDp0p4F"
      },
      "source": [
        "## `set`\n",
        "\n",
        "Un `set` de Python también es similar a un` list`, excepto que no está ordenado. Puede almacenar datos heterogéneos y es mutable, pero ¿qué significa estar desordenado? La explicación más simple es simplemente mirar un ejemplo. Podemos crear un conjunto encerrando nuestros datos entre corchetes `{}`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XCgqn7Ts0p4F"
      },
      "outputs": [],
      "source": [
        "example_set = {'Dylan', 26, 167.6, True}\n",
        "print( example_set )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SQD9zOv30p4F"
      },
      "source": [
        "Aunque ingresamos los datos en un orden, el conjunto se imprimió en un orden diferente. Aún más importante, no podemos indexar o cortar un `conjunto`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vUgJsNVH0p4F"
      },
      "outputs": [],
      "source": [
        "%%expect_exception TypeError\n",
        "\n",
        "print( example_set[0] )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NTYKRkCF0p4F"
      },
      "source": [
        "Sin embargo, todavía podemos agregar y eliminar elementos de un conjunto."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BZOSvzhV0p4G"
      },
      "outputs": [],
      "source": [
        "print( example_set )\n",
        "print( example_set.pop() )\n",
        "print( example_set )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jJA395hm0p4G"
      },
      "outputs": [],
      "source": [
        "example_set.add('True')\n",
        "print( example_set )\n",
        "example_set.update([58.1, 'brown'])\n",
        "print( example_set )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0InYYpU30p4G"
      },
      "source": [
        "El método `add` de un` set` funciona de manera similar al método `append` de un` list`. El método `update` de un` set` funciona de manera similar al método `extend` de un` list`.\n",
        "\n",
        "_**¿Por qué es útil`set`?**_\n",
        "\n",
        "Parece extraño que podamos querer una estructura de datos no ordenada. No podemos acceder o modificar los datos a través de la indexación. ¿Cómo nos beneficia renunciar al pedido? La respuesta es que nos da flexibilidad sobre cómo se almacenan los datos en la memoria, y esa flexibilidad puede hacer que la recuperación de datos sea mucho más rápida.\n",
        "\n",
        "Imagina que tenemos diez cajas y diez montones de dinero. Ponemos los diez montones de dinero en las diez cajas. Ahora digamos que queremos encontrar la caja que tiene \\$ 5.37 en ella. No sabemos qué casilla es esta, así que comenzamos con la primera casilla y comprobamos. Si no está en el primer cuadro, pasamos al segundo cuadro. Seguimos marcando casillas hasta que lo encontramos. Esto podría tomar un tiempo.\n",
        "\n",
        "![list_illustration](https://github.com/rubuntu/uaa-417-sistemas-de-gestion-de-bases-de-datos-avanzados/blob/main/images/list_illustration.png?raw=1)\n",
        "\n",
        "Ahora imagina que tenemos los mismos diez montones de dinero, pero tenemos 31 cajas. En lugar de poner en orden cada pila de dinero en las cajas, en lugar de poner cada pila en una caja basada en la cantidad de dinero en la pila. Primero, multiplicamos la cantidad de dinero por 100 y luego tomamos la división del módulo por 31. Esto da el número de la caja en la que deberíamos poner el montón de dinero."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-8Tdw9e-0p4G"
      },
      "outputs": [],
      "source": [
        "piles = [2.83, 8.23, 9.38, 10.23, 25.58, 0.42, 5.37, 28.10, 32.14, 7.31]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Q0HUnl-y0p4G"
      },
      "outputs": [],
      "source": [
        "def hash_function(x):\n",
        "    return int(x*100 % 31)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5dWs_S6f0p4G"
      },
      "outputs": [],
      "source": [
        "map(hash_function, piles)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1srm74sI0p4G"
      },
      "source": [
        "Ahora digamos que queremos encontrar la caja con \\$ 5.37 en ella. No tenemos que buscar en cuadro tras cuadro. Podemos calcular:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UzxsD_8r0p4H"
      },
      "outputs": [],
      "source": [
        "print( int(5.37 * 100 % 31) )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VnyReOCM0p4H"
      },
      "source": [
        "![hash_illustration](https://github.com/rubuntu/uaa-417-sistemas-de-gestion-de-bases-de-datos-avanzados/blob/main/images/hash_illustration.png?raw=1)\n",
        "\n",
        "La casilla número 10 contiene la pila \\$ 5.37.\n",
        "\n",
        "Esta técnica de asignación de cajas (es decir, memoria) basada en el objeto que contiene se llama **hashing**. Hace que la búsqueda de datos sea muy rápida (como hemos ilustrado), pero al costo de aumentar la asignación de memoria (necesitábamos más cajas). También significa que no podemos asignar un orden a los objetos ya que están almacenados en la memoria.\n",
        "\n",
        "Hashing también pone dos restricciones principales en el `conjunto`. En primer lugar, los objetos en un `conjunto` deben ser inmutables. Si un objeto cambiara, su posición en la memoria ya no correspondería con su **hash**. En segundo lugar, los objetos en un `conjunto` deben ser únicos. Los objetos idénticos terminan con el mismo hash. Como no podemos almacenar varios objetos en la misma porción de memoria, simplemente descartamos cualquier duplicado.\n",
        "\n",
        "Esta segunda restricción significa que podemos usar un `set` para determinar fácilmente los objetos únicos en una` list` o `tuple`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "maozmtld0p4H"
      },
      "outputs": [],
      "source": [
        "print( set([23, 609, 348, 10, 5, 23, 340, 82]) )\n",
        "print( set(('a', 'b', 'q', 'c', 'c', 'd', 'r', 'a')) )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n8w8Lj6-0p4H"
      },
      "source": [
        "Debido a que la búsqueda de datos es muy simple en un 'conjunto', también son muy útiles para hacer comparaciones entre colecciones de datos."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gYoKwWf30p4H"
      },
      "outputs": [],
      "source": [
        "student_a_courses = {'history', 'english', 'biology', 'theatre'}\n",
        "student_b_courses = {'biology', 'english', 'mathematics', 'computer science'}\n",
        "\n",
        "print( student_a_courses.intersection(student_b_courses) )\n",
        "print( student_a_courses.union(student_b_courses) )\n",
        "print( student_a_courses.difference(student_b_courses) )\n",
        "print( student_b_courses.difference(student_a_courses) )\n",
        "print( student_a_courses.symmetric_difference(student_b_courses) )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yqDf5kvA0p4H"
      },
      "source": [
        "![set_operations](https://github.com/rubuntu/uaa-417-sistemas-de-gestion-de-bases-de-datos-avanzados/blob/main/images/set_operations.png?raw=1)\n",
        "\n",
        "### Ejercicios\n",
        "\n",
        "1. ¿Cuándo debo usar un `set` en lugar de` list`?\n",
        "2. ¿Cuál es un ejemplo de un problema donde un `conjunto` podría ser parte de la solución?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N_midQSD0p4H"
      },
      "source": [
        "# dict\n",
        "\n",
        "Para entender el `dict` de Python, comencemos de nuevo con la 'lista' de Python."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pL8kENL10p4H"
      },
      "outputs": [],
      "source": [
        "me = ['Sam', 26, 167.5, 56.5, 'brown', 'brown', True]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EL5PnjRv0p4H"
      },
      "source": [
        "Esta `lista 'me describe: mi nombre, mi edad, mi altura (en centímetros), mi peso (en kilogramos), el color de mi cabello, el color de mis ojos y si tengo un perro o no. Sabemos que podemos acceder a esta información individualmente por índice."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "k0Amljgb0p4H"
      },
      "outputs": [],
      "source": [
        "print( 'My name is %s' % me[0] )\n",
        "print( 'I have %s hair' % me[4] )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hnlUnHma0p4I"
      },
      "source": [
        "Sería fácil confundirse acerca de qué datos son cuáles (por ejemplo, ¿qué ''marrón'' es el color del cabello y cuál es el color de los ojos?), O dónde debería encontrarlo (¿la edad siempre estará en el índice 1?) .\n",
        "\n",
        "Una mejor solución sería una estructura de datos donde podríamos indexar utilizando valores significativos. Por ejemplo, en lugar de usar `me[0]` para recuperar `Dylan`, podría usar` me['name']`. En lugar de que el color del cabello sea `me[4]`, podría ser `me['hair']`. Esta característica es la característica central del `dict` de Python."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "X8ME7n3Q0p4I"
      },
      "outputs": [],
      "source": [
        "me_dict = {'name': 'Dylan', 'age': 26, 'height': 167.5, 'weight': 56.5, 'hair': 'brown', 'eyes': 'brown', 'has dog': True}\n",
        "\n",
        "print( 'My name is %s' % me_dict['name'] )\n",
        "print( 'I have %s hair' % me_dict['hair'] )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q0ryL0aO0p4I"
      },
      "source": [
        "En lugar de llamar a \"nombre\" y \"cabello\" el índice, los llamamos **clave**. Cada clave está asociada con un **valor** en un **par clave-valor**. Podemos ver los pares clave-valor en la sintaxis `{}` utilizada para crear un `dict`. Cada par clave-valor está separado por una coma, y dentro de un par, la clave y el valor están separados por dos puntos `:`.\n",
        "\n",
        "### Ejercicios\n",
        "1. ¿Cuándo podría ser más útil un `dict` que un` list`?\n",
        "2. Compare la flexibilidad de un `dict` que contiene otro objeto` dict` con el de una matriz multidimensional."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5HdszKez0p4I"
      },
      "source": [
        "### `zip`\n",
        "\n",
        "La función `zip` puede ser muy útil para crear un` dict`. Volvamos a la `lista` que hicimos antes de que contenga todos los valores que me describen. Haremos una segunda 'lista' que contiene todas las claves que desearíamos para poner estos valores en un diccionario"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nfPfVqmL0p4I"
      },
      "outputs": [],
      "source": [
        "value_list = me\n",
        "key_list = ['name', 'age', 'height', 'weight', 'hair', 'eyes', 'has dog']\n",
        "\n",
        "print( value_list )\n",
        "print( key_list )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ULh6Ql0U0p4I"
      },
      "source": [
        "Actualmente tenemos dos listas: una de valores y una de claves. No tienen ninguna relación entre sí dentro de Python, pero podemos ver que pertenecen lógicamente juntos. ¿Cómo los combinamos en Python? Usando la función `zip`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FHMFdKxh0p4I"
      },
      "outputs": [],
      "source": [
        "key_value_pairs = zip(key_list, value_list)\n",
        "print( key_value_pairs )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ihuqEZIB0p4I"
      },
      "source": [
        "Ahora tenemos una lista de tuplas. Interpretamos el primer elemento de cada tupla como una clave y el segundo elemento como un valor. Podemos convertir esta lista de tuplas directamente en un `dict`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AMZqJtkR0p4J"
      },
      "outputs": [],
      "source": [
        "me_dict = dict(key_value_pairs)\n",
        "print( me_dict )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-A0chMh20p4L"
      },
      "source": [
        "Es posible que hayas notado que aunque nuestra lista de tuplas comenzó con `('name', 'Dylan')`, cuando imprimimos `me_dict` comenzó con` 'eyes': 'brown'`. Si adivinaste que esto significa que un `dict` no está ordenado, ¡estás en lo correcto! Las teclas están en hash para asignar pares clave-valor a la memoria. Por lo tanto, las claves deben ser inmutables y únicas, similares a los elementos de un 'conjunto'. Sin embargo, los valores no tienen estas restricciones."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GtrTJ1OQ0p4L"
      },
      "outputs": [],
      "source": [
        "%%expect_exception TypeError\n",
        "\n",
        "# this doesn't work\n",
        "invalid_dict = {[1, 5]: 'a', 5: 23}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EEpJPYd40p4L"
      },
      "outputs": [],
      "source": [
        "# but this does\n",
        "valid_dict = {(1, 5): 'a', 5: [23, 6]}\n",
        "print( valid_dict )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0MeN-eSs0p4L"
      },
      "source": [
        "El `dict` también es mutable. Podemos agregar nuevos pares clave-valor por simple asignación."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KKprbgsI0p4L"
      },
      "outputs": [],
      "source": [
        "print( me_dict )\n",
        "me_dict['favorite book'] =  'The Little Prince'\n",
        "print( me_dict )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f-5ufYyk0p4L"
      },
      "source": [
        "También podemos usar `update`, similar a la forma en que lo usamos para un` set`, excepto ahora con pares clave-valor."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Vtgd306d0p4L"
      },
      "outputs": [],
      "source": [
        "print( me_dict )\n",
        "me_dict.update({'favorite color': 'orange', 'siblings': 3, 'nieces/nephews': 3})\n",
        "print( me_dict )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L-URtAk80p4L"
      },
      "source": [
        "Podemos reemplazar o eliminar pares clave-valor del `dict`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ia1yjmVy0p4M"
      },
      "outputs": [],
      "source": [
        "print( me_dict )\n",
        "me_dict['nieces/nephews'] = 4\n",
        "print( me_dict )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PaqB-fiS0p4M"
      },
      "outputs": [],
      "source": [
        "del me_dict['favorite book']\n",
        "print( me_dict )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "si2I5c4T0p4M"
      },
      "outputs": [],
      "source": [
        "print( me_dict.pop('siblings') )\n",
        "print( me_dict )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gjRuMSI10p4M"
      },
      "source": [
        "Debido a que el `dict` usa hash, la búsqueda es muy rápida (como en` set`). A veces, los diccionarios se denominan **tablas de búsqueda** o **tablas hash**. Es increíblemente útil para referenciar datos a través de claves significativas. Mientras que los datos en un `dict` no están ordenados, permanecen organizados por las claves. Podemos recuperar una lista de las claves y los valores directamente, o como pares clave-valor, utilizando los métodos apropiados de `dict`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ar6f0z9G0p4M"
      },
      "outputs": [],
      "source": [
        "print( me_dict.keys() )\n",
        "print( me_dict.values() )\n",
        "print( me_dict.items() )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vvQqqvA00p4M"
      },
      "source": [
        "## Cambio a otra estructura de datos\n",
        "Cada uno de los contenedores que hemos introducido tiene diferentes propiedades y características. A veces querremos cambiar una estructura de datos a otra para aprovechar estas diferencias. Ya hemos visto algunos métodos para transformar un `dict` en una` lista` de `tuple`s o viceversa. Podemos transformar fácilmente entre `list`,` tuple` y `set`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2-oNywaT0p4M"
      },
      "outputs": [],
      "source": [
        "example_list = ['a', 'b', 23, 10, True, 'a', 10]\n",
        "example_tuple = tuple(example_list)\n",
        "example_set = set(example_tuple)\n",
        "example_list = list(example_set)\n",
        "\n",
        "print( example_tuple )\n",
        "print( example_set )\n",
        "print( example_list ) # note we lost the duplicates because of set"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DkvrawrF0p4M"
      },
      "source": [
        "## Buscar\n",
        "\n",
        "Discutimos la idea de buscar datos en nuestras estructuras de datos cuando describimos lo que hace que `set` (y` dict`) sean tan especiales. ¿Cómo se ve la búsqueda en Python? Buscamos datos usando la palabra clave `in`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZvqcJZI90p4N"
      },
      "outputs": [],
      "source": [
        "print( example_list )\n",
        "print( 'a' in example_list )\n",
        "print( 'c' in example_list )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ml5f3xYv0p4N"
      },
      "source": [
        "Cuando se trata de un `dict`, podemos buscar claves, pero no valores."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "canLPvmW0p4N"
      },
      "outputs": [],
      "source": [
        "print( me_dict )\n",
        "print( 'hair' in me_dict )\n",
        "print( 'has cat' in me_dict )\n",
        "print( 'brown' in me_dict )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_LkEB9vc0p4N"
      },
      "source": [
        "La búsqueda de claves es importante en los diccionarios para que no intentemos recuperar accidentalmente un par clave-valor que no existe."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fEddl6uT0p4N"
      },
      "outputs": [],
      "source": [
        "%%expect_exception KeyError\n",
        "\n",
        "print( me_dict['has cat'] )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "y0FF43m70p4N"
      },
      "outputs": [],
      "source": [
        "if 'has dog' in me_dict:\n",
        "    print( 'Has dog: %s' % me_dict['has dog'] )\n",
        "else:\n",
        "    print( None )\n",
        "\n",
        "if 'has cat' in me_dict:\n",
        "    print( 'Has cat: %s' % me_dict['has cat'] )\n",
        "else:\n",
        "    print( None )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RpT0i1000p4N"
      },
      "outputs": [],
      "source": [
        "# Puede usar el método get para los mismos resultados.\n",
        "\n",
        "print( 'Has dog: %s' % me_dict.get('has dog') )\n",
        "print( 'Has cat: %s' % me_dict.get('has cat') )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "89_oVqxh0p4O"
      },
      "source": [
        "Podemos imaginar muchas situaciones donde la búsqueda es útil. ¿Está un país en el conjunto de lugares que se van a ver afectados por una sequía? ¿Hay alguna tarea en mi lista de tareas pendientes? ¿Ya se ha tomado este nombre de usuario y, de ser así, cuál es la contraseña coincidente (aquí sería útil un `dict`)?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q_YX5bsY0p4O"
      },
      "source": [
        "## Ordenamiento\n",
        "\n",
        "Dado que una 'tupla' es inmutable, ¿podemos ordenarla? ¿O es eso una mutación? ¿Qué significaría ordenar un `set` o un` dict`, que no tiene orden?\n",
        "\n",
        "Fuera de las estructuras de datos que hemos estudiado hasta ahora, solo `list` tiene un método` sort`. Sin embargo, Python también tiene una función `sorted`, que creará una \"lista\" ordenada a partir de otras estructuras de datos. Por defecto, `sorted` aplicado a un` dict` hace una `lista` de claves ordenadas. Debemos usar el método `items` si queremos que nuestra salida sean pares clave-valor."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1h2BEIRj0p4O"
      },
      "outputs": [],
      "source": [
        "print( sorted(me_dict.items()) )\n",
        "print( sorted(me_dict) )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mwCtBfmU0p4O"
      },
      "source": [
        "## Iteración\n",
        "\n",
        "Como ya hemos visto en algunos ejemplos, a menudo será útil recorrer una estructura de datos, ya sea para ejecutar una tarea basada en la información contenida o para transformar o analizar un conjunto de datos. La mayoría de las veces usaremos bucles `for` para iterar sobre estructuras de datos. Con una `list`,` tuple` o `set` los elementos del contenedor se devuelven uno tras otro. Con un `dict` las cosas son un poco más complicadas: ¿queremos iterar sobre claves, valores o pares clave-valor?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qPN4dSH70p4O"
      },
      "outputs": [],
      "source": [
        "# by default we iterate over keys of a dict\n",
        "for k in me_dict:\n",
        "    print( k )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ypp2hFbW0p4O"
      },
      "outputs": [],
      "source": [
        "# to iterate over values...\n",
        "for v in me_dict.values():\n",
        "    print( v )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sfUw4NGN0p4O"
      },
      "outputs": [],
      "source": [
        "# or to iterate over key-value pairs...\n",
        "for k, v in me_dict.items():\n",
        "    print( '%s: %s' % (k, v) )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VfUN_oXv0p4O"
      },
      "source": [
        "¡Note que usamos `tuple` desempaquetando en el bucle` for` en el último ejemplo!\n",
        "\n",
        "### Comprensiones\n",
        "\n",
        "Python tiene una sintaxis especial llamada _comprensión_ para combinar iteración con la creación de una estructura de datos. Es esencialmente un bucle 'for' envuelto en los corchetes apropiados para crear la estructura de datos."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KsM4g6-w0p4O"
      },
      "outputs": [],
      "source": [
        "squares = [x**2 for x in range(10)]\n",
        "square_lut = {x: x**2 for x in range(10)}\n",
        "\n",
        "print( squares )\n",
        "print( square_lut )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_7KSV6Nb0p4P"
      },
      "source": [
        "Las comprensiones son muy útiles para hacer transformaciones simples en estructuras de datos. Por ejemplo, tal vez estamos escribiendo una función que analizará `me_dict`. Podría ser útil tener un `dict` de los tipos de datos de los valores en` me_dict` para que sepamos qué esperar como entrada."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AakFiuxE0p4P"
      },
      "outputs": [],
      "source": [
        "me_dict_dtypes = {k: type(v) for k, v in me_dict.items()}\n",
        "print( me_dict_dtypes )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4cWTvFRt0p4P"
      },
      "source": [
        "Las comprensiones también hacen que el código sea más legible. Compare la implementación del bucle `for` de` square_lut` con la comprensión."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3saiEcMQ0p4P"
      },
      "outputs": [],
      "source": [
        "square_lut = {}\n",
        "for x in range(10):\n",
        "    square_lut[x] = x**2\n",
        "\n",
        "print( square_lut )\n",
        "\n",
        "square_lut = {x: x**2 for x in range(10)}\n",
        "\n",
        "print( square_lut )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FkwFlHio0p4P"
      },
      "source": [
        "## Colecciones\n",
        "Como se mencionó anteriormente, la biblioteca estándar de Python tiene un módulo de \"colecciones\" que contiene una variedad de contenedores extremadamente útiles, especialmente para implementar algoritmos, ya que tienden a estar bastante optimizados. Son un poco más especializados que los contenedores generales de Python.\n",
        "\n",
        "Los contenedores son:\n",
        "\n",
        "- `nameduuple`\n",
        "- `deque`\n",
        "- `Contador`\n",
        "- `OrderedDict`\n",
        "- `defaultdict`\n",
        "\n",
        "\n",
        "### `namedtuple`\n",
        "\n",
        "El `namedtuple` genera una clase que es similar a una tupla, pero tiene entradas con nombre. Vamos a hacer uno para un vector tridimensional que tiene los campos `x, y, z`. Si usamos el indicador `verbose` podemos ver el código Python generado"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zG9Pvv130p4P"
      },
      "outputs": [],
      "source": [
        "from collections import namedtuple\n",
        "#Vector3 = namedtuple('Vector', ['x', 'y', 'z'], verbose=True)\n",
        "Vector3 = namedtuple('Vector', ['x', 'y', 'z'])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CcU29LMp0p4P"
      },
      "source": [
        "Ahora podemos acceder a los elementos de los elementos de la tupla por su nombre."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ulnMf23l0p4P"
      },
      "outputs": [],
      "source": [
        "vec = Vector3(1,2,3)\n",
        "vec.x, vec.y, vec.z"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nSQ0blXd0p4P"
      },
      "source": [
        "En este punto, es posible que se pregunte por qué no podemos usar un diccionario (o algún otro objeto). Una buena razón es la inmutabilidad."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eq5hRPaw0p4Q"
      },
      "outputs": [],
      "source": [
        "%%expect_exception AttributeError\n",
        "\n",
        "vec.x = 5"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gLPEUNnI0p4Q"
      },
      "source": [
        "Otra buena razón es que se comportará como una tupla cuando se pasa a una función."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gxjm1g4i0p4Q"
      },
      "outputs": [],
      "source": [
        "def tfunc(a,b,c):\n",
        "    print( a,b,c )\n",
        "tfunc(*vec)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vmi7DcXj0p4Q"
      },
      "source": [
        "`namedtuple` es una excelente manera de crear código de auto-documentación sin casi ningún costo de memoria.\n",
        "\n",
        "### `deque`\n",
        "Un `deque` es como una cola o una pila, excepto que funciona en ambos sentidos. Podemos pensar en un `deque` como una lista en la que generalmente nos importa trabajar con los extremos de la lista. El `deque` está optimizado para el rendimiento de $O(1)$ tanto para agregar como para eliminar elementos de los extremos de la estructura, mientras que una `lista` general será $O(N)$ para las operaciones al principio de la lista.\n",
        "\n",
        "Veamos un ejemplo."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "m3A0Zo5J0p4Q"
      },
      "outputs": [],
      "source": [
        "from collections import deque\n",
        "\n",
        "d = deque([2,3,4,5])\n",
        "print( d )\n",
        "d.append(10)\n",
        "print( d )\n",
        "d.appendleft(20)\n",
        "print( d )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mHH70iS30p4Q"
      },
      "source": [
        "Determinemos cuanto tiempo lleva realizar la misma operación agregando elementos a la izquierda de un `deque` y un `list`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tpIV8hgc0p4Q"
      },
      "outputs": [],
      "source": [
        "%%timeit\n",
        "l_ = list()\n",
        "for i in range(40000):\n",
        "    l_.insert(0, i)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oRuYcrr70p4Q"
      },
      "outputs": [],
      "source": [
        "%%timeit\n",
        "d = deque()\n",
        "for i in range(40000):\n",
        "    d.appendleft(i)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xeIVC0PZ0p4R"
      },
      "outputs": [],
      "source": [
        "d = deque()\n",
        "l_ = list()\n",
        "for i in range(40000):\n",
        "    d.appendleft(i)\n",
        "    l_.insert(0, i)\n",
        "\n",
        "list(d) == l_"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_jiwfZ630p4R"
      },
      "source": [
        "El `deque` es un orden de magnitud más rápido que el` list`, pero contiene los mismos valores. Por lo tanto, para algunas tareas especializadas, puede ser una mejora masiva.\n",
        "\n",
        "### `Counter`\n",
        "El 'contador' es un objeto extremadamente útil. Cuenta los elementos en algunos iterables y devuelve una estructura similar a un diccionario que contiene el recuento de cada elemento. Veamos un ejemplo."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3EBI1Cu00p4R"
      },
      "outputs": [],
      "source": [
        "from collections import Counter\n",
        "ele = ['a','b','a','c','b','b','d']\n",
        "c = Counter(ele)\n",
        "print( c )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sJ60jWoO0p4R"
      },
      "source": [
        "Podemos encontrar el número de recuentos de un elemento utilizando la misma sintaxis `get` que un diccionario. Qué pasa cuando accedemos a un elemento que no cuenta."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wYK8SSiB0p4R"
      },
      "outputs": [],
      "source": [
        "c['a'], c['z']"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g7xbp-Du0p4R"
      },
      "source": [
        "También podemos encontrar los elementos más comunes."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Awo1IW9P0p4R"
      },
      "outputs": [],
      "source": [
        "c.most_common(2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zaQ3Uun_0p4R"
      },
      "source": [
        "### `OrderedDict`\n",
        "\n",
        "Un diccionario de Python no tiene un orden natural, pero a veces es útil tener las propiedades de un diccionario como $O (1)$ acceso a artículos con un pedido. Un `OrderedDict` es exactamente como un` dict`, pero recuerda el orden de inserción de las claves.\n",
        "\n",
        "### `defaultdict`\n",
        "\n",
        "Un paradigma común de un diccionario es manejar el caso de una clave faltante. Digamos que tomamos el ejemplo contrario y tratamos de implementar el nuestro. Queremos hacer algo como crear un diccionario y cada vez que encontremos una clave queremos agregar uno al valor existente en esa clave y, si no hemos visto esa clave, queremos crearla e inicializarla a cero antes de agregarla. eso. Una forma de hacer esto es:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yAPow0jX0p4S"
      },
      "outputs": [],
      "source": [
        "def count(x):\n",
        "    count_dict = {}\n",
        "    for ele in x:\n",
        "        if ele in count_dict.keys():\n",
        "            count_dict[ele] += 1\n",
        "        else:\n",
        "            count_dict[ele] = 1\n",
        "    return count_dict\n",
        "count(ele)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cd635rb90p4S"
      },
      "source": [
        "Este es un caso tan común que tenemos el `defaultdict` para resolverlo. El `defaultdict` toma una función _factory predeterminada, que puede ser tan simple como simplemente devolver 0, lo que produce un valor cuando la clave no se ha visto antes. Podemos implementar en el mismo algoritmo anterior de una manera un poco más simple"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YDoHqMBO0p4S"
      },
      "outputs": [],
      "source": [
        "from collections import defaultdict\n",
        "def count_default(x):\n",
        "    count_dict = defaultdict(int)\n",
        "    for ele in x:\n",
        "        count_dict[ele] += 1\n",
        "    return count_dict\n",
        "count_default(ele)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qv40Xrzl0p4S"
      },
      "source": [
        "## Algunos temas que no hemos discutido, pero que hemos usado:\n",
        "- `map`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dtr2cZff0p4S"
      },
      "source": [
        "## Preguntas:\n",
        "- ¿Son inmutables los strings? ¿Se ordenan los strings? ¿Podemos cortar los strings?"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "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.14"
    },
    "varInspector": {
      "cols": {
        "lenName": 16,
        "lenType": 16,
        "lenVar": 40
      },
      "kernels_config": {
        "python": {
          "delete_cmd_postfix": "",
          "delete_cmd_prefix": "del ",
          "library": "var_list.py",
          "varRefreshCmd": "print(var_dic_list())"
        },
        "r": {
          "delete_cmd_postfix": ") ",
          "delete_cmd_prefix": "rm(",
          "library": "var_list.r",
          "varRefreshCmd": "cat(var_dic_list()) "
        }
      },
      "types_to_exclude": [
        "module",
        "function",
        "builtin_function_or_method",
        "instance",
        "_Feature"
      ],
      "window_display": false
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}