Python II.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <img src=\"uni-logo.png\" alt=\"Logo UNI\" width=100 hight=200 align=\"right\">\n",
    "\n",
    "\n",
    "<br><br><br>\n",
    "<h1><font color=\"#1D65DD\" size=5>Python desde cero</font></h1>\n",
    "\n",
    "\n",
    "\n",
    "<h1><font color=\"#1D65DD\" size=6>Python II</font></h1>\n",
    "\n",
    "<br>\n",
    "<div style=\"text-align: right\">\n",
    "<font color=\"#1D65DD\" size=3>Yuri Coicca, M.Sc.</font><br>\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2><font color=\"#1D65DD\" size=5>Índice</font></h2>\n",
    "\n",
    "---\n",
    "\n",
    "El objetivo de este módulo es conocer los elementos básicos del lenguaje python 3.7\n",
    "\n",
    "<a id=\"indice\"></a>\n",
    "\n",
    "Acorde al **índice**, en esta sesión veremos:\n",
    "\n",
    "\n",
    "* [6. Estructuras de datos básicas](#section1)\n",
    "  * [6.1 Listas](#section1A)\n",
    "  * [6.2 Conjuntos](#section1B)\n",
    "  * [6.3 Tuplas](#section1C)\n",
    "  * [6.4 Diccionarios](#section1D)\n",
    "* [7. Paquetes y módulos: importar](#section2)\n",
    "* [8. Eficiencia sobre una lista de elementos](#section3)\n",
    "  * [8.1 Inicialización de listas](#section3A)\n",
    "  * [8.2 Generadores: ¿Qué son?](#section3B)\n",
    "  * [8.3 List Comprehension](#section3C)\n",
    "  * [8.4 Funciones filter, map y reduce](#section3D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></a>\n",
    "</font></div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section1\"></a> </font></h1>\n",
    "<h1><font color=\"#1D65DD\" size=5>6. Estructuras de datos básicas.</font>\n",
    "<a id=\"section1A\"></a> \n",
    "    \n",
    "## <font color=\"#1D65DD\" size=4> 6.1 Listas </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas son **secuencias de elementos** (análogo a los arrays en otros lenguajes). **No es necesario especificar el tamaño máximo** (crece según sea necesario) **ni el tipo de datos que albergará** (puede ser cualquier combinación).\n",
    "\n",
    "Las funciones que utlizaremos para gestionar las listas son:\n",
    "* **Creación de listas**: usando los constructores `list` o `[]`\n",
    "* **Indexación**: acceso a los elementos de la lista usando los corchetes `[]`\n",
    "* **Insertar elementos al final**: `append`\n",
    "* **Concatenar**: Operador `+`\n",
    "* **Insertar un elemento en cualquier posición**: `insert`\n",
    "* **Borrar un elemento**: `del`\n",
    "* **Número de elementos en la lista**: `len`\n",
    "* Operaciones sobre **iterables**: all, any, max, min y sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Creación de listas </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se crean de dos formas distintas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Usando la función built-in list\n",
    "lista = list()\n",
    "\n",
    "# O usando los corchetes\n",
    "lista = []\n",
    "\n",
    "# La ventaja de usar los corchetes es que la podemos inicializar con una secuencia de valores:\n",
    "lista = [1, 2, 3, \"a\", \"b\", 4]\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para crear una lista de secuencia de enteros, puede usar la función **range** y convertir en lista usando la función **list**. La función **range** devuelve una lista de secuencia de números enteros de 0 a 1 menos que el valor que se le pasa como parámetro, como se muestra a continuación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = list(range(10))\n",
    "nums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La lista de números contiene números enteros del 0 al 9. Para crear una lista de secuencia de números enteros entre un rango especificado, puede pasar dos valores a la función **range**. El primer valor especifica el límite inferior (incluido en la secuencia resultante) y el segundo valor especifica el límite superior (excluido en la secuencia resultante). La siguiente función de rango devuelve una lista de números enteros del 50 al 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = list(range(50,101))\n",
    "nums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Indexación: acceso a los elementos de una lista </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [1, 2, 3]\n",
    "\n",
    "# El acceso es mediante el índice (posición dentro de la lista). El primer elemento tiene el índice 0, y el último\n",
    "# el número de elementos menos 1\n",
    "x = lista[0]\n",
    "print(\"Imprimo el primer elemento {}\".format(x))\n",
    "\n",
    "x = lista[2]\n",
    "print(\"Imprimo el último elemento {}\".format(x))\n",
    "\n",
    "# Los índices pueden ser negativos. Esto indica que se empieza a contar en orden inverso (desde la última posición)\n",
    "# En este caso, -1 indica el último elemento, y el número de elementos negativo es el primer elemento.\n",
    "x = lista[-1]\n",
    "print(\"Imprimo el último elemento {}\".format(x))\n",
    "\n",
    "x = lista[-3]\n",
    "print(\"Imprimo el primer elemento {}\".format(x))\n",
    "\n",
    "print(\"====\")\n",
    "\n",
    "# Se puede acceder a una secuencia de elementos utilizando los denominados slice indices\n",
    "print(lista[1:2])    # Obtiene los elementos desde el índice 1 (inclusive) hasta el índice 2 (exclusive)\n",
    "\n",
    "# Se puede obviar tanto el índice a la izquierda como el de la derecha de los :\n",
    "# Si obviamos el de la izquierda, se supone el primer índice como 0\n",
    "print(lista[:2])     # Obtiene los elementos desde 0 (inclusive) hasta 2 (exclusive)\n",
    "\n",
    "# Si obviamos el de la derecha, se supone el último índice como el número de elementos (es decir, todos los elementos hasta el final)\n",
    "print(lista[1:])     # Obtiene los elementos desde 1 (inclusive) hasta 3 (exclusive)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ¿Qué imprimirá? \n",
    "print(lista[-2:-1])\n",
    "print(lista[-1:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Adición de elementos </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Podemos extender la lista añadiendole nuevos elementos por el final\n",
    "lista = [1, 2, 3]\n",
    "lista.append('c')\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<i class=\"fa fa-exclamation-circle\" aria-hidden=\"true\"></i>\n",
    "Como una lista puede albergar cualquier elemento, puede albergar una lista también. Si ejecutamos `lista.append([1, 2, 3])` no introduce los elementos 1, 2 y 3, sino que introduce un elemento (lista) que contiene los elementos 1, 2 y 3.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [1, 2, 3]\n",
    "lista.append([1, 2, 3])\n",
    "print(lista)\n",
    "\n",
    "# El método extend es como el método append, excepto que permite agregar una lista a otra\n",
    "\n",
    "lista1 = [1, 2, 3, 4]\n",
    "lista2 = [5, 6, 7]\n",
    "lista1.extend(lista2)\n",
    "print(lista1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Concatenación de elementos </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Al igual que con los strings, las listas se pueden concatenar usando el operador +\n",
    "l1 = [1, 2, 3]\n",
    "l2 = ['a', 'b', 'c']\n",
    "print(l1 + l2)\n",
    "\n",
    "# Las listas l1 y l2 no han sido modificadas\n",
    "print(l1)\n",
    "print(l2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Inserción de elementos </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existe la función **insert** para insertar un elemento en una posición determinada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1, 2, 3]\n",
    "l.insert(1, 'a')                 # Inserta el elemento 'a' (segundo argumento) en la posición 1 (primer argumento)\n",
    "                                 # Los índices van desde el 0 (primera posición) hasta la última (número de elementos menos 1)\n",
    "print(l)\n",
    "\n",
    "l.insert(0, 'primer elemento')   # Insertamos un elemento en la primera posición\n",
    "print(l)\n",
    "\n",
    "l.insert(5, 'último elemento')   # Insertamos un elemento en la última posición (la lista tiene 6 elementos)\n",
    "print(l)\n",
    "l.insert(-1, \"penúltimo elemento\")\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Borrado de elementos </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Permite borrar elementos de la lista. Para ello se indexa los elementos que queremos borrar, y se precede la palabra \"del\"\n",
    "l = [1, 2, 3, 4, 5]\n",
    "print( l[2] ) # Indexamos un elemento (el 3)\n",
    "\n",
    "del l[2]      # Lo borramos\n",
    "print(l)\n",
    "\n",
    "# Borramos una secuencia de elementos utilizando slice indices\n",
    "del l[1:3]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El método **remove** no es el inverso de insert. Mientras que insert inserta un elemento en una ubicación específica, remove busca la primera instancia de un valor dado en una lista y elimina ese valor de la lista:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = [1, 2, 3, 4, 3, 5]\n",
    "m.remove(3)\n",
    "print(m)\n",
    "\n",
    "m.remove(3)\n",
    "print(m)\n",
    "\n",
    "# ¿Qué imprimirá? \n",
    "# m.remove(3)\n",
    "# print(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1, 2, 3, 4, 5]\n",
    "len(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Revertiendo el orden de una lista </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El método **reverse** es un método de modificación de lista más especializado. Invierte eficientemente una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = [1, 3, 5, 6, 7]\n",
    "n.reverse()\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El método **sort()** ordena los elementos de una lista determinada en un orden ascendente o descendente específico. \n",
    "<br>\n",
    "La sintaxis del método sort () es: **list. sort(key=..., reverse=...)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Ordenando una lista</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas pueden ser sorted usando el método **sort**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = [3, 8, 4, 0, 2, 1]\n",
    "g.sort()\n",
    "print(g)\n",
    "\n",
    "# Ordenando una lista con elementos de tipo string\n",
    "x = [\"en la UNI\", \"Pre-Maestría\", \"Clase de\"]\n",
    "x.sort()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ¿Qué imprimirá? \n",
    "\n",
    "dife = [1, 2, 'hello', 3]\n",
    "dife.sort()\n",
    "print(dife)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Comparando el sort personalizado versus el método sort \n",
    "\n",
    "def compare_num_of_chars(string1):\n",
    "    return len(string1)\n",
    "word_list = ['Python', 'is', 'better', 'than', 'C']\n",
    "word_list.sort()\n",
    "print(word_list)\n",
    "\n",
    "word_list = ['Python', 'is', 'better', 'than', 'C']\n",
    "word_list.sort(key=compare_num_of_chars)\n",
    "print(word_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> La función sorted()</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas tienen un método built-in para ordenarse por sí mismas, pero otros iterables en Python, como las claves de un diccionario, no tienen un método sort.\n",
    "Python también tiene la función built-in **sorted()**, que devuelve una lista ordenada de cualquier iterable. \n",
    "**sorted()** utiliza la misma clave y los mismos parámetros inversos que el método sort.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = (4, 3, 1, 2)\n",
    "y = sorted(x)\n",
    "print(y)\n",
    "\n",
    "z = sorted(x, reverse=True)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Detalles técnicos__\n",
    "\n",
    "Si está haciendo la transición de Python 2 y está familiarizado con la función del mismo nombre, debe tener en cuenta un par de cambios importantes en Python 3:\n",
    "\n",
    " * **sorted ()** de Python 3 no tiene un parámetro cmp. En su lugar, solo se usa la clave para introducir una lógica de clasificación personalizada.\n",
    " * **key** y **reverse** deben pasarse como argumentos de palabras clave, a diferencia de Python 2, donde podrían pasarse como argumentos posicionales."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Tamaño de la lista</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Función que devuelve el número de elementos que tiene una lista\n",
    "l = ['a', 'b', 'c']\n",
    "print( len(l) )   # Imprime el número de elementos: 3\n",
    "\n",
    "# Es útil para acceder al último elemento\n",
    "print(l[len(l)-1])\n",
    "\n",
    "# Aunque es mucho más simple utilizar los índices negativos\n",
    "print(l[-1])\n",
    "\n",
    "# El primer elemento es un número, el segundo es un string y el tercero es otra lista\n",
    "\n",
    "x = [2, \"two\", [1, 2, 3]]\n",
    "print( len(x) )   # Imprime el número de elementos: 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ¿Qué imprimirá? \n",
    "y = [0]\n",
    "z = []\n",
    "w = [[1, 3, [4, 5], 6], 7]\n",
    "print(len(y))\n",
    "print(len(z))\n",
    "print(len(w))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ¿Qué imprimirá? \n",
    "a = [1, 2, 3, 4]\n",
    "a[len(a):] = [5, 6, 7]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ¿Qué imprimirá? \n",
    "a[:0] = [-1, 0]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ¿Qué imprimirá? \n",
    "a[1:-1] = []\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3>Membresía de lista con el operador in</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es fácil probar si un valor está en una lista mediante el operador **in**, que devuelve un valor booleano. También puede usar el operador inverso, **not in**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3 in [1, 3, 4, 5])\n",
    "print(3 not in [1, 3, 4, 5])\n",
    "print(3 in [\"one\", \"two\", \"three\"])\n",
    "print(3 not in [\"one\", \"two\", \"three\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Operaciones sobre secuencias de elementos (_iterables_) </font>\n",
    "\n",
    "Un elemento **iterable** representa una secuencia de elementos: ejemplo de elementos iterables son las listas, los conjuntos, las tuplas y los diccionarios (tanto las claves como los valores). Las operaciones sobre iterables son operaciones que se pueden ejecutar recibiendo como argumento un elemento iterable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> all </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Si la lista es una lista de booleanos, devuelve True si todos los elementos son True, y False en caso contrario\n",
    "l = [True, False, True]\n",
    "print(all(l))   # Imprime False\n",
    "\n",
    "l = [True, True, True]\n",
    "print(all(l))   # Imprime True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> any </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Si la lista es una lista de booleanos, devuelve True si alguno de los elementos es True, y False en caso contrario\n",
    "l = [True, False, True]\n",
    "print(any(l))   # Imprime True\n",
    "\n",
    "l = [False, False, False]\n",
    "print(any(l))   # Imprime True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color=\"#1D65DD\" size=3> max </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Max también puede ser utilizado pasando una lista como único argumento, analizando todos los elementos de la lista para computar el máximo\n",
    "max([1,2,3,9,8,7,6]) # Computa 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> min </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Min también puede ser utilizado pasando una lista como único argumento, analizando todos los elementos de la lista para computar el mínimo\n",
    "min([1,2,3,9,8,7,6]) # Computa 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> sum </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Computa la suma de todos los elementos de una lista, pasada como argumento\n",
    "sum([1, 2, 3, 4, 5]) # Devuelve 15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></a>\n",
    "</font></div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section1B\"></a> \n",
    "## <font color=\"#1D65DD\" size=4> 6.2 Conjuntos </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un conjunto en Python es una **colección desordenada de objetos** que se usa cuando la pertenencia y la unicidad en el conjunto son las principales cosas que necesita saber sobre ese objeto. Los conjuntos son **conjuntos de elementos no repetidos**. En este caso la indexación no tiene sentido, únicamente la comprobación de pertenencia de un elemento al conjunto. Para ello haremos uso de la palabra reservada `in`.\n",
    "\n",
    "Las funciones utilizadas para gestionar un conjunto son:\n",
    "* **Creación de conjuntos**: `set`\n",
    "* **Insertar elementos**: `add`\n",
    "* **Eliminar elementos**: `remove`\n",
    "* **Pertenencia de elementos al conjunto**: operador infijo `in`\n",
    "* **Operaciones básicas de conjuntos**: unión, intersección y diferencia\n",
    "* **Número de elementos en el conjunto**: `len`\n",
    "* Operaciones sobre **iterables**: all, any, max, min y sum **(igual que para listas)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "Se puede almacenar cualquier elemento hasheable, que son elementos que tienen implementada una función hash. Para nosotros, serán hasheables los tipos básicos (int, float, bool y str, así como las tuplas (ver punto [C](#section5C)).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Creación de conjuntos</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Se crean usando la función built-in set\n",
    "print(set())\n",
    "\n",
    "# También se puede crear un conjunto con una lista de elementos inicial\n",
    "print(set([1,2,3,4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Inserción de elementos</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Se utiliza la función add\n",
    "s = set()      # Creamos el conjunto\n",
    "s.add(1)       # Añadimos el 1\n",
    "s.add(\"Hola\")  # Añadimos el string \"Hola\"\n",
    "s.add(2.3)     # Añadimos el flotante 2.3\n",
    "print(s)\n",
    "\n",
    "# Ahora si añadimos un elemento repetido no hace nada (el conjunto sigue siendo el mismo)\n",
    "s.add(1)       # Añadimos el 1\n",
    "s.add(\"Hola\")  # Añadimos el string \"Hola\"\n",
    "s.add(2.3)     # Añadimos el flotante 2.3\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Eliminación de elementos</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = set(['a','b','c'])\n",
    "print(s)\n",
    "\n",
    "s.remove('b')  # Extraemos el elemento 'b'\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3>Pertenencia de elementos</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Con el operador infijo \"in\" se puede comprobar la petenencia de elementos en un set\n",
    "# Comprueba si el elemento a la izquierda existe en el elemento de la derecha\n",
    "\n",
    "s = set([1,2,3])\n",
    "print(2 in s) # Devuelve True\n",
    "print(5 in s) # Devuelve False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "En realidad el operador infijo <i>in</i> se puede utilizar sobre cualquier elemento que sea iterable (como listas, tuplas o diccionarios).\n",
    "    \n",
    "Por ejemplo: `'b' in ['a', 'b', 'c']` devolvería `True`\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Operaciones básicas sobre conjuntos</font>\n",
    "* <font color=\"#1D65DD\" size=3> <strong>unión</strong> </font>: union\n",
    "* <font color=\"#1D65DD\" size=3> <strong>intersección</strong> </font>: intersection\n",
    "* <font color=\"#1D65DD\" size=3> <strong>diferencia</strong> </font>: difference (-)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = set([1,2,3,4,5])\n",
    "s2 = set([4,5,6,7,8])\n",
    "\n",
    "print(\"Unión de conjuntos: {}\".format(s1.union(s2)))\n",
    "print(\"Intersección de conjuntos: {}\".format(s1.intersection(s2)))\n",
    "print(\"Diferencia entre conjuntos: {}, igual que {}\".format(s1.difference(s2), s1 - s2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Debido a que los conjuntos no son inmutables ni modificables (hashables), no pueden pertenecer a otros conjuntos. La función **frozenset** () devuelve un objeto frozenset inmutable (que es como un objeto set, solo que no se puede cambiar.\n",
    "Su sintaxis es: frozenset(iterable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = set([1, 2, 3, 1, 3, 5])\n",
    "z = frozenset(x)\n",
    "print(z)\n",
    "\n",
    "z.add(6)\n",
    "print(z)\n",
    "\n",
    "x.add(z)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></a>\n",
    "</font></div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section1C\"></a> \n",
    "## <font color=\"#1D65DD\" size=4> 6.3 Tuplas </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las tuplas son secuencias de elementos, de forma similar a las listas, pero que son **inmutables**. Esto significa que una tupla no se puede modificar una vez ésta ha sido creada.\n",
    "\n",
    "Una de las ventajas de las tuplas, más allá de la definición conceptual, es que permiten que exista implementada una función hash por defecto: **permite que estos elementos puedan ser insertados en conjuntos y en diccionarios como claves (ver punto [D](#section5D))**\n",
    "\n",
    "\n",
    "Al ser una especialización de las listas, tanto la **indexación** como las funciones descritas anteriormente para las listas sirven para las tuplas. La **excepción** son las funciones que modifican la lista (¡ya que las tuplas son inmutables!). Éstas son las funciones `append`, `insert` y `del`, además de las que trabajan con **iterables**: all, any, max, min y sum.\n",
    "\n",
    "Por lo tanto, a modo de índice, éstas son las funciones que usaremos para gestionar las tuplas:\n",
    "* **Creación de tuplas**: `tuple` o `()`\n",
    "* **Indexación**: acceso a los elementos de la tupla usando los corchetes `[]` **(igual que para listas)**.\n",
    "* **Concatenar**: Operador `+` **(igual que para listas)**\n",
    "* **Número de elementos en la tupla**: `len` **(igual que para listas)**\n",
    "* Operaciones sobre **iterables**: all, any, max, min y sum **(igual que para listas)**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t[0] = 3  # TypeError: 'tuple' object does not support item assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Creación de tuplas</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mediante la función built-in tuple, a la que se le pasa una lista (si no se indican argumentos, construye una tupla vacía)\n",
    "t = tuple([1, 2, 3])   # Tupla con los elementos 1, 2, 3\n",
    "print(t)\n",
    "\n",
    "# También se puede crear mediante el uso de paréntesis:\n",
    "t = (1, 2, 3)\n",
    "print(t)\n",
    "\n",
    "# Creación de tuplas vacías:\n",
    "print(tuple())         # Función tuple sin argumentos\n",
    "print(())              # Paréntesis sin elementos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Como son objetos hasheables, se pueden insertar en conjuntos:\n",
    "s = set()\n",
    "s.add((1,2))       # Añadimos la tupla (1, 2) al conjunto\n",
    "print(s)\n",
    "\n",
    "print((1,2) in s)  # Comprobamos si la tupla pertenece o no al conjunto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<i class=\"fa fa-exclamation-circle\" aria-hidden=\"true\"></i>\n",
    "Cuando se crea una tupla con un solo elemento tenemos dos opciones:\n",
    "\n",
    "- Usar `tuple('a')`</li>\n",
    "- Usar `('a',)`. ¡En este caso es necesaria la coma para diferenciar el uso de los paréntesis como agrupación de operaciones!\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color=\"#1D65DD\" size=4>Asignación múltiple</font>\n",
    "\n",
    "En Python se permite asignación múltiple: `x, y, z = 1, 2, 3`\n",
    "\n",
    "En realidad, el código al que se traduce es el siguiente: `(x, y, z) = (1, 2, 3)`.\n",
    "\n",
    "Puede ser muy útil, por ejemplo, en la descomposición de strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre, apellido1, apellido2 = \"Pedro López Santos\".split(\" \")\n",
    "print(nombre)\n",
    "print(apellido1)\n",
    "print(apellido2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para hacer las cosas aún más convenientes, Python 3 tiene una función de desempaquetado extendida, que permite que un elemento marcado con ***** absorba cualquier número de elementos que no coincidan con los otros elementos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = (1, 2, 3, 4)\n",
    "a, b, *c = x\n",
    "print(a, b, c)\n",
    "(1, 2, [3, 4])\n",
    "\n",
    "a, *b, c = x\n",
    "print(a, b, c)\n",
    "\n",
    "*a, b, c = x\n",
    "print(a, b, c)\n",
    "\n",
    "a, b, c, d, *e = x\n",
    "print(a, b, c, d, e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las tuplas se pueden convertir fácilmente en listas con la función **list()**, que toma cualquier secuencia como argumento y produce una nueva lista con los mismos elementos que la secuencia original. De manera similar, las listas se pueden convertir en tuplas con la función **tuple()**, que hace lo mismo pero produce una nueva tupla en lugar de una nueva lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list((1, 2, 3, 4)))\n",
    "print(tuple([1, 2, 3, 4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es interesante ver como usar una lista como una forma conveniente de dividir una cadena en caracteres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(\"Hola\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Concatenando tuplas</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al igual que las listas, el operador de suma \"+\" se puede utilizar para concatenar dos tuplas. De hecho, esta es una de las formas de agregar un elemento a una tupla."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = ('Red', 'Green', 'Blue', 'Yellow', 'White') \n",
    "orange_color = ('Orange',)\n",
    "newcolors = colors + orange_color\n",
    "print(newcolors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></a>\n",
    "</font></div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section1D\"></a> \n",
    "## <font color=\"#1D65DD\" size=4> 6.4 Diccionarios </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los diccionarios son elementos que relacionan una **clave** con un **valor**. La clave tiene que ser hasheable (al igual que pasaba con los elementos de un **set**). El valor puede ser cualquier elemento.\n",
    "\n",
    "Las siguientes funciones son las utilizadas para gestionar diccionarios:\n",
    "\n",
    "* **Creación de diccionarios**: `dict` o `{}`\n",
    "* **Indexación**: acceso a los elementos de la tupla usando los corchetes `[]`, donde dentro de los corchetes se especifica una clave\n",
    "* **Borrar un elementos**: `del` **(igual que para listas)**\n",
    "* **Número de elementos en el diccionario**: `len` **(igual que para listas)**\n",
    "* Operaciones sobre **iterables**: all, any, max, min y sum **(igual que para listas. Opera sobre la lista de claves)**\n",
    "* Operaciones **iterables**: all, any, max, min y sum (**se opera sobre la lista de claves**)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Creación de diccionarios</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Se crean usando la función built-in dict, y como argumentos asignaciones \"clave=valor\"\n",
    "print(dict(a=1, b=2))\n",
    "\n",
    "# También se puede crear utilizando las llaves, y elemenos \"clave:valor\" separados por comas\n",
    "print({'a':1, 'b':2})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "La ventaja de crear los diccionarios con la palabra reservada `dict` es que puede resultar más cómodo de recordar, al seguir el formato de agumentos en funciones.\n",
    "\n",
    "<br>\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "La desventaja es que las claves en este formato siempre se toman como caracteres. Si queremos utilizar enteros o flotantes como clave, hay que hacerlo usando el constructor basado en llaves `{}`\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo de creación de un diccionario con claves numéricas:\n",
    "print({1:\"entero\", 2.65:\"flotante\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Acceso a pares clave-valor</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El acceso se realiza mediante el uso de corchetes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {1:\"entero\", 2.5: \"flotante\", \"hola\": \"string\"}\n",
    "\n",
    "print(d[1])       # \"entero\"\n",
    "print(d[2.5])     # \"flotante\"\n",
    "print(d[\"hola\"])  # \"string\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {}\n",
    "d['hola'] = 'mundo'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d[(1,2,3)] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede acceder a la lista de claves, la lista de valores, y la lista de tuplas (clave, valor). Para ello, existen las funciones `keys`, `values` e `items`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "Estas funciones devuelven un generador. Por ahora solo necesitamos saber que para generar la lista a parir del generador, es necesario usar la función list().\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {1:\"entero\", 2.5: \"flotante\", \"hola\": \"string\"}\n",
    "\n",
    "print( list(d.keys()) )    # Imprime la lista de claves\n",
    "print( list(d.values()) )  # Imprime la lista de valores\n",
    "print( list(d.items()) )   # Imprime la lista de tuplas (clave, valor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Borrando items del diccionario </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al igual que las listas, la función **del** se puede utilizar para eliminar elementos de una lista. Veamos el siguiente ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cars = {'name':'Honda', 'model':2013, 'color':'Yellow', 'Air bags': True}\n",
    "print(cars)\n",
    "del cars['model']\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También puede eliminar todos los elementos de un diccionario mediante la función **clear**. El siguiente ejemplo muestra que:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cars = {'name':'Honda', 'model':2013, 'color':'Yellow', 'Air bags': True}\n",
    "print(cars)\n",
    "cars.clear()\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Copiando diccionarios</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para copiar un diccionario a otro, puede utilizar la función **copy**. Eche un vistazo al siguiente ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cars = {'name':'Honda', 'model':2013, 'color':'Yellow', 'Air bags': True}\n",
    "cars2 = cars.copy()\n",
    "print(cars2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Diccionarios con un valor por defecto </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En ocasiones es muy útil disponer de diccionarios con un valor por defecto. Existen los `defaultdict`, diccionarios que al asignar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cuentapalabras = dict()\n",
    "texto = \"En un día como hoy, estamos viendo el uso de diccionarios en Python con un valor por defecto\".split(\" \")\n",
    "print(texto)\n",
    "for p in texto:\n",
    "    # hacemos la palabra lowercase\n",
    "    palabra = p.lower()\n",
    "    if palabra in cuentapalabras:\n",
    "        cuentapalabras[palabra] += 1\n",
    "    else:\n",
    "        cuentapalabras[palabra] = 1\n",
    "cuentapalabras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El módulo integrado **collections** nos proveé otros tipos o mejoras de las colecciones clásicas.\n",
    "La clase **defaultdict** se utiliza para crear diccionarios con un valor por defecto aunque el registro no haya sido definido anteriormente. \n",
    "\n",
    "**defaultdict** significa que si no se encuentra una clave en el diccionario, en lugar de lanzar una **KeyError**, se creará una nueva entrada. El tipo de esta nueva entrada viene dado por el argumento de **defaultdict**.\n",
    "\n",
    "Para ello hay que indicar un tipo de dato por defecto al diccionario:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "cuentapalabras = defaultdict(int)\n",
    "texto = \"En un día como hoy, estamos viendo el uso de diccionarios en Python con un valor por defecto\".split(\" \")\n",
    "for p in texto:\n",
    "    palabra = p.lower()\n",
    "    # hacemos la palabra lowercase\n",
    "    cuentapalabras[palabra] += 1\n",
    "cuentapalabras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "d = defaultdict(float)  # tipo flotante por defecto\n",
    "print(d['algo'])\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = defaultdict(str)  # tipo cadena por defecto\n",
    "print(d['algo'])\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La clase **OrderedDict** es otra subclase de diccionario, pero esta vez con la capacidad de conservar el orden en que añadimos los registros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import OrderedDict\n",
    "\n",
    "n = OrderedDict()\n",
    "n['uno'] = 'one'\n",
    "n['dos'] = 'two'\n",
    "n['tres'] = 'three'\n",
    "\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La clase **Counter** es una subclase de diccionario utilizada para realizar cuentas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "l = [1,2,3,4,1,2,3,1,2,1]\n",
    "Counter(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "animales = \"gato perro canario perro canario perro\"\n",
    "c = Counter(animales.split())\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Counter(\"palabra\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "animales = \"gato perro canario perro canario perro\"\n",
    "c = Counter(animales.split())\n",
    "\n",
    "print(c.most_common(1))  # Primeros elemento más repetido\n",
    "print(c.most_common(2))  # Primeros dos elementos más repetidos\n",
    "print(c.most_common())   # Elementos ordenados por repeticiones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [10,20,30,40,10,20,30,10,20,10]\n",
    "c = Counter(l)\n",
    "\n",
    "print(c.items())        # Registros del contador por clave-valor\n",
    "print(c.keys())         # Registros del contador por clave\n",
    "print(c.values())       # Registros del contador por valor\n",
    "\n",
    "print(sum(c.values()))  # Suma total de elementos del contador\n",
    "\n",
    "print(list(c))          # Conversión a lista\n",
    "print(dict(c))          # Conversión a conjunto\n",
    "print(set(c))           # Conversión a conjunto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También es muy útil cuando manejamos listas..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tipo_palabras = [('estamos', 'verbo'), ('en', 'preposición'), ('clase', 'nombre'), ('escuchando', 'verbo')]\n",
    "\n",
    "grupos_palabras = defaultdict(list)\n",
    "for valor, clave in tipo_palabras:\n",
    "    grupos_palabras[clave].append(valor)\n",
    "grupos_palabras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></a>\n",
    "</font></div>\n",
    "\n",
    "---\n",
    "\n",
    "<h1><font color=\"#1D65DD\" size=5>7. Paquetes y módulos: importar<a id=\"section2\"></a> </font></h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el _Tutorial python I_ ya introdujimos cómo importar módulos (`import math`).\n",
    "\n",
    "Los módulos son ficheros en python. Los módulos pueden ser importados, haciendo su código accesible: por ejemplo `modulo.atributo`.\n",
    "\n",
    "Para cargar un módulo se usa la sentencia `import` seguido del nombre del paquete. Se creará una variable cuyo nombre es el nombre del paquete, y podremos acceder a su contenido con el punto: por ejemplo `math.pi`.\n",
    "\n",
    "Si queremos que la variable para acceder al paquete tenga otro nombre, se puede elegir añadiendo `as nuevo_nombre` después del import: `import math as mt`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "Los paquetes son directorios que contienen uno o más módulos (u otros paquetes). Además, cada paquete debe contener un módulo con un nombre especial: <i>__init__.py</i>. Este fichero especial contiene el código que será ejecutado cuando el paquete se importe por primera vez en el intérprete.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "Además de import, existen otras formas de importar módulos y paquetes. Los más importantes son tres:\n",
    "\n",
    "\n",
    "- `import` (el mostrado anteriormente)\n",
    "- `from módulo import elemento as nombre` (donde `as nombre` es opcional)\n",
    "- Uso del paquete `importlib`: permite un mayor control a la hora de importar módulos y paquetes. Uno de los ejemplos es el importar mediante el uso de strings: `importlib.import_module('random')`.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "En este ejemplo utilizaremos el módulo random para generar números aleatorios.\n",
    "\"\"\"\n",
    "import random  # importamos el módulo\n",
    "import numpy as np\n",
    "numeros_aleatorios = []\n",
    "a, b = 0, 10\n",
    "N = 10000000\n",
    "for _ in range(N):\n",
    "    numeros_aleatorios.append(random.randint(a, b))\n",
    "\n",
    "# Obtenemos estadísticas de sobre la lista de números aleatorios generada\n",
    "\n",
    "print(\"La media +- desviación típica es: {} +- {}.\".format(\n",
    "    np.mean(numeros_aleatorios), np.std(numeros_aleatorios)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Utilizando from\n",
    "import random  # importamos el módulo\n",
    "from numpy import mean, std\n",
    "numeros_aleatorios = []\n",
    "a, b = 0, 10\n",
    "N = 1000\n",
    "for _ in range(N):\n",
    "    numeros_aleatorios.append(random.randint(a, b))\n",
    "\n",
    "# Obtenemos estadísticas de sobre la lista de números aleatorios generada\n",
    "\n",
    "print(\"La media +- desviación típoca es: {} +- {}.\".format(\n",
    "    mean(numeros_aleatorios), std(numeros_aleatorios)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=4> <i class=\"fa fa-book\" aria-hidden=\"true\" style=\"color:#113D68\"></i> </font> __Importante!__ Sobre todo si no estás habituado a programar en python, es muy recomendable utilizar únicamente `import`. De esta manera, es más dificil cometer errores en el nombrado de variables y machacar paquetes importados **(en ese caso, habría que volver a realizar el import para acceder a los módulos / paquetes)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#7F000E\"></i></a>\n",
    "</font></div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section3\"></a> </font></h1>\n",
    "<h1><font color=\"#1D65DD\" size=5>8. Eficiencia sobre una lista de elementos</font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando trabajemos con conjuntos de datos, sobre todo cuando éstos son especialmente grandes, es muy importante tener en cuenta la eficiencia.\n",
    "\n",
    "En esta sección abordaremos detalles de implementación que tienen un gran impacto en el rendimiento de nuestro código."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></a>\n",
    "</font></div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section3A\"></a> \n",
    "## <font color=\"#1D65DD\" size=4> 8.1. Inicialización de listas </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como hemos visto, no es necesario especificar el tamaño de las listas en su creación (al contrario que en otros lenguajes de proogramación). Esto, aunque muy util, conlleva una penalización en cuanto al uso de memoria RAM. Además, exite un sobrecoste en tiempo de ejecución cuando hay que expandir el tamaño de la lista (uso de la función `append`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Acerca de timeit**\n",
    "\n",
    "La función **`timeit()`** ejecuta el código muchas veces (por defecto un millón) y toma un promedio de los tiempos. \n",
    "\n",
    "**`% timeit`** es una función mágica de **ipython**, que se puede usar para cronometrar un fragmento de código en particular (una sola declaración de ejecución o un solo método).\n",
    "\n",
    "La **línea mágica** tienen el prefijo% y funcionan de manera muy similar a las llamadas de línea de comandos del sistema operativo: obtienen como argumento el resto de la línea, donde los argumentos se pasan sin paréntesis ni comillas.\n",
    "\n",
    "La **celda mágica** tiene el prefijo %% doble, y son funciones que obtienen como argumento no solo el resto de la línea, sino también las líneas debajo de ella en un argumento separado.\n",
    "\n",
    "Para más información: [The cell magics in IPython](https://nbviewer.jupyter.org/github/adrn/ipython/blob/1.x/examples/notebooks/Cell%20Magics.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -n 10\n",
    "# Uso de append (va aumentando el tamaño de la lista dinámicamente)\n",
    "\n",
    "l = []\n",
    "N = 10**6\n",
    "for i in range(N):\n",
    "    l.append(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%timeit -n 10\n",
    "# Inicializamos la lista a un tamaño N (usando elementos None)\n",
    "\n",
    "N = 10**6\n",
    "l = [0] * N\n",
    "for i in range(N):\n",
    "    l[i] = i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[0] * 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=4> <i class=\"fa fa-book\" aria-hidden=\"true\" style=\"color:#113D68\"></i> </font> __Importante!__ Por ello, si se conoce el tamaño de la lista a priori, es mejor generar una lista con todos los elementos (inicialmente `None`, `0`, ...) y hacer asignaciones mediante el índice.\n",
    "\n",
    "Aún más eficiente es el uso de **comprehension lists** (que veremos a continuación)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></a>\n",
    "</font></div>\n",
    "---\n",
    "\n",
    "<a id=\"section3B\"></a> \n",
    "## <font color=\"#1D65DD\" size=4> 8.2. Iteradores y generadores: ¿Qué son? </font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conceptualmente, un iterador es cualquier objeto que se puede iterar, es decir, recorrer sus elementos mediante un bucle o equivalente (acaba llamando a una función interna `__iter__`).\n",
    "\n",
    "Un generador es un objeto que genera un elemento cada vez que se le solicita (a trav'es de una llamada a una función interna `__next__`). Todo generador es un iterador, pero no todo iterador es un generador: por ejemplo, la función `enumerate` devuelve un generador (e iterador) pero la función `range` devuelve un iterador (pero no generador)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<i class=\"fa fa-info-circle\" aria-hidden=\"true\"></i>\n",
    "La principal diferencia radica en la implementación, siendo mucho más legible y fácil de implementar un generador (estructura de función) que un iterador (estructura de clase).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Al constructor de una lista se le puede pasar un objeto iterable, inicializando la lista con todos los elementos del mismo.\n",
    "# Una lista también es un iterable. Ejemplo:\n",
    "l = list(range(10))\n",
    "print(l)\n",
    "\n",
    "# Pero también se le puede pasar otra lista!\n",
    "l = list([1,2,3])\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La diferencia entre manejar un iterable y la propia lista de elementos radica en la eficiencia: mientras que la **lista de elementos debe permanecer alojada (por completo) en memoria principal** (habiéndose generado inicialmente por completo), el **iterable puede ir creando los objetos dinámicamente uno a uno**. Ejemplo usando `range`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Range</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El módulo **timeit** proporciona una interfaz simple para determinar el tiempo de ejecución de pequeñas partes de código Python. Utiliza una función de tiempo específica de la plataforma para proporcionar el cálculo de tiempo más preciso posible y reduce el impacto de los costos de inicio o apagado en el cálculo de tiempo al ejecutar el código repetidamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -n 10\n",
    "N = 10 ** 6\n",
    "suma = 0\n",
    "for _ in list(range(N)):  # Creando la lista y luego iterándola\n",
    "    suma += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit  -n 10\n",
    "N = 10 ** 6\n",
    "suma = 0\n",
    "for _ in range(N):  # Iterando el objeto range (iterable) directamente\n",
    "    suma += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=4> <i class=\"fa fa-book\" aria-hidden=\"true\" style=\"color:#113D68\"></i> </font> __Importante!__ Lo realmente costoso no está en el bucle (en ambos casos el bucle itera N veces la operación +=1). Lo costoso está en la creación de la lista entera en memoria, con el consecuente consumo de memoria para alojarla."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit\n",
    "N = 10 ** 6\n",
    "l = list(range(N))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit\n",
    "N = 10 ** 6\n",
    "r = range(N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Enumerate</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En ejemplos anteriores hemos iterado sobre los elementos de una lista (`for elemento in lista`) y sobre los índices (`for i in range(len(lista))`). Este último caso se da cuando necesitamos el índice para, por ejemplo, actualizar la posición de la lista.\n",
    "\n",
    "Es posible iterar sobre los elementos y los índices simultáneamente haciendo uso de `enumerate` (un generador):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [1, 2, 3, 4, 5]\n",
    "\n",
    "for (i, elemento) in enumerate(lista):\n",
    "    lista[i] = elemento**2\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [1, 2, 3, 4, 5]\n",
    "\n",
    "for i in range(len(lista)):\n",
    "    lista[i] = lista[i]**2\n",
    "\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo que se le pasa a `enumerate` es un iterable, y lo que hace es añadir el índice, de tal manera que por cada elemento devuelve una tupla (índice, elemento). El elemento puede ser a su vez otra tupla, o cualquier otro objeto de python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuplas = [(1, 2), (3, 4), (5, 6)]\n",
    "\n",
    "for i, tupla in enumerate(tuplas):\n",
    "    print(i)\n",
    "    print(tupla)\n",
    "    # Nótese que en cada iteración la lista tuplas va cambiando!\n",
    "    # En la siguiente iteración, se actualizará la posición i con el valor modificado en la iteración anterior\n",
    "    tuplas[i] = (tuplas[i-1][0] + tupla[0], tuplas[i-1][1] + tupla[1])\n",
    "    print(tuplas)\n",
    "\n",
    "print(tuplas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Zip</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otra función que suele ser de utilizada es la función `zip`. Esta función permite iterar simultáneamente dos iterables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista1 = [1, 2, 3, 4, 5]\n",
    "lista2 = range(6,11)\n",
    "suma = []\n",
    "\n",
    "for e1, e2 in zip(lista1, lista2):\n",
    "    suma.append(e1 + e2)\n",
    "\n",
    "print(suma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si los iterables son de **diferente tamaño**, se iterará sobre N elementos, siendo N el **mínimo de los dos tamaños**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista1 = range(1,6)\n",
    "lista2 = range(6,9)\n",
    "suma = []\n",
    "\n",
    "for e1, e2 in zip(lista1, lista2):\n",
    "    suma.append(e1 + e2)\n",
    "\n",
    "print(suma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Siguiendo la filosofía de la eficiencia, se puede combinar enumerate y zip para no tener que generar ninguna lista en memoria, y además evitar el uso de append en la lista resultado (suma)\n",
    "\n",
    "Sin embargo, llamar a las funciónes también incrementa el tiempo de ejecución"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -n 10\n",
    "# Siguiendo la filosofía de la eficiencia, se puede combinar enumerate y zip para no tener que \n",
    "# generar ninguna lista en memoria, y además evitar el uso de append en la lista resultado (suma)\n",
    "N = 10 ** 6\n",
    "lista1 = range(0,N)\n",
    "lista2 = range(0,N)\n",
    "\n",
    "suma = []\n",
    "\n",
    "for e1, e2 in zip(lista1, lista2):\n",
    "    suma.append(e1 + e2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -n 10\n",
    "# Siguiendo la filosofía de la eficiencia, se puede combinar enumerate y zip para no tener que \n",
    "# generar ninguna lista en memoria, y además evitar el uso de append en la lista resultado (suma)\n",
    "N = 10 ** 6\n",
    "lista1 = range(0,N)\n",
    "lista2 = range(0,N)\n",
    "\n",
    "suma = [None] * N\n",
    "\n",
    "for i, (e1, e2) in enumerate(zip(lista1, lista2)):\n",
    "    suma[i] = e1 + e2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></a>\n",
    "</font></div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section3C\"></a> \n",
    "## <font color=\"#1D65DD\" size=4> 8.3 List Comprehension </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En los ejemplos anteriores hemos creado inicialmente una lista de resultados (suma), y le asignamos los valores en un bucle posterior. Esto significa que:\n",
    "\n",
    "* Usamos append para ir añadiendo los valores, uno a uno, a la lista\n",
    "* Gastamos tiempo en crear la lista en memoria (con valores None por ejemplo), y posteriormente asignamos los valores\n",
    "\n",
    "Existe una alternativa más eficiente: los **list comprehension**\n",
    "\n",
    "Permiten generar una lista con unos valores en un solo paso, con la ventaja de que el código implícito está optimizado **(mucho más eficiente)**. En este sentido, se pueden crear listas, generadores y diccionarios."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Su sintaxis es:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[expression for item in list]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iterando a través de un string usando el bucle `for`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "h_letters = []\n",
    "\n",
    "for letter in 'human':\n",
    "    h_letters.append(letter)\n",
    "\n",
    "print(h_letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iterando a través de un string usando `List Comprehension`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "h_letters = [ letter for letter in \"human\"]\n",
    "print( h_letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si lo ha notado, **human** es un string, no una lista. Este es el poder de la `list comprehension`. Puede identificar cuándo recibe un string o una tupla y trabajar en ella como una lista.\n",
    "\n",
    "Puede hacerlo usando bucles. Sin embargo, no todos los bucles pueden reescribirse como `list comprehension`, pero a medida que aprenda y se sienta cómodo con las `list comprehension`, se encontrará reemplazando más y más bucles con esta elegante sintaxis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Listas</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [1, 2, 3, 4]\n",
    "\n",
    "lista2 = [x**2 for x in lista]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -n 10\n",
    "\n",
    "N = 10 ** 6\n",
    "lista1 = range(0,N)\n",
    "lista2 = range(0,N)\n",
    "\n",
    "suma = [None] * N\n",
    "\n",
    "for (i, (e1, e2)) in enumerate(zip(lista1, lista2)):\n",
    "    suma[i] = e1 + e2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -n 10\n",
    "\n",
    "N = 10 ** 6\n",
    "lista1 = range(0,N)\n",
    "lista2 = range(0,N)\n",
    "\n",
    "suma = [ e1 + e2 for e1, e2 in zip(lista1, lista2) ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pueden combinar expresiones condicionales en la comprehension list, te tal manera que solo cuando la expresión se evalua a True se genera el elemento correspondiente **(permitiendo que la lista resultante sea más pequeña que la original)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 100\n",
    "lista1 = range(0,N)\n",
    "lista2 = range(0,N)\n",
    "\n",
    "suma_impares = [ e1 + e2 for e1, e2 in zip(lista1, lista2) if e1 % 2 == 1 and e2 % 2 == 1]\n",
    "print(suma_impares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transpuesta de una matriz usando bucles `for` anidados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# matrix es de dimensión 2x4\n",
    "transposed = []\n",
    "matrix = [[1, 2, 3, 4], [4, 5, 6, 8]]\n",
    "\n",
    "for i in range(len(matrix[0])):\n",
    "    transposed_row = []\n",
    "\n",
    "    for row in matrix:\n",
    "        transposed_row.append(row[i])\n",
    "    transposed.append(transposed_row)\n",
    "\n",
    "print(transposed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transpuesta de una matriz usando `list comprehension`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# matrix es de dimensión 4x2\n",
    "matrix = [[1, 2], [3,4], [5,6], [7,8]]\n",
    "transpose = [[row[i] for row in matrix] for i in range(2)]\n",
    "print (transpose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Expresiones generadoras</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "N = 10 ** 6\n",
    "lista1 = range(0,N)\n",
    "lista2 = range(0,N)\n",
    "\n",
    "suma = ( e1 + e2 for e1, e2 in zip(lista1, lista2) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "suma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%time\n",
    "\n",
    "N = 10 ** 2\n",
    "lista1 = range(0,N)\n",
    "lista2 = range(0,N)\n",
    "\n",
    "suma = list([ e1 + e2 for e1, e2 in zip(lista1, lista2) ])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Diccionarios (comprehension dicts)</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -n 10\n",
    "\n",
    "N = 10 ** 5\n",
    "lista1 = range(0,N)\n",
    "lista2 = range(0,N)\n",
    "\n",
    "suma = {(e1, e2):  e1 + e2 for e1, e2 in zip(lista1, lista2) }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></a>\n",
    "</font></div>\n",
    "\n",
    "---\n",
    "\n",
    "<a id=\"section3D\"></a> \n",
    "## <font color=\"#1D65DD\" size=4> 8.4  Funciones filter, map y reduce </font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estas funciones permiten aplicar una función sobre los elementos de un iterable. Las tres funciones tienen dos argumentos: el primero es la función a aplicar, y el segundo es el objeto iterable sobre el que aplicarlos.\n",
    "\n",
    "* La función `filter` filtra los elementos del iterable en base al resultado una función que devuelve un booleano con cada elemento de la lista. Si es `True` permanece en el resultado, y si es `False` lo filtra.\n",
    "\n",
    "* La función `map` permite aplicar una función a cada uno de los elementos, generando un segundo iterable.\n",
    "\n",
    "* La función `reduce` permite combinar todos los elementos de la lista aplicando una finción, dos a dos iterativamente, hasta reducir a un solo elemento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3>  Filter</font>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filtrar los numeros impares\n",
    "l = range(10)\n",
    "def es_par(x):\n",
    "    return x % 2 == 0\n",
    "pares = filter(es_par, l)\n",
    "print(pares)\n",
    "print(list(pares))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ¡En este caso es mucho más cómodo usar funciones lambda!\n",
    "l = range(10)\n",
    "pares = filter(lambda x: x%2==0, l)\n",
    "print(pares)\n",
    "print(list(pares))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Map</font>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = range(10)\n",
    "def cuadrado(x):\n",
    "    return x**2\n",
    "cuadrados = map(cuadrado, l)\n",
    "print(cuadrados)\n",
    "print(list(cuadrados))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tanto las funciones filter, como map y reduce esperan funciones con 1 único parámetro (en el caso de filter y map)\n",
    "# o 2 parámetros (función reduce). \n",
    "# Si queremos aplicar una función con más parámetros, pero especificando un valor específico para un un subconjunto\n",
    "# de ellos (todos menos uno) se puede hacer mediante el uso de funciones lambda\n",
    "\n",
    "def suma(x, y):\n",
    "    return x + y\n",
    "l = range(10)\n",
    "# En este ejemplo queremos aplicar la función suma (2 parámetros), fijando uno de ellos a 10.\n",
    "cuadrados = map(lambda x: suma(x, 10), l)\n",
    "print(list(cuadrados))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color=\"#1D65DD\" size=3> Reduce</font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aunque en python 3.0 la función `reduce` se [eliminó](https://docs.python.org/3.0/whatsnew/3.0.html#builtins) como función `built-in` (y se movió a un módulo, llamado `functools`), es útil que la veamos porque será de utilidad en posteriores módulos (al menos conceptualmente).\n",
    "\n",
    "La razón por la que la movieron, según la documentación oficial, es:\n",
    "\n",
    "_\"Removed reduce(). Use functools.reduce() if you really need it; however, 99 percent of the time an explicit for loop is more readable.\"_\n",
    "\n",
    "Sin embargo, aunque puede resultar más dificil de leer, requiere menos código (evitamos el uso de bucles), y desde el punto de vista de la _programación funcional_ es más **intuitiva**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "l = range(10)\n",
    "suma = functools.reduce(lambda x, y: x+y, l)\n",
    "print(suma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: left\"><font size=4> <i class=\"fa fa-check-square-o\" aria-hidden=\"true\" style=\"color:#113D68\"></i>\n",
    " </font></div>\n",
    " \n",
    "<div style=\"text-align: right\"> <font size=5>\n",
    "    <a href=\"#indice\"><i class=\"fa fa-arrow-circle-up\" aria-hidden=\"true\" style=\"color:#004D7F\"></i></a>\n",
    "</font></div>"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}