9.Manejando conjuntos en python (Sets).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Combinando estructuras de datos:\n",
    "\n",
    "### Ejercicio: \n",
    "\n",
    "¿Cómo representaría la siguiente tabla de datos utilizando un diccionario de diccionarios? \n",
    "\n",
    "![](images/tablita.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una opción puede ser:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'sam': {'Nombre': 'Sam Smith', 'Genero': 'M', 'Ocupación': 'Gato', 'Ciudad': 'Bogotá'}, 'lobo': {'Nombre': 'Lobo W', 'Genero': 'F', 'Ocupación': 'Perro', 'Ciudad': 'Bogotá'}, 'marvin': {'Nombre': 'Marvin', 'Genero': 'M', 'Ocupación': 'Loro', 'Ciudad': 'Cali'}, 'hussain': {'Nombre': 'Hussain', 'Genero': 'F', 'Ocupación': 'Hamster', 'Ciudad': 'Bogotá'}}\n"
     ]
    }
   ],
   "source": [
    "print(mascotas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'hussain': {'Ciudad': 'Bogotá',\n",
      "             'Genero': 'F',\n",
      "             'Nombre': 'Hussain',\n",
      "             'Ocupación': 'Hamster'},\n",
      " 'lobo': {'Ciudad': 'Bogotá',\n",
      "          'Genero': 'F',\n",
      "          'Nombre': 'Lobo W',\n",
      "          'Ocupación': 'Perro'},\n",
      " 'marvin': {'Ciudad': 'Cali',\n",
      "            'Genero': 'M',\n",
      "            'Nombre': 'Marvin',\n",
      "            'Ocupación': 'Loro'},\n",
      " 'sam': {'Ciudad': 'Bogotá',\n",
      "         'Genero': 'M',\n",
      "         'Nombre': 'Sam Smith',\n",
      "         'Ocupación': 'Gato'}}\n"
     ]
    }
   ],
   "source": [
    "import pprint\n",
    "\n",
    "pprint.pprint(mascotas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imprimir la ocupación de Sam:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Gato'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mascotas['sam']['Ocupación']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De donde es marvin?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A qué se dedica hussain?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Liste las mascotas de Bogotá:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Nombre': 'Sam Smith', 'Genero': 'M', 'Ocupación': 'Gato', 'Ciudad': 'Bogotá'}\n",
      "{'Nombre': 'Lobo W', 'Genero': 'F', 'Ocupación': 'Perro', 'Ciudad': 'Bogotá'}\n",
      "{'Nombre': 'Hussain', 'Genero': 'F', 'Ocupación': 'Hamster', 'Ciudad': 'Bogotá'}\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Liste las mascotas de Género M:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Nombre': 'Sam Smith', 'Genero': 'M', 'Ocupación': 'Gato', 'Ciudad': 'Bogotá'}\n",
      "{'Nombre': 'Marvin', 'Genero': 'M', 'Ocupación': 'Loro', 'Ciudad': 'Cali'}\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manejando Conjuntos en Python\n",
    "\n",
    "Los conjuntos en python pueden ser muy útiles para eliminar datos duplicados. Si se tiene una lista de nombres que puede estar duplicada, basta con convertirla en conjunto para eliminar los datos duplicados. Esta estructura también está optimizada para buscar datos pues las listas realizan una búsqueda secuencial. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para definir el conjunto de las vocales:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'i', 'u', 'o', 'e', 'a'}\n"
     ]
    }
   ],
   "source": [
    "vocales = {'a', 'e', 'i', 'o', 'u', 'a', 'a', 'o', 'e'}\n",
    "print(vocales)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los datos no se almacenan necesariamente en orden. A diferencia de un diccionario se tienen datos no ítems de la forma ```llave:valor```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible ordenar un conjunto así:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'e', 'i', 'o', 'u']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(vocales)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pueden crear conjuntos a partir de strings, listas o tuplas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'i', 'u', 'o', 'e', 'a'}\n"
     ]
    }
   ],
   "source": [
    "str_vocales = 'aaaeeeeioooouooooi'\n",
    "vocals = set(str_vocales)\n",
    "print(vocals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'i', 'u', 'o', 'e', 'a'}\n"
     ]
    }
   ],
   "source": [
    "l_vocals = ['a', 'e', 'i', 'o', 'u', 'i']\n",
    "vocalsl = set(l_vocals)\n",
    "print(vocalsl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'i', 'u', 'o', 'e', 'a'}\n"
     ]
    }
   ],
   "source": [
    "t_vocals = ('a', 'e', 'i', 'o', 'u', 'i')\n",
    "vocalst = set(t_vocals)\n",
    "print(vocalsl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible utilizar el operador ```in``` para saber si un elemento se encuentra en el conjunto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' in vocals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unión de conjuntos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible unir dos conjuntos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'u', 'e', 'o', 'a', 'd', 'n', 't', 'm', 'i', 'x', 'l', 'c', 's', 'r', 'g'}\n"
     ]
    }
   ],
   "source": [
    "seta = set('murcielago')\n",
    "setb = set('externocleidomastoideo')\n",
    "setc = seta.union(setb)\n",
    "print(setc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'u', 'e', 'o', 'a', 'd', 'n', 't', 'm', 'i', 'x', 'l', 'c', 's', 'r', 'g'}\n"
     ]
    }
   ],
   "source": [
    "setc = seta | setb\n",
    "print(setc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diferencia de conjuntos\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Permite examinar los datos que están en un conjunto de palabras que no están en otro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "stop_wordsA = {'el', 'un', 'la', 'los'}\n",
    "stop_wordsB = {'un', 'una', 'unos', 'el'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para determinar los elementos que están en stop_wordsA que no están en stop_wordsB basta con:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'la', 'los'}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stop_wordsA - stop_wordsB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'la', 'los'}"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stop_wordsA.difference(stop_wordsB)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para determinar los elementos que están en stop_wordsB que no están en stop_wordsA basta con:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'una', 'unos'}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stop_wordsB - stop_wordsA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'una', 'unos'}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stop_wordsB.difference(stop_wordsA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para determinar los elementos que tienen en común los conjuntos de stop_words:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'el', 'un', 'una', 'unos'}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stop_wordsB.intersection(stop_wordsB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'el', 'un'}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stop_wordsB & stop_wordsA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La diferencia simétrica consiste en encontrar elementos que están en la unión de dos conjuntos pero no en la intersección"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'la', 'los', 'una', 'unos'}"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stop_wordsB ^ stop_wordsA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ## Intersección de n Conjuntos:\n",
    "\n",
    "Se tienen n conjuntos. Se desea calcular la intersección de dichos conjuntos. \n",
    "\n",
    "### Entrada:\n",
    "La entrada consta de un número n > 1 de conjuntos seguido por los elementos separados por espacio.\n",
    "\n",
    "### Salida:\n",
    "Muestre en forma de diccionario la intersección de los n conjuntos ó ```empty set``` si la intersección es un conjunto vacío.\n",
    "\n",
    "### Ejemplo 1\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>Input</td><td>Output</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>3<br>\n",
    "            1 2 2 3 4<br>\n",
    "            2 2 3 5 6<br>\n",
    "            1 3 2 2 6<br>\n",
    "        </td><td>2 3\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "\n",
    "### Ejemplo 2\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>Input</td><td>Output</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>3<br>\n",
    "            1 1<br>\n",
    "            2 2<br>\n",
    "            3 3<br>\n",
    "        </td><td>empty set\n",
    "    </tr>\n",
    "</table>\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "a b c d e 5\n",
      "a 5 b 4 c 6 \n",
      "c 5 a b c d\n",
      "5 a b c\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Barry, P. (2016). Head First Python: A Brain-Friendly Guide. \" O'Reilly Media, Inc.\".\n",
    "\n",
    "Das, B. N. (2017). Learn Python in 7 Days. Packt Publishing Ltd.\n",
    "\n",
    "https://www.geeksforgeeks.org/intersection-of-n-sets/\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}