optimizacion_de_codigo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimización del código\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objetivos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Reescribir llamadas a loops y map() como una list coprehension en Python\n",
    "* Elegir entre comprensiones, loops y map()\n",
    "* Potenciar tus comprensiones con lógica condicional\n",
    "* Usar comprensiones para reemplazar filter()\n",
    "* Perfilar el código para resolver preguntas de rendimiento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ## Introducción "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En los primeros tiempos de la informática, programar exigía utilizar lenguajes muy próximos a la plataforma de ejecución. El código máquina o el lenguaje ensamblador permiten un control muy fino del proceso de ejecución: cómo se asignan los registros del procesador, cómo se almacenan los datos y se accede a la memoria, … Así es posible exprimir la máxima eficiencia de una plataforma, aunque el precio a pagar es la falta de portabilidad y el mayor coste de desarrollo y mantenimiento del código.\n",
    "\n",
    "Afortunadamente, hoy en día podemos utilizar lenguajes de programación de alto nivel, que abstraen estos detalles de la plataforma y nos permiten ser más productivos resolviendo problemas más complejos en menos tiempo. Sin embargo, con esta transición a veces olvidamos que existen formas más optimas para realizar las tareas y muchas veces vemos que esto nos afecta hasta que ya todo está funcionando en producción, la idea de esta guía es recordarnos que hay algunas formas más optimas para realizar ciertas tareas, sin dejar atras la legibilidad del código."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usando list comprehensions\n",
    "Estas proporcionan una forma concisa de crear listas. Se componen de dos corchetes que contienen una expresión seguida por una cláusula **for** o **if**. Las expresiones pueden ser cualquier cosa , lo que significa que podemos utilizarlo en todo tipo de objetos dentro de las listas.\n",
    "\n",
    "El resultado será una nueva lista con el objeto creado a partir de la expresión en el contexto de las cláusulas **for** e **if** que le siguen.   \n",
    "Esto podemos verlo expresado como pseudocódigo de la siguiente manera:\n",
    "\n",
    "`new_list = [expression for item in iterable if conditional]`\n",
    "\n",
    "que se traduce a código como:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`new_list = [expression(i) for i in list_of_items if filter(i)]`\n",
    "\n",
    "el filtro nos ayudará a obtener unicamente los objetos que deseamos pero este puede omitirse si no es necesario.\n",
    "\n",
    "Un ejemplo de uso sería el siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = [x**2 for x in range(10)]\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso nuestra expression será el item actual de la iteración (**x**), y el iterable (**range(10)**) sin filtros o condicionales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.25, 0, 10.22, 3.78, 0, 1.16]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "original_prices = [1.25, -9.45, 10.22, 3.78, -5.92, 1.16]\n",
    "prices = [i if i > 0 else 0 for i in original_prices]\n",
    "prices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este ejemplo, podemos notar que aplicamos una condición a la lista.\n",
    "A demás de la facil lectura de este código podemos tener beneficios como la rapidéz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usando Lambdas\n",
    "Las funciones lambda también conocidas como abstracciones de lambda, tienen su origen en la lógica matemática y el cálculo de lambda, a diferencia de los lenguajes de programación imperativos que adoptan el modelo de computación basado en estados inventado por Alan Turing. Los dos modelos de computación, cálculo lambda y máquinas de Turing, se pueden traducir entre sí. Y esta equivalencia se conoce como la hipótesis de Church-Turing.\n",
    "Los lenguajes funcionales heredan directamente la filosofía del cálculo lambda, adoptando un enfoque declarativo de programación que enfatiza la abstracción, la transformación de datos, la composición y la pureza (sin estado ni efectos secundarios). Ejemplos de lenguajes funcionales incluyen Haskell, Lisp o Erlang.  \n",
    "\n",
    "Por el contrario, Turing Machine condujo a una programación imperativa que se encuentra en lenguajes como Fortran, C o Python.\n",
    "\n",
    "El estilo imperativo consiste en programar con declaraciones, conduciendo el flujo del programa paso a paso con instrucciones detalladas. Este enfoque promueve la mutación y requiere administrar los estados.\n",
    "\n",
    "Python no es inherentemente un lenguaje funcional, sin embargo varios conceptos de programación funcional fueron adoptados desde sus inicios en 1994 map(), filter(), reduce() y el operador lambda fue agregado un poco más tarde.\n",
    "\n",
    "Operador Lambda:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>(x)>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Imperativo:\n",
    "def identidad(x):\n",
    "    return x + 1\n",
    "# Se traduce a Funcional como:\n",
    "lambda x : x + 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# (lambda x: x + 1)(2) = lambda 2: 2 + 1\n",
    "#                   = 2 + 1\n",
    "#                  = 3\n",
    "#\n",
    "#\n",
    "#\n",
    "y = 2\n",
    "(lambda x: x + 1)(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usando map() objects\n",
    "map() proporciona un enfoque alternativo que se basa en la programación funcional . Como parametros pasamos una función y un iterable, y map()creará un objeto. Este objeto contiene el resultado que obtendríamos al ejecutar cada elemento iterable a través de la función proporcionada.\n",
    "\n",
    "Como ejemplo, consideremos una situación en la que necesitamos calcular el precio después de impuestos para una lista de transacciones:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.1772000000000002, 25.4448, 62.467200000000005, 4.9248, 7.322400000000001]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista_de_precios  =  [ 1.09 ,  23.56 ,  57.84 ,  4.56 ,  6.78 ] \n",
    "TAX_RATE  =  0.08 \n",
    "\n",
    "def  get_price_with_tax ( lista_de_precios ): \n",
    "    return  lista_de_precios  *  ( 1  +  TAX_RATE ) \n",
    "\n",
    "precios_con_impuestos  =  map ( get_price_with_tax ,  lista_de_precios ) \n",
    "list( precios_con_impuestos )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El resultado de este script almacena el objeto resultante en precios_con_impuestos. Podemos convertir fácilmente este objeto map en una lista usando list()."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicios:  \n",
    "1. considerando que podemos utilizar la función `str(\"\"\"string_en_minusculas\"\"\").upper()` para convertir cualquier string en un texto en mayusculas,   utiliza un map para convertir `my_text = \"Este es un texto Random\"` a un texto completamente en maysculas y luego imprimirlo como resultado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solución:\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Considerando que tenemos el siguiente objeto json `simple_dict` escribe una función que imprima el valor que contiene el key `\"nombre\"` usando lambda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'valeria'"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solución\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Ahora que sucede si en vez de un solo objeto json, tenemos un listado de objetos json?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a continuación podemos ver una comparativa de los distintos métodos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "comprehension:  1.4422237819999282\n",
      "loop:  1.8601072139999815\n",
      "lambda:  1.5124189440002738\n",
      "map:  1.2068358480000825\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import timeit\n",
    "TAX_RATE = .08 \n",
    "# Porque no podemos iterar sobre 100000 sin el range?\n",
    "txns = [random.randrange(100) for _ in range(100000)]\n",
    "def get_price(txn):\n",
    "    return txn * (1 + TAX_RATE)\n",
    "\n",
    "def get_prices_with_map():\n",
    "    return list(map(get_price, txns))\n",
    "\n",
    "def get_prices_with_lambda():\n",
    "    # Esta linea sustituye a la función get_price\n",
    "    get_price_lambda = lambda x : x * (1 + TAX_RATE) \n",
    "    \n",
    "    result = [get_price_lambda(txn) for txn in txns]\n",
    "    \n",
    "    return result\n",
    "\n",
    "def get_prices_with_comprehension():\n",
    "    return [get_price(txn) for txn in txns]\n",
    "\n",
    "def get_prices_with_loop():\n",
    "    prices = []\n",
    "    for txn in txns:\n",
    "        prices.append(get_price(txn))\n",
    "    return prices\n",
    "\n",
    "# timeit es una función que nos ayuda a medir el tiempo de ejecución de un método\n",
    "print(\"comprehension: \",timeit.timeit(get_prices_with_comprehension, number=100))\n",
    "print(\"loop: \",timeit.timeit(get_prices_with_loop, number=100))\n",
    "print(\"lambda: \", timeit.timeit(get_prices_with_lambda, number=100))\n",
    "print(\"map: \", timeit.timeit(get_prices_with_map, number=100))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como podemos notar en este caso en específico la opción más rapida es **map()**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sort\n",
    "\n",
    "El método Sort es inherente de Python por lo que podemos utilizarlo en muchos casos sin necesidad de importar bibliotecas, a continuación veremos algunos de los casos en los que se puede utilizar:\n",
    "\n",
    "#### Ordenando listas simples\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [3, 4, 2, 5, 9, 8, 6, 1, 7] \n",
    "  \n",
    "# las ordenamos en orden ascendente\n",
    "numbers.sort() \n",
    "\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ordenando una lista de listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Usando for loop y sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['Canada', 'France', 'Lanka', 'London', 'Machine'],\n",
       " ['Munich', 'Spain'],\n",
       " ['Australia', 'Mandi']]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_input = [['Machine', 'London', 'Canada', 'France', 'Lanka'], \n",
    "         ['Spain', 'Munich'], \n",
    "         ['Australia', 'Mandi']] \n",
    "  \n",
    "# ordenamos lista por lista dentro del for loop\n",
    "for sublist in my_input: \n",
    "    sublist.sort() \n",
    "  \n",
    "my_input # En este caso no necesitamos una nueva variable ya que el método sort se aplica directamente en la lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Usando map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['Canada', 'France', 'Lanka', 'London', 'Machine'],\n",
       " ['Munich', 'Spain'],\n",
       " ['Australia', 'Mandi']]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_input = [['Machine', 'London', 'Canada', 'France', 'Lanka'], \n",
    "         ['Spain', 'Munich'], \n",
    "         ['Australia', 'Mandi']] \n",
    "  \n",
    "# En este caso utilizamos map para acceder a cada item de las listas que están contenidas en la lista principal\n",
    "my_output = list(map(sorted, my_input)) \n",
    "  \n",
    "my_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Usando lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['Canada', 'France', 'London', 'Lanka', 'Machine'],\n",
       " ['Munich', 'Spain'],\n",
       " ['Australia', 'Mandi']]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_input = [['Machine', 'London', 'Canada', 'France', 'Lanka'], \n",
    "         ['Spain', 'Munich'], \n",
    "         ['Australia', 'Mandi']] \n",
    "  \n",
    "# en este caso lambda en conjunto con una list coprehension nos ayuda a accesar a la primera letra de cada item y ordenarla por medio de ella\n",
    "my_output = [sorted(x, key = lambda x:x[0]) for x in my_input] \n",
    "  \n",
    "my_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ordenando un diccionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 2, 5: 12, 6: 18, 4: 24, 2: 56, 3: 323}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "key_value = dict()     \n",
    "   \n",
    "# Inicializamos el diccionario  \n",
    "key_value[2] = 56       \n",
    "key_value[1] = 2 \n",
    "key_value[5] = 12 \n",
    "key_value[4] = 24\n",
    "key_value[6] = 18      \n",
    "key_value[3] = 323 \n",
    "   \n",
    "   \n",
    " # de esta forma lo ordenaremos en orden lexicográfico \n",
    " # Para ordenarlo matematicamente hay que cambiar los valores por floats\n",
    "result = sorted(key_value.items(), key = lambda kv:(kv[1], kv[0])) \n",
    "dict(result) # convertimos el listado de tuplas resultante en un dictionario nuevamente\n",
    "\n",
    "# Que nos genera key_value.items() ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2: 1, 12: 5, 18: 6, 24: 4, 56: 2, 323: 3}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict(map(reversed, result)) # podemos cambiar el key por el valor con el método \"reversed\" dentro de un map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ordenando una lista de diccionarios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'name': 'Nikhil', 'age': 19},\n",
       " {'name': 'Nandini', 'age': 20},\n",
       " {'name': 'Manjeet', 'age': 23}]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista_de_diccionarios = [{ \"name\" : \"Nandini\", \"age\" : 20},  \n",
    "{ \"name\" : \"Manjeet\", \"age\" : 23 }, \n",
    "{ \"name\" : \"Nikhil\" , \"age\" : 19 }] \n",
    "  \n",
    "# En este caso vamos a ordenarlos por la edad, para accesar a ese valor usaremos un lambda\n",
    "sorted(lista_de_diccionarios, key = lambda i: i['age']) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Convirtiendo listas a dicccionarios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 'c': 3}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Es más rapido hacerlo así? o con un for loop?\n",
    "keys = ['a', 'b', 'c']\n",
    "values = [1, 2, 3]\n",
    "dictionary = dict(zip(keys, values))\n",
    "dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CPU o RAM?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CPU\n",
    "El procesador o CPU es un elemento esencial dentro de cualquier equipo que ejecuta todo tipo de tareas, realiza operaciones de enteros y de coma flotante y también efectúa accesos a la memoria RAM.\n",
    "\n",
    "Podemos decir que todo pasa por el procesador y que el mismo se encarga de asignar tareas a otros componentes, como la tarjeta gráfica por ejemplo, aunque su importancia puede quedar parcialmente eclipsada por dicho componente en función del uso que vayamos a dar al equipo.\n",
    "\n",
    "#### RAM\n",
    "La memoria de acceso aleatorio, más conocida como memoria RAM por sus siglas en inglés, ejerce también una función vital, ya que sirve de *almacén temporal* para el sistema operativo y para todas las tareas y aplicaciones con las que estemos trabajando, evitando que el procesador tenga que volver a realizar ciertos trabajos ya que éstos quedan guardados en ella y se pueden recuperar en cualquier momento, siempre que no apaguemos el equipo.\n",
    "\n",
    "##### Entonces en que casos necesitamos más RAM y en que casos más CPU?\n",
    "\n",
    "La explicación más simplificada es que el CPU lo necesitamos para procesar datos como tal (transformar, hacer operaciones matemáticas, renderizar, etc) y la RAM la necesitamos para poder aplicar estas operaciones al mismo tiempo a una gran cantidad de datos, o para tener disponibles estos datos en el momento que los necesitamos sin ir de nuevo por ellos a la base de datos.  \n",
    "Entonces, veamos cada caso con un ejemplo:\n",
    "\n",
    "Suponiendo que queremos convertir una cadena de RNA a una proteína, primero, debemos obtener la cadena de RNA, suponiendo que lo hacemos desde una base de datos, estos datos son leídos y pasados a memoria RAM y una vez allí ya podemos aplicar la transformación de los datos a proteínas, este proceso lo realiza el CPU y finalmente los datos resultantes quedan de nuevo en memoria RAM (como proteína) hasta que los guardamos de nuevo en la base de datos.\n",
    "\n",
    "Ahora bien, si nuestra cadena de RNA fuese, por ejemplo la cadena completa de un humano, entonces nuestra RAM tiene que ser lo suficientemente amplia para poder almacenar tanto los datos de RNA como el resultante de proteína si queremos hacerlo todo en una sola iteración y ya es el CPU con sus distintos cores quien se encargará de procesarlo, en el caso que no tengamos suficiente RAM deberíamos de accesar a la base de datos y obtener pedazos de la cadena para procesarlas por separado, lo cual tomaría mucho más tiempo.\n",
    "\n",
    "Es aquí donde debemos decidir si necesitamos más RAM o más CPU y probablemente para algunas tareas nuestra computadora de escritorio no sea suficiente para que el código se ejecute en un tiempo razonable, o incluso puede que llene por completo la memoria RAM y ya no pueda seguir procesando los datos.\n",
    "\n",
    "En el caso de la conversión de RNA a proteína, necesitabamos más RAM debido al tamaño de los datos pero poco CPU debido a que el procesamiento no es tan complejo, sin embargo cuando estamos entrenando un modelo de deep learning es más probable que necesitemos más CPU o GPU y no tanta RAM ya que lo que más se necesita son operaciónes matemáticas que deben resolverse."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Highligts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La RAM sirve para almacenar datos en memoria mientras que el CPU los procesa, cuanto necesitamos de cada uno depende del tipo de tareas que vamos a ejecutar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Para generar data inicial en una lista podemos hacer una multiplicación de la lista con una string con la cantidad de items que necesitamos por ejemplo:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_lista = [\"a\"] * 10\n",
    "mi_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bibliografía"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "http://informatica.blogs.uoc.edu/2016/05/02/optimizacion-de-codigo-un-codigo-mas-eficiente/ Optimización de código: un código más eficiente 2016\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}