{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Colecciones\n",
    "---------------------------------\n",
    "\n",
    "En Python: Tipos básicos vimos los números, las cadenas de texto y los booleanos. En esta lección veremos algunos tipos de colecciones de datos: __listas, tuplas y diccionarios__. Se les llama colecciones debido a que sirven para agrupar elementos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listas\n",
    "----------------------------\n",
    "La lista es un tipo de colección ordenada. Sería equivalente a lo que en otros lenguajes se conoce por __arrays, o vectores.__\n",
    "\n",
    "- Los elementos dentro de una lista pueden ser de cualquier tipo de dato, pueden ser de uno de los tipos de datos básicos de python, pueden ser imágenes,  archivos, otras listas, etc . . .\n",
    "- Dentro de una lista puedo tener cualquier cantidad de elementos y todos pueden ser de diferente tipo de dato.\n",
    "- Puedo agregar y eliminar elementos de la lista en cualquier momento y además modificar sus elementos cuando lo desee (a diferencia de las tuplas) esto significa que son __mutables__.\n",
    "\n",
    "Crear una lista es tan sencillo como indicar entre corchetes, y separados por comas, los valores que queremos incluir en la lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [1 , 3 , \"Hola\" , 2.12 , 3j]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 'Hola', 2.12, 3j]\n"
     ]
    }
   ],
   "source": [
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acceder a cada uno de los elementos de la lista escribiendo el nombre de la lista e indicando el índice del elemento entre corchetes. Ten en cuenta sin embargo que el índice del primer elemento de la lista es 0, y no 1 como vimos anteriormente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hola'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-cf0236d70f2a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlista\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "lista[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recordar que los índices se toman de la siguiente manera:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Alt text](../images/listas.png \"Optional title\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos modificar algun elemento de la lista usamos la asignación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 'Hola', 'Kappa', 3j]\n"
     ]
    }
   ],
   "source": [
    "lista[3] = \"Kappa\"\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al igual que las cadenas podemos usar el **slicing**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hola', 'Kappa']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[2:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas también pueden contener otras listas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = [2 , 5 , [2, 3, 5]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 5]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test[2][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usar la función **`len()`** para obtener el tamaño de una lista: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista2 = [1, 6, 7, 8, 20 ,99]\n",
    "len(lista2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos concatenar listas como si fueran cadenas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 7, 'A', 'B', 'C']\n"
     ]
    }
   ],
   "source": [
    "xas = [1, 4, 7] + [\"A\", \"B\", \"C\"]\n",
    "print(xas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La instrucción **`del`** eliminará los valores en un índice de una lista. Todos los valores de la lista después del valor eliminado se moverán hacia arriba un índice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['gato', 'perro', 'conejo', 'cuy', 'llama']\n"
     ]
    }
   ],
   "source": [
    "animales = [\"gato\",\"perro\",\"conejo\",\"cuy\",\"llama\"]\n",
    "print(animales)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['gato', 'perro', 'cuy', 'llama']\n"
     ]
    }
   ],
   "source": [
    "del animales[2]\n",
    "print(animales)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora hagamos el ejemplo de un programa en donde ingresaremos el nombre de perros a una lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese el nombre del perro 1 (O deje en blanco para terminar):\n",
      "Diomedes\n",
      "Ingrese el nombre del perro 2 (O deje en blanco para terminar):\n",
      "Galu\n",
      "Ingrese el nombre del perro 3 (O deje en blanco para terminar):\n",
      "Thera\n",
      "Ingrese el nombre del perro 4 (O deje en blanco para terminar):\n",
      "\n",
      "El nombre de los perros son:\n",
      " Diomedes\n",
      " Galu\n",
      " Thera\n"
     ]
    }
   ],
   "source": [
    "dogNames = []\n",
    "while True:\n",
    "    print('Ingrese el nombre del perro ' + str(len(dogNames) + 1) + ' (O deje en blanco para terminar):')\n",
    "    name = input()\n",
    "    if name == '':\n",
    "        break\n",
    "    dogNames = dogNames + [name] # concatenamos\n",
    "print('El nombre de los perros son:')\n",
    "for name in dogNames:\n",
    "    print(' ' + name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puede determinar si un valor está o no en una lista con los operadores **`in`** y **`not`**. Estas expresiones se evaluarán con un valor booleano."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "girls = [\"Zasha\",\"Sofia\",\"Milagros\",\"Melissa\",\"Nadia\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Zasha\" in girls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Katherine\" in girls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Diana\" not in girls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Melissa\" not in girls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos recorrer una lista con el bucle **`for`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zasha\n",
      "Sofia\n",
      "Milagros\n",
      "Melissa\n",
      "Nadia\n"
     ]
    }
   ],
   "source": [
    "for name in girls:\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "68\n",
      "32\n"
     ]
    }
   ],
   "source": [
    "for num in [1,3,5,7,21,1,68,32]:\n",
    "    if(num%2==0):\n",
    "        print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listas por compresión\n",
    "\n",
    "Aquí veremos como generar lista y dicccionarios de manera inline en python. Se trata de una notación práctica para definir listas, sets, diccionarios.\n",
    "\n",
    "Su forma es muy parecida la del **`for in`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [k for k in range(8)]\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['0', '1', '4', '9', '16', '25']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[str(n*n) for n in range(6)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se puede aplicar filtros a la secuencia, mediante la utilización del **`if`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '9', '25', '49', '81', '121']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[str(n*n) for n in range(13) if n % 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 3, 6, 9]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list( i for i in range(0,10,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0,\n",
       " 0.1,\n",
       " 0.2,\n",
       " 0.30000000000000004,\n",
       " 0.4,\n",
       " 0.5,\n",
       " 0.6000000000000001,\n",
       " 0.7000000000000001,\n",
       " 0.8,\n",
       " 0.9]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(i*0.1 for i in range(0,10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Métodos\n",
    "\n",
    "Un método es lo mismo que una función, excepto que es \"llamado\" a un valor. Por ejemplo, si un valor de lista se almacenaba en spam, se llamaría el método de lista index() (que explicaré a continuación) en esa lista de la siguiente manera: spam.index ('hola'). La parte del método viene después del valor, separados por un punto. Cada tipo de datos tiene su propio conjunto de métodos. El tipo de datos de lista, por ejemplo, tiene varios métodos útiles para encontrar, agregar, quitar y de otra manera manipular valores en una lista."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Método `index()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "departamentos = ['Piura', 'Lambayeque', 'Lima', 'Puno']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "departamentos.index('Piura')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "departamentos.index('Lambayeque')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "'Ucayali' is not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-31-adfed6891950>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdepartamentos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Ucayali'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: 'Ucayali' is not in list"
     ]
    }
   ],
   "source": [
    "departamentos.index('Ucayali')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Método `append()` e `insert()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "ciudades = [\"Tokio\",\"Roma\",\"Berlín\",\"Moscú\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Tokio', 'Roma', 'Berlín', 'Moscú', 'París']\n"
     ]
    }
   ],
   "source": [
    "ciudades.append(\"París\")\n",
    "print(ciudades) # El método append agregará Paris al final de la lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Tokio', 'Roma', 'Berna', 'Berlín', 'Moscú', 'París']\n"
     ]
    }
   ],
   "source": [
    "ciudades.insert(2,\"Berna\")\n",
    "print(ciudades) # El método insert agregará Berna en la posicion 2 y desplazara las demás"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Método `remove()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Tokio', 'Roma', 'Berlín', 'Moscú', 'París']\n"
     ]
    }
   ],
   "source": [
    "ciudades.remove(\"Berna\")\n",
    "print(ciudades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "list.remove(x): x not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-36-e2727cf98e22>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mciudades\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Lima\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Lima no está en la lista por eso no puede removerla\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: list.remove(x): x not in list"
     ]
    }
   ],
   "source": [
    "ciudades.remove(\"Lima\") # Lima no está en la lista por eso no puede removerla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Método `sort()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 2, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "numbers = [2 ,7,1,2,6,8]\n",
    "numbers.sort()\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ana', 'camila', 'juana', 'maria']\n"
     ]
    }
   ],
   "source": [
    "names = [\"maria\",\"juana\",\"ana\",\"camila\"]\n",
    "names.sort()\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['maria', 'juana', 'camila', 'ana']\n"
     ]
    }
   ],
   "source": [
    "names.reverse()\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Método `split()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Este', 'ejemplo', 'tiene', 'cinco', 'palabras']\n"
     ]
    }
   ],
   "source": [
    "oracion = \"Este ejemplo tiene cinco palabras\"\n",
    "palabras = oracion.split()\n",
    "print(palabras)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veamos algo interesante..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 7, 2, 3, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "test = [1,3,7,2,3,6,8]\n",
    "copy_test = test\n",
    "print(copy_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué pasará si...?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 7, 2, 3, 'Hello', 8]\n"
     ]
    }
   ],
   "source": [
    "copy_test[5] = \"Hello\"\n",
    "print(copy_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 7, 2, 3, 'Hello', 8]\n"
     ]
    }
   ],
   "source": [
    "print(test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué acaba de pasar? ... NO he modificado test... D:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si hiciera lo mismo en variables su valor cambia, pero en las listas no funciona así, cuando asigna una lista a una variable, en realidad está asignando una referencia de lista a la variable. Una referencia es un valor que apunta a algún bit de datos, y una referencia de lista es un valor que apunta a una lista. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entonces como copio una lista sin alterar sus valores? La respuesta es usando el método **copy()** del módulo **copy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 5, 6, 7, 8]\n",
      "[1, 2, 4, 'Hola', 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "lista = [1,2,4,5,6,7,8]\n",
    "lista2 = copy.copy(lista)\n",
    "lista2[3] = \"Hola\"\n",
    "print(lista)\n",
    "print(lista2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuplas\n",
    "--------------------------------------\n",
    "\n",
    "Las tuplas son casi idénticas a las listas, excepto en dos formas. Pero tienen ciertas características:\n",
    "\n",
    "1.\tNo pueden añadirse elementos a una tupla. Las tuplas no tienen los métodos append ni extend.\n",
    "2.\tNo pueden eliminarse elementos de una tupla. Las tuplas no tienen los métodos remove ni pop.\n",
    "3.\tNo pueden buscarse elementos en una tupla. Las tuplas no tienen el método index.\n",
    "4.\tSe puede, no obstante, usar in para ver si un elemento existe en la tupla.\n",
    "\n",
    "**Entonces, ¿para qué sirven las tuplas?**\n",
    "\n",
    "Las tuplas son más rápidas que las listas. Si está usted definiendo un conjunto constante de valores y todo lo que va a hacer con él es recorrerla, utilice una tupla en lugar de una lista.\n",
    "¿Recuerda que dije que las claves de un diccionario pueden ser enteros, cadenas y “algunos otros tipos”? Las tuplas son uno de estos tipos. Las tuplas pueden utilizarse como claves en un diccionario, pero las listas no.\n",
    "Las tuplas se utilizan para formatear cadenas.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import rand\n",
    "values = rand(10000,4)\n",
    "lst = [list(row) for row in values]\n",
    "tup = tuple(tuple(row) for row in values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.39 ms ± 133 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit for row in lst: list(row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "861 µs ± 39.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit for row in tup: tuple(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nota**\n",
    "\n",
    "Las tuplas pueden convertirse en listas, y viceversa. La función incorporada tuple toma una lista y devuelve una tupla con los mismos elementos, y la función list toma una tupla y devuelve una lista. En la práctica, tuple congela una lista, y list descongela una tupla."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 4, 5, 8, 10)\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "tupla_test = (2,4,5,8,10)\n",
    "print(tupla_test)\n",
    "print(tupla_test[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las tuplas también pueden anidarse como las listas :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((2, 4, 5, 8, 10), (1, 2, 3, 4, 5))\n"
     ]
    }
   ],
   "source": [
    "u = (tupla_test, (1, 2, 3, 4, 5))\n",
    "\n",
    "print(u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero la principal forma en que las tuplas son diferentes de las listas es que las tuplas, como las cadenas, son **inmutables**. Las tuplas no pueden modificar sus valores, agregar o eliminar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-50-c9802ce7e10d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtupla_test\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m8\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "tupla_test[3] = 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(tupla_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diccionarios\n",
    "----------------------------\n",
    "Los diccionarios, también llamados __matrices asociativas__, deben su nombre a que son colecciones que relacionan una __clave__ y un __valor__. La principal diferencia entre los diccionarios con las tuplas y listas, es que sus valores no son accedidos a través de un índice, porque __no poseen orden__ (ya que los diccionarios se implementan como __tablas hash__), sino que mediante su clave utilizando el __operador[clave]__. Por esta misma razón es que tampoco puede aplicarse slicing sobre estas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Alt text](../images/python_dict.png \"Optional title\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre': 'Carlos', 'edad': 22, 'cursos': ['C', 'Java', 'Python']}\n"
     ]
    }
   ],
   "source": [
    "diccionario = {'nombre' : 'Carlos', 'edad' : 22, 'cursos': ['C','Java','Python'] }\n",
    "print(diccionario)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acceder al elemento de un Diccionario mediante la clave de este elemento, como veremos a continuación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Carlos\n",
      "22\n",
      "['C', 'Java', 'Python']\n"
     ]
    }
   ],
   "source": [
    "print(diccionario['nombre']) #Carlos\n",
    "print(diccionario['edad'])#22\n",
    "print(diccionario['cursos']) #['C','Java','Python']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n"
     ]
    }
   ],
   "source": [
    "print(diccionario['cursos'][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Java\n"
     ]
    }
   ],
   "source": [
    "print(diccionario['cursos'][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nombre : Carlos\n",
      "edad : 22\n",
      "cursos : ['C', 'Java', 'Python']\n"
     ]
    }
   ],
   "source": [
    "for key in diccionario:\n",
    "    print(key, \":\", diccionario[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos a programar un diccionario que tenga los cumpleaños de algunas personas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese un nombre: (deje en blanco para salir)\n",
      "Katherine\n",
      "No tengo información de: Katherine\n",
      "Cuando es su cumpleaños?\n",
      "24 de Febrero\n",
      "Base de datos de cumpleaños actualizada!\n",
      "Ingrese un nombre: (deje en blanco para salir)\n",
      "Gerson\n",
      "No tengo información de: Gerson\n",
      "Cuando es su cumpleaños?\n",
      "23 de diciembre\n",
      "Base de datos de cumpleaños actualizada!\n",
      "Ingrese un nombre: (deje en blanco para salir)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "birthdays = {'Alondra': '5 de Abril', 'Carla': '12 de Diciembre ', 'Martin': '3 de Enero'}\n",
    "while True:\n",
    "    print('Ingrese un nombre: (deje en blanco para salir)')\n",
    "    name = input()\n",
    "    if name == '':\n",
    "        break\n",
    "    if name in birthdays:\n",
    "        print(birthdays[name] + ' es el cumpleaños de ' + name)\n",
    "    else:\n",
    "        print('No tengo información de: ' + name)\n",
    "        print('Cuando es su cumpleaños?')\n",
    "        bday = input()\n",
    "        birthdays[name] = bday\n",
    "        print('Base de datos de cumpleaños actualizada!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Alondra': '5 de Abril', 'Carla': '12 de Diciembre ', 'Martin': '3 de Enero', 'Katherine': '24 de Febrero', 'Gerson': '23 de diciembre'}\n"
     ]
    }
   ],
   "source": [
    "print(birthdays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora vamos a usar algunos métodos interesantes en los diccionarios:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Método `values()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moscu\n",
      "Paris\n",
      "Berlín\n"
     ]
    }
   ],
   "source": [
    "capitales = {\"Rusia\":\"Moscu\",\"Francia\":\"Paris\",\"Alemania\":\"Berlín\"}\n",
    "for i in capitales.values(): # El metodo values nos lista los valores de diccionario\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Método `keys()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rusia\n",
      "Francia\n",
      "Alemania\n"
     ]
    }
   ],
   "source": [
    "for j in capitales.keys(): # el metodo keys nos lista las llaves del diccionario\n",
    "    print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Método `items()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Rusia', 'Moscu')\n",
      "('Francia', 'Paris')\n",
      "('Alemania', 'Berlín')\n"
     ]
    }
   ],
   "source": [
    "for k in capitales.items(): #el metodo items nos lista todos los items del diccionario\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Alemania\" in capitales.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Berlin\" in capitales.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora veamos unos ultimos métodos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Método `get()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Moscu'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Metodo get()\n",
    "# Recibe como parámetro una clave, devuelve el valor de la clave. Si no lo encuentra, devuelve un objeto none.\n",
    "capitales = {\"Rusia\":\"Moscu\",\"Francia\":\"Paris\",\"Alemania\":\"Berlín\"}\n",
    "capitales.get(\"Rusia\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Método `pop()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Paris'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Metodo pop()\n",
    "# Recibe como parámetro una clave, elimina esta y devuelve su valor. Si no lo encuentra, devuelve error.\n",
    "capitales.pop(\"Francia\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Rusia': 'Moscu', 'Alemania': 'Berlín'}\n"
     ]
    }
   ],
   "source": [
    "print(capitales)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Método `setdefault()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Berlín\n"
     ]
    }
   ],
   "source": [
    "# Metodo setdefault()\n",
    "# Funciona como get y tambien sirve para agregar un nuevo elemento al diccionario\n",
    "\n",
    "print(capitales.setdefault(\"Alemania\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Roma'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "capitales.setdefault(\"Italia\",\"Roma\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Rusia': 'Moscu', 'Alemania': 'Berlín', 'Italia': 'Roma'}\n"
     ]
    }
   ],
   "source": [
    "print(capitales)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplos "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese un numero entre 1 y 20: 5\n",
      "Usted ha adivinado\n",
      "Ingrese un numero entre 1 y 20: 10\n",
      "Siga intentando\n",
      "Ingrese un numero entre 1 y 20: 3\n",
      "Siga intentando\n",
      "Lista de numeros\n",
      "[16, 15, 7, 20, 7, 5, 11, 8, 2, 20]\n"
     ]
    }
   ],
   "source": [
    "# Este es un juego de advinar el numero mágico\n",
    "import random \n",
    "\n",
    "lista_numeros = [] # creamos una lista vacia\n",
    "\n",
    "for i in range(10):\n",
    "    k = random.randint(1,20)\n",
    "    lista_numeros.append(k)\n",
    "    \n",
    "\n",
    "\n",
    "intentos = 3 # numero de intentos\n",
    "\n",
    "for l in range(3):\n",
    "    entrada = int(input(\"Ingrese un numero entre 1 y 20: \"))\n",
    "    if entrada in lista_numeros:\n",
    "        print(\"Usted ha adivinado\")\n",
    "    else:\n",
    "        print(\"Siga intentando\")\n",
    "\n",
    "print(\"Lista de numeros\")\n",
    "print(lista_numeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ahora veamos como convertir un numero decimal a hexadecimal usando diccionarios:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese el numerohexadecimal: 8F3D35\n",
      "100011110011110100110101\n"
     ]
    }
   ],
   "source": [
    "hexToBinary = {'0':'0000', '1':'0001', '2':'0010',\n",
    "               '3':'0011', '4':'0100', '5':'0101',\n",
    "               '6':'0110', '7':'0111', '8':'1000',\n",
    "               '9':'1001', 'A':'1010', 'B':'1011',\n",
    "               'C':'1100', 'D':'1101', 'E':'1110',\n",
    "               'F':'1111'}\n",
    "\n",
    "\n",
    "binary = \"\"\n",
    "number = input(\"Ingrese el numerohexadecimal: \")\n",
    "\n",
    "for digit in number:\n",
    "    binary = binary + hexToBinary[digit]\n",
    "\n",
    "print(binary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conjuntos\n",
    "\n",
    "Por último tambien tenemos a los conjuntos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = set([1, 2, 3, 1])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = {2,3,4,5,6}\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos realizar operaciones entre conjuntos como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.union(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.union(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a | b # Podemos usar tambien esta notación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3}"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.intersection(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3}"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.intersection(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3}"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a & b # Notacion para interseccion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos agregar elementos con el método __add__ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 322}"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.add(322)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5, 6}"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.difference(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 322}"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.difference(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 322}"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a - b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.symmetric_difference(b) == b.symmetric_difference(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 4, 5, 6, 322}"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a ^ b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos saber si un conjunto es subconjunto de otro hacemos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = {1,2,3,4}\n",
    "b = {0,1,2,3,4,5,6,7}\n",
    "\n",
    "a.issubset(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a <= b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.issuperset(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b >= a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Source+Sans+Pro|Josefin+Sans:400,700,400italic|Ubuntu+Condensed' rel='stylesheet' type='text/css'>\n",
       "Estilo aplicado\n",
       "<style>\n",
       "\n",
       "\n",
       "\n",
       "#notebook_panel { /* main background */\n",
       "    background: #f7f7f7;\n",
       "}\n",
       "\n",
       "div.cell { /* set cell width */\n",
       "    width: 1000px;\n",
       "}\n",
       "\n",
       "div #notebook { /* centre the content */\n",
       "    background: #fff; /* white background for content */\n",
       "    width: 1100px;\n",
       "    margin: auto;\n",
       "    padding-left: 0em;\n",
       "}\n",
       "\n",
       "#notebook li { /* More space between bullet points */\n",
       "    margin-top:0.6em;\n",
       "}\n",
       "\n",
       "/* draw border around running cells */\n",
       "div.cell.border-box-sizing.code_cell.running { \n",
       "    border: 1px solid #111;\n",
       "}\n",
       "\n",
       "/* Put a solid color box around each cell and its output, visually linking them*/\n",
       "div.cell.code_cell {\n",
       "    font-family: 'Source Sans Pro', sans-serif;\n",
       "    background-color: rgb(256,256,256);\n",
       "    font-size: 110%;\n",
       "    border-radius: 0px; \n",
       "    padding: 0.5em;\n",
       "    margin-left:1em;\n",
       "    margin-top: 1em;\n",
       "}\n",
       "\n",
       "div.text_cell_render{\n",
       "    font-family: 'Josefin Sans', serif;\n",
       "    line-height: 145%;\n",
       "    font-size: 125%;\n",
       "    font-weight: 500;\n",
       "    width:850px;\n",
       "    margin-left:auto;\n",
       "    margin-right:auto;\n",
       "}\n",
       "\n",
       "\n",
       "/* Formatting for header cells */\n",
       ".text_cell_render h1, .text_cell_render h2, .text_cell_render h3,\n",
       ".text_cell_render h4, .text_cell_render h5 {\n",
       "    font-family: 'Ubuntu Condensed', sans-serif;\n",
       "}\n",
       "/*\n",
       ".text_cell_render h1 {\n",
       "    font-family: Flux, 'Ubuntu Condensed', serif;\n",
       "    font-style:regular;\n",
       "    font-weight: 400;    \n",
       "    font-size: 30pt;\n",
       "    text-align: center;\n",
       "    line-height: 100%;\n",
       "    color: #335082;\n",
       "    margin-bottom: 0.5em;\n",
       "    margin-top: 0.5em;\n",
       "    display: block;\n",
       "}\n",
       "*/\n",
       ".text_cell_render h1 {\n",
       "\tfont-family: Flux, 'Ubuntu Condensed', serif;\n",
       "    font-style:regular;\n",
       "    font-weight: 600;\n",
       "    font-size: 35pt;\n",
       "\ttext-align: center;\n",
       "    line-height: 100%;\n",
       "    color: #2c7638;\n",
       "    margin-bottom: 0.2em;\n",
       "    margin-top: 0.3em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h2 {\n",
       "    margin-top:16px;\n",
       "    font-size: 27pt;\n",
       "    font-weight: 550;\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.3em;\n",
       "    font-style: regular;\n",
       "    color: #498550\t;\n",
       "}\t\n",
       "\n",
       ".text_cell_render h3 {\n",
       "    font-size: 20pt;\n",
       "    font-weight: 550\n",
       "    text-align: left;\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.3em;\n",
       "    font-style: regular;\n",
       "    color:  #1a66ab;\n",
       "}\n",
       "\n",
       ".text_cell_render h4 {    /*Use this for captions*/\n",
       "    font-size: 18pt;\n",
       "    font-weight: 450\n",
       "    text-align: left;\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.3em;\n",
       "    font-style: regular;\n",
       "    color:  #578cb4;\n",
       "}\n",
       "\n",
       ".text_cell_render h5 {  /*Use this for small titles*/\n",
       "    font-size: 18pt;\n",
       "    font-weight: 550;\n",
       "    color: rgb(163,0,0);\n",
       "    font-style: italic;\n",
       "    margin-bottom: .1em;\n",
       "    margin-top: 0.8em;\n",
       "    display: block;\n",
       "    color:  #b21c0d;\n",
       "}\n",
       "\n",
       ".text_cell_render h6 { /*use this for copyright note*/\n",
       "    font-family: 'Ubuntu Condensed', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 14pt;\n",
       "    line-height: 100%;\n",
       "    color: #252525;\n",
       "    text-align: right;\n",
       "    margin-bottom: 1px;\n",
       "    margin-top: 1px;\n",
       "}\n",
       "\n",
       ".CodeMirror{\n",
       "        font-family: 'Duru Sans', sans-serif;\n",
       "        font-size: 100%;\n",
       "}\n",
       "\n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"],\n",
       "                           equationNumbers: { autoNumber: \"AMS\", useLabelIds: true}\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {'.MathJax_Display': {\"margin\": 4}}\n",
       "                }\n",
       "        });\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Esta celda da el estilo al notebook\n",
    "from IPython.core.display import HTML\n",
    "css_file = '../styles/StyleCursoPython.css'\n",
    "HTML(open(css_file, \"r\").read())"
   ]
  },
  {
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}