Introducción a Python - nivel medio.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Introducción a Python: nivel intermedio\n",
    "\n",
    "Python es un lenguaje muy extendido, con una rica comunidad que abarca muchos aspectos, muy fácil de aprender y programar con él, y que nos permite realizar un montón de tareas diferentes. Pero, no solo de pan vive. Python tiene muchas _librerías_ o _módulos_ que nos facilitan muchas tareas, que están respaldados por un gran número de personas detrás y que en muchos casos, realizan tareas específicas de una manera mucho más eficiente que haciéndolo puramente en Python.\n",
    "\n",
    "Este es el caso de librerías como ___NumPy___, ___Pandas___, ___scikit-learn___, ___Django___ y muchísimas más. \n",
    "\n",
    "Además de esto, aunque Python sea un lenguaje puramente imperativo, nos permite simular lo que se conoce como programación funcional, que viene directamente del _Lambda Calculus_, gracias al uso de las funciones ___lambda___.\n",
    "\n",
    "A continuación, veremos una introducción a _NumPy_ que nos sirve como puerta de entrada a un montón de módulos más, y la programación funcional con las funciones _lambda_.\n",
    "\n",
    "## NumPy\n",
    "\n",
    "NumPy es el paquete central que usaremos para tareas como ciencia de datos, o muchos cálculos matemáticos que requieren el uso de estructuras algebraicas como los vectores y matrices. Este paquete tiene la ventaja de que podemos trabajar cómodamente con la sintaxis de Python, creando estructuras $n$-dimensionales de forma sencilla y realizar complejas funciones sobre estas estructuras en una sola línea de código muy eficiente. \n",
    "\n",
    "Esta eficiencia se debe a que NumPy utiliza código C para realizar estos cálculos, que es mucho más rápido que la misma implementación en Python.\n",
    "\n",
    "Además de esto, otras de las grandes ventajas de NumPy es la documentación oficial que tiene, que es una de las más completas y bien documentadas que hay, ya que cubren muy bien todos los aspectos de las distintas funciones que tiene, además de incorporar una gran cantidad de ejemplos.\n",
    "\n",
    "### Instalación\n",
    "\n",
    "Para instalar NumPy tenemos que ejecutar la siguiente línea en nuestro terminal:\n",
    "```\n",
    "[braulio@braulio-PC ~]$ sudo pip install numpy\n",
    "```\n",
    "Con esto, gracias a pip, descargaremos e instalaremos NumPy. Así que, una vez instalados... a trabajar!!\n",
    "\n",
    "### Primeros pasos con NumPy\n",
    "\n",
    "Para empezar a trabajar con NumPy, lo primero es importar el paquete en nuestro script."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Con esta línea, ya tendremos en nuestro pequeño script el paquete listo para ser usado. Para acceder a los módulos tendremos que hacer `numpy.nombre_de_la_función`. Esto no es que este mal, pero por así decirlo, el estandar es importar NumPy como se ve a continuación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "De esta forma, vuestro código pasa a ser más legible, el resto de gente y mas cómodo y rápido de escribir. Además de que por convenio, debes importar NumPy como `np`.\n",
    "\n",
    "### Arrays de NumPy\n",
    "\n",
    "Numpy puede trabajar con arrays de $n$ dimensiones, pero los más comunes son los arrays de una, dos o tres dimensiones (1D, 2D, 3D). Además de esto, podemos establecer el tipo de los elementos del array a la hora de crearlo. Esto es muy importante, ya que si el array del tipo está determinado antes de ejecutar el script, Python no tiene que pararse a inferir el tipo de estos elementos, por lo que ganamos mucha velocidad.\n",
    "\n",
    "Además de esto, ciertas operaciones en NumPy, o librerías que requieren el uso de NumPy, necesitan que los operandos sean de un determinado tipo.\n",
    "\n",
    "A continuación vamos a crear una serie de arrays de distintas dimensiones a partir de una lista propia de Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array 1D:\n",
      " [ 1  5  6 79]\n",
      "Array 2D:\n",
      " [[  2.     5.3    0.    -1.99]\n",
      " [ 14.5    5.    -5.     1.  ]]\n",
      "Array 3D:\n",
      " [[[ 1  5  6 79]\n",
      "  [ 5  7  9  0]]\n",
      "\n",
      " [[ 1  5  6 79]\n",
      "  [ 5  7  9  0]]]\n"
     ]
    }
   ],
   "source": [
    "lista1D = [1, 5, 6, 79]\n",
    "lista2D = [[2, 5.3, 0, -1.99], [14.5, 5, -5., 1]]\n",
    "lista3D = [[[1, 5, 6, 79], [5, 7, 9, 0]], [[1, 5, 6, 79], [5, 7, 9, 0]]]\n",
    "\n",
    "uni_dimensional = np.array(lista1D, dtype=np.int32) # Los elementos de este array serán enteros de 32 bits\n",
    "bi_dimensional  = np.array(lista2D, dtype=np.float64) # En este caso, serán float de 64 bits\n",
    "tri_dimensional = np.array(lista3D) # Y en este caso? \n",
    "\n",
    "print(\"Array 1D:\\n\", uni_dimensional)\n",
    "print(\"Array 2D:\\n\", bi_dimensional)\n",
    "print(\"Array 3D:\\n\", tri_dimensional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Hay que tener encuenta que usar `np.array` requiere de un objeto ya existente, como en este caso son las listas utilizadas anteriormente. Este objeto es el que se inserta en el parámetro `object`. El otro parámetro más importante es `dtype` que nos sirve para indicar de qué tipo será el array que construyamos. Para más información sobre la creación de un array, puedes consultar la [documentación oficial](https://docs.scipy.org/doc/numpy/reference/generated/numpy.array.html#numpy.array).\n",
    "\n",
    "Además de crear arrays a partir de un objeto, NumPy nos ofrece la posibilidad de crear arrays \"vacíos\" o con valores predeterminados, gracias a las siguientes funciones:\n",
    "* __`np.ones`__: genera un array de unos.\n",
    "* __`np.zeros`__: genera un array de ceros.\n",
    "* __`np.random.random`__: genera un array de números aleatorios, `float` en el intervalo $[0,1]$.\n",
    "* __`np.full`__: similar a `np.ones` con la diferencia de que todos los valores serán iguales al que reciba como parámetro.\n",
    "* __`np.arange`__: genera un array con números dentro de un intervalo, con la frecuencia que queramos.\n",
    "* __`np.linspace`__: similar al anterior, solo que fijamos el intervalo y el número de elementos que queremos.\n",
    "* __`np.eye`__o __`np.identity`__: crean la matriz identidad.\n",
    "\n",
    "##### Ejercicio\n",
    "Ahora que hemos visto cómo crear arrays a partir de un objeto y otros para crear arrays con tipos prefijados, crea distintos arrays con las funciones anteriores para 1D, 2D y 3D e imprímelas por pantalla. Prueba a usar distintos tipos para ver cómo cambian los arrays. Si tienes dudas sobre cómo usarlos, puedes consultar la documentación oficial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Una vez creado nuestros arrays, podemos encontrar información muy útil sobre ellos en los propios atributos del array. Estos atributos nos pueden dar información sobre el número de dimensiones, el espacio en memoria que ocupa cada elemento, etc. Los más comunes y el acceso a esta información podemos verlos a continuación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "20\n",
      "  C_CONTIGUOUS : True\n",
      "  F_CONTIGUOUS : True\n",
      "  OWNDATA : True\n",
      "  WRITEABLE : True\n",
      "  ALIGNED : True\n",
      "  UPDATEIFCOPY : False\n",
      "8\n",
      "160\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(0.0,10.0,0.5)\n",
    "\n",
    "print(x.ndim) # Nos muestra el número de dimensiones que tiene el array\n",
    "\n",
    "print(x.size) # Muestra el número de elementos que tiene x\n",
    "\n",
    "print(x.flags) # Nos muestra la información de los distintos flags de x\n",
    "\n",
    "print(x.itemsize) # Nos muestra los bytes que ocupa un elemento de x\n",
    "\n",
    "print(x.nbytes) # Nos muestra el número total de bytes que ocupan los elementos de x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Además de esto, podemos acceder a un elemento del array, podemos acceder de la misma manera que se hace en las listas de Python, usando el operador `[]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_1d = np.arange(-5,5,1)\n",
    "array_1d[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "También podemos acceder a subconjuntos dentro del array usando el operador `[]` y el operador `:` de la siguente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2, -1,  0])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_1d[3:6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Y usando estos dos mismos operadores, por ejemplo, en los arrays bidimensionales podemos acceder a todos los elementos de una fila o una columna de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matriz aleatoria:\n",
      " [[ 0.36481215  0.55524168  0.59123213  0.03515903  0.53376552  0.58540817]\n",
      " [ 0.96293322  0.56818271  0.07974979  0.47830906  0.1140435   0.64796461]\n",
      " [ 0.28240222  0.35074404  0.20332803  0.85960016  0.27068901  0.80815698]\n",
      " [ 0.18559377  0.96641599  0.68036268  0.73089638  0.40971625  0.60344162]]\n",
      "Fila: \n",
      " [ 0.96293322  0.56818271  0.07974979  0.47830906  0.1140435   0.64796461]\n",
      "Columna: \n",
      " [ 0.03515903  0.47830906  0.85960016  0.73089638]\n",
      "Filas: \n",
      " [[ 0.96293322  0.56818271  0.07974979  0.47830906  0.1140435   0.64796461]\n",
      " [ 0.28240222  0.35074404  0.20332803  0.85960016  0.27068901  0.80815698]\n",
      " [ 0.18559377  0.96641599  0.68036268  0.73089638  0.40971625  0.60344162]]\n",
      "Columnas: \n",
      " [[ 0.59123213  0.03515903  0.53376552  0.58540817]\n",
      " [ 0.07974979  0.47830906  0.1140435   0.64796461]\n",
      " [ 0.20332803  0.85960016  0.27068901  0.80815698]\n",
      " [ 0.68036268  0.73089638  0.40971625  0.60344162]]\n",
      "Subconjunto de columnas: \n",
      " [[ 0.59123213  0.03515903  0.53376552]\n",
      " [ 0.07974979  0.47830906  0.1140435 ]]\n"
     ]
    }
   ],
   "source": [
    "array_random2d = np.random.random((4,6))\n",
    "print(\"Matriz aleatoria:\\n\", array_random2d)\n",
    "\n",
    "# Para acceder a todos los elementos de la segunda fila\n",
    "print(\"Fila: \\n\", array_random2d[1])\n",
    "\n",
    "# Para acceder a todos los elementos de la cuarta columna\n",
    "print(\"Columna: \\n\", array_random2d[:,3])\n",
    "\n",
    "# Filas de la segunda fila en adelante incluida esta\n",
    "print(\"Filas: \\n\", array_random2d[1:])\n",
    "\n",
    "# Columnas de la tercera columna en adelante\n",
    "print(\"Columnas: \\n\", array_random2d[:,2:])\n",
    "\n",
    "# Subconjuntos en filas y comunas\n",
    "print(\"Subconjunto de columnas: \\n\", array_random2d[0:2,2:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Ahora que ya sabemos cómo manejarnos con los arrays de NumPy, cómo crearlos y acceder a la información de ellos, ya podemos empezar a realizar operaciones matemáticas con ellos.\n",
    "\n",
    "##### Ejercicio\n",
    "\n",
    "Gracias a las distintas formas de indexar un array que nos permite NumPy, podemos hacer operaciones de forma vectorizada, evitando los bucles. Esto supone un incremento en la eficiencia del código y tener un código más corto y legible. Para ello, vamos a realizar el siguiente ejercicio. \n",
    "\n",
    "Genera una matriz aleatoria cuadrada de tamaño 1000. Una vez creada, genera una nueva matriz donde las filas y columnas 0 y $n-1$ estén repetidas 500 veces y el centro de la matriz quede exactamente igual a la original. Un ejemplo de esto lo podemos ver a continuación: $$\\left(\\begin{matrix} 1 & 2 & 3 \\\\ 2 & 3 & 4 \\\\ 3 & 4 & 5\\end{matrix}\\right) \\Longrightarrow \n",
    "\\left(\\begin{matrix} \n",
    "1 & 1 & 1 & 2 & 3 & 3 & 3 \\\\\n",
    "1 & 1 & 1 & 2 & 3 & 3 & 3 \\\\ \n",
    "1 & 1 & 1 & 2 & 3 & 3 & 3 \\\\ \n",
    "2 & 2 & 2 & 3 & 4 & 4 & 4 \\\\ \n",
    "3 & 3 & 3 & 4 & 5 & 5 & 5 \\\\ \n",
    "3 & 3 & 3 & 4 & 5 & 5 & 5 \\\\ \n",
    "3 & 3 & 3 & 4 & 5 & 5 & 5\n",
    "\\end{matrix}\\right) $$ \n",
    "\n",
    "Impleméntalo usando un bucle `for` y vectorizando el cálculo usando lo anteriormente visto para ver la diferencias de tiempos usando ambas variantes. Para medir el tiempo, puedes usar el módulo `time`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Operaciones con Arrays\n",
    "\n",
    "Ahora que ya hemos visto cómo crear y manejar arrays, podemos pasar a ver cómo realizar operaciones aritméticas con ellos. NumPy tiene funciones como `np.add`, `np.substract`, `np.multiply` y `np.divide` para sumar, restar, multiplicar y dividir arrays. También podemos calcular el módulo entre dos arrays usando `np.remainder`. Pero, no es necesario usar estas funciones como tal, sino que podemos usar nuestros operadores aritméticos de siempre: `+`, `-`, `*`, `/` y `%`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suma usando el operador +:\n",
      "\t [5 7 9]\n",
      "Suma usando np.add:\n",
      "\t [5 7 9]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "b = np.array([4, 5, 6])\n",
    "\n",
    "print(\"Suma usando el operador +:\\n\\t\", a + b)\n",
    "print(\"Suma usando np.add:\\n\\t\", np.add(a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "También podemos encontrar funciones para calcular el coseno entre dos arrays, el producto vectorial, elevar a un exponente un array. Todas las funciones matemáticas las podemos encontrar en la [documentación](https://docs.scipy.org/doc/numpy/reference/routines.math.html).\n",
    "\n",
    "Otro módulo muy importante de NumPy es el de álgebra lineal, que podemos acceder a las funciones de este módulo haciendo `np.linalg`. Este módulo contiene operaciones como el producto vectorial de dos arrays, la descomposición en valores singulares, funciones para resolver sistemas de ecuaciones, etc. Una vez más, la [documentación](https://docs.scipy.org/doc/numpy/reference/routines.linalg.html) es nuestra amiga y en ella podemos encontrar toda la información sobre estas funciones, junto con ejemplos de uso.\n",
    "\n",
    "##### Ejercicio\n",
    "\n",
    "Una matriz de rotación $R$ es una matriz que representa una rotación en el espacio euclídeo. Esta matriz $R$ se representa como $$R=\\left(\\begin{matrix} \\cos\\theta & -\\sin\\theta \\\\ \\sin\\theta & -\\cos\\theta \\end{matrix}\\right)$$ donde $\\theta$ es el número de ángulos rotados en sentido antihorario.\n",
    "\n",
    "Estas matrices son muy usadas en geometría, informática o física. Un ejemplo de uso de estas matrices puede ser el cálculo de una rotación de un objeto en un sistema gráfico, la rotación de una cámara respecto a un punto en el espacio, etc.\n",
    "\n",
    "Estas matrices tienen como propiedades que son ___matrices ortogonales___ (su inversa y su traspuesta son iguales) y su ___determinante es igual a 1___. Por tanto, genera un array y muestra si ese array es una matriz de rotación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### Ejercicio\n",
    "\n",
    "Dados el array que se ve a continuación, realiza los siguientes apartados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "array1 = np.array([ -1., 4., -9.])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "1. Multiplica `array1` por $\\frac{\\pi}{4}$ y calcula el seno del array resultante.\n",
    "2. Genera un nuevo array cuyo valor sea el doble del resultado anterior mas el vector `array1`.\n",
    "3. Calcula la norma del vector resultante. Para ello, consulta la documentación para ver qué función realiza esta tarea, y ten en cuenta los parámetros que recibe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Operaciones lógicas\n",
    "\n",
    "Además de las funciones algebraicas y aritméticas, también podemos hacer uso de los operadores lógicos para comparar dos arrays. Por ejemplo, si queremos comparar elemento a elemento si son iguales dos arrays, usaremos el operador `==`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False False  True False  True]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 2, -1, 5])\n",
    "b = np.array([0, 1, 2, 42, 5])\n",
    "\n",
    "print(a == b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Lo mismo sucede con los operadores de comparación `<` y `>`, que comparan elemento a elemento según el operador que hayamos decidido usar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Operador <:\t [False False False  True False]\n",
      "Operador >:\t [ True  True False False False]\n",
      "Operador <=:\t [False False  True  True  True]\n"
     ]
    }
   ],
   "source": [
    "print(\"Operador <:\\t\", a < b)\n",
    "print(\"Operador >:\\t\", a > b)\n",
    "print(\"Operador <=:\\t\", a <= b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Pero, en el caso de que queramos comparar si dos arrays son completamente iguales, devolviendo un único valor que sea `True` o `False`, debemos usar la función `np.array_equal(array_1, array_2)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "¿Son iguales a y b? False\n"
     ]
    }
   ],
   "source": [
    "print(\"¿Son iguales a y b?\", np.array_equal(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "También están disponibles los operadores lógicos `&` y `|` para realizar operaciones lógicas con ellas. Sin embargo, NumPy también ofrece las funciones `np.logical_and()`, `np.logical_or()` para realizar estas operaciones y `np.logical_not` para negar el array.\n",
    "\n",
    "Otras funciones a las que tenemos acceso son a funciones que nos ofrecen datos estadísticos como la _media_ o la _desviación típica_, o el valor de la suma de una fila de un array, etc. A continuación, podemos ver algunas de las que ofrece:\n",
    "* __`array.sum()`__: devuelve la suma total de los componentes del array.\n",
    "* __`array.min()`__: devuelve el mínimo valor del array.\n",
    "* __`array.max()`__: devuelve el valor máximo de la fila o la columna, dependiendo del valor que tenga el parámetro `axis`.\n",
    "* __`array.cumsum()`__: nos devuelve un nuevo array donde cada elemento es la suma acumulativa de los elementos del array. Al igual que antes, es dependiente del parámetro `axis`.\n",
    "* __`array.mean()`__: para obtener la media.\n",
    "* __`array.median()`__: para obtener la mediana.\n",
    "* __`np.std(array)`__: para obtener la desviación típica del array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### Ejercicio\n",
    "\n",
    "Dada la siguiente matriz, realiza los siguientes apartados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "n_array1 =  np.array([[ 1., 3., 5.], [7., -9., 2.], [4., 6., 8.]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "1. Calcula la media y la desviación típica de la matriz.\n",
    "2. Obtén el elemento mínimo y máximo de la matriz.\n",
    "3. Calcula el determinante, la traza y la traspuesta de la matriz.\n",
    "4. Calcula la descomposición en valores singulares de la matriz.\n",
    "5. Calcula el valor de la suma de los elementos de la diagonal principal de la matriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Salvar arrays de NumPy en ficheros\n",
    "\n",
    "Hay veces que en nuestro problema podemos generar matrices de un tamaño considerable, y que el tiempo de cómputo que hemos necesitado para obtener esa matriz es demasiado grande como para permitirnos el lujo de generarlo de nuevo, o simplemente no es posible reproducir los cálculos.\n",
    "\n",
    "Es por ello que NumPy ofrece una solución, y es que nos permite el poder salvar estos arrays en ficheros gracias a las funciones `save`, `savetxt`, `savez` o `savez_compressed`.\n",
    "* __`save`__: guarda el array en un fichero binario de NumPy. Este fichero tiene como formato _.npy_.\n",
    "* __`savetxt`__: guarda el array en un fichero de texto.\n",
    "* __`savez`__: guarda varios arrays en un mismo fichero sin comprimir. Este fichero tiene formato _.npz_.\n",
    "* __`savez_compressed`__: similar al anterior pero en este caso el fichero estará comprimido. Su formato también es _.npz_.\n",
    "\n",
    "Para más infomración y ejemplos de uso, siempre podréis consultar la documentación oficial.\n",
    "\n",
    "### Quiero más ejercicios para seguir entrenando con NumPy\n",
    "\n",
    "Existe un repositorio en GitHub lleno de ejercicios que cubren un gran número de módulos y funciones de NumPy, con las soluciones a dichos ejercicios. Estos ejercicios, al igual que esta breve introducción, se encuentran en _jupyter-notebooks_ que podemos descargar y manipular. Este repositorio se encuentra [aquí](https://github.com/Kyubyong/numpy_exercises). Y recordar que siempre que useis un repositorio en GitHub y os ha sido de utilidad, dadle ___star___ al repositorio.\n",
    "\n",
    "## Funciones _lambda_ ($\\lambda$)\n",
    "\n",
    "Las funciones `lambda` se utilizan para declarar pequeñas funciones anónimas con un objetivo claro. Su comportamiento es parecido a las funciones que declaramos con `def`, aunque no son exactamente iguales.\n",
    "\n",
    "Estas funciones `lambda` se asocian a una única expresión, por lo que elementos como `return` no están permitidos al igual que tampoco están permitidos los bloques de sentencias. Además de esto, las funciones `lambda` no tienen porque estar asociadas a un nombre en concreto, como lo hacen de forma obligatoria las funciones definidas con `def`. Vamos a ver un ejemplo a continuación.\n",
    "\n",
    "En este ejemplo, vamos a hacer una función que recibe como parámetros dos elementos y devuelve la suma de ellos. Pero, vamos a definirlo primero como una función `lambda` y luego con una función clásica con `def`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suma con lambda:  5\n",
      "Suma con def:  5\n"
     ]
    }
   ],
   "source": [
    "# Definimos la función lambda de esta manera\n",
    "suma_l = lambda x, y: x + y\n",
    "\n",
    "print(\"Suma con lambda: \", suma_l(4,1))\n",
    "\n",
    "def suma(x,y):\n",
    "    return x+y\n",
    "\n",
    "print(\"Suma con def: \", suma(4,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Como podemos ver, ambas funciones dan el mismo resultado, así que, ¿para qué aprender a usar funciones `lambda`? Bueno, con estas funciones podemos hacer cosas como se ve a continuación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda x, y: 2*(x+y))(5,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "¿Qué ha pasado aquí? Pues bien, para empezar, esto es una de las ventajas de las funciones `lambda`, que podemos crear funciones anónimas en una sola línea, con un uso específico como acaba de pasar aquí, que no está asociada a ningún nombre en específico como pasa con las funciones `def`. Concretamente, lo que acaba de pasar es que hemos declarado una función `lambda` que recibe dos parámetros, $x$ e $y$, los suma y los multiplica por dos.\n",
    "\n",
    "Acto seguido, hemos pasado como parámetros los dos números que van a realizar la operación, como parámetros de la función `lambda`, que se suman, se multiplican por dos y automáticamente se devuelven. \n",
    "\n",
    "Además, aquí podemos ver una de las diferencias con las funciones clásicas, y es que en las funciones `lambda` existe un `return` implícito. Es decir, una vez realizadas todas las operaciones que hay definidas en la función `lambda` automáticamente se devuelve este valor.\n",
    "\n",
    "Otra diferencia es que las funciones `lambda` son expresiones, no sentencias, por lo que pueden aparecer en sitios donde por la sintaxis de Python, no puede aparecer un `def`. \n",
    "\n",
    "También tienen otras peculiaridades, como el que no se puede crear dentro de una función `lambda` un bloque `if-else` como el que estamos acostumbrados, sino que se tiene que expresar como vemos a continuación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mínimo entre 2 y 5:  2\n"
     ]
    }
   ],
   "source": [
    "get_min = lambda x, y: x if x < y else y\n",
    "\n",
    "print(\"Mínimo entre 2 y 5: \", get_min(2,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "También son capaces de realizar bucles internos y llamar a funciones como `map`, usar las expresiones de comprensión de listas, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Un\n",
      "Dos\n",
      "Tres\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "pinta = lambda x: list(map(sys.stdout.write, x))\n",
    "\n",
    "lista = pinta(['Un\\n', 'Dos\\n', 'Tres\\n'])\n",
    "\n",
    "bucle = lambda x: [i for i in range(0,10) if i%x==0]\n",
    "\n",
    "bucle(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Cuándo usar funciones lambda\n",
    "\n",
    "Uno de los mejores momentos para usar una función `lambda`, es el momento en el que vamos a usar una función para ordenar los elementos de una lista, siguiendo un orden en concreto. Este orden se puede definir usando una función, así que, qué mejor que usar una función `lambda` para establecer este orden y al ser una función anónima, no es necesario predefinirla. Vamos a ver un ejemplo de esto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista inicial con range:\t [-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Lista ordenada con lambda:\t [0, -1, 1, -2, 2, -3, 3, -4, 4, -5, 5, -6, 6, -7, 7, -8, 8, -9, 9, -10]\n"
     ]
    }
   ],
   "source": [
    "ini = list(range(-10, 10,))\n",
    "print(\"Lista inicial con range:\\t\", ini)\n",
    "\n",
    "# ¿Y si la queremos ordenada de esta manera?\n",
    "# [0, -1, 1, -2, 2, ...]\n",
    "sorted_list = sorted(range(-10, 10), key=lambda x: x**2)\n",
    "print(\"Lista ordenada con lambda:\\t\", sorted_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "También podemos hacer que una función `lambda` actúe como una ___clausura léxica___. Pero, ¿qué es una clausura? Una clausura léxica es un nombre para una función que recuerda los valores que se encuentran en un cierto espacio de nombres, incluso cuando el flujo de ejecución del programa no se encuentra en ese espacio de nombres. Vamos a ver un ejemplo de esto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suma 5:  10\n",
      "Suma 10:  15\n"
     ]
    }
   ],
   "source": [
    "def suma_n(n):\n",
    "    return lambda x: x+n\n",
    "\n",
    "suma5 = suma_n(5)\n",
    "suma10 = suma_n(10)\n",
    "\n",
    "print(\"Suma 5: \", suma5(5))\n",
    "print(\"Suma 10: \",suma10(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Otro uso muy conocido de las funciones `lambda` es el uso de estas en las funciones `filter` o `map`, ya que podemos filtrar elementos que cumplan una serie de condiciones, haciendo uso de la ***Programación Funcional***.\n",
    "\n",
    "La _programación funcional_ es un paradigma de programación que evalua las expresiones al igual que se hace en matemáticas, es decir, se evalua la expresión, se devuelve un resultado y los operandos quedan inmutables. Esto hace que dada una función $f$ que realiza una tarea determinada, siempre devuelva el mismo resultado si recibe como parámetro el elemento $x$. Esto es conocido como ___transparencia referencial___. Esta programación funcional se basa mucho en el [$\\lambda$-_calculus_](https://en.wikipedia.org/wiki/Lambda_calculus]).\n",
    "\n",
    "Python, aunque sea un lenguaje por naturaleza imperativo, tiene la posibilidad de emular esta programación funcional y emular también la transparencia referencial, usando las funciones `lambda` que hemos visto, y funciones como `filter`, `map` o `reduce`, que gracias a la programación funcional, nos permite hacer en una sola línea de código lo que haríamos en bastante más escribiendo de forma \"clásica\", y de forma más eficiente y elegante.\n",
    "\n",
    "#### Función `map`\n",
    "\n",
    "La función `map` recibe como parámetros una función y una lista o `sequence`. `map` aplica la función que recibe como entrada sobre la lista y devuelve un generador (en Python 2 devuelve una lista). Un generador es una estructura de Python que actúa como un iterador. Por ejemplo, al usar la función `range(5)`, obtenemos un generador de números enteros de 0 a 5. Los elementos de este generador los podemos obtener todos del tirón haciendo `list(range(5))` o bien, sacarlos de uno en uno en un bucle `for i in range(5)`. Una vez generados estos elementos, desaparecen del generador (obviamente).\n",
    "\n",
    "Vamos a ver un ejemplo a continuación, en el que usaremos la función `map` sin y con funciones `lambda`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista transformada:  [3.141592653589793, 4.363323129985823, 0.0, 0.3141592653589793, 3.735004599267865]\n",
      "Lista transformada con lambda:  [3.141592653589793, 4.363323129985823, 0.0, 0.3141592653589793, 3.735004599267865]\n"
     ]
    }
   ],
   "source": [
    "from numpy import pi\n",
    "\n",
    "# Definimos nuestra lista que queremos transformar\n",
    "degrees = [180, 250, 0, 18, 214, ]\n",
    "\n",
    "# Pasar de grados a radianes\n",
    "def deg2rad(deg):\n",
    "    return deg * pi/180\n",
    "\n",
    "rads_generator = map(deg2rad, degrees)\n",
    "\n",
    "print(\"Lista transformada: \", list(rads_generator))\n",
    "\n",
    "# En caso de que queramos extraerlos de uno en uno:\n",
    "# for rads in rads_generator:\n",
    "#     print(rads)\n",
    "\n",
    "rads_generator_lambda = map(lambda x: x*pi/180, degrees)\n",
    "print(\"Lista transformada con lambda: \", list(rads_generator_lambda))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Como puedes ver, el código usado escribiendo la función `lambda` es mucho menor que usando una función `def` y más limpio. Además, no es necesario definir una función y asociarla a un nombre para hacer esta tarea.\n",
    "\n",
    "Además de esto, también podemos hacer una función `map` a varias listas a la vez. El único requisito es que estas listas sean de la misma longitud."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Resultado:  [12, 16, 20, 24]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3, 4]\n",
    "b = [5, 6, 7, 8]\n",
    "\n",
    "result = list(map(lambda x, y: 2*(x+y), a, b))\n",
    "print(\"Resultado: \", result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Función `filter`\n",
    "\n",
    "La función `filter` es la manera elegante de filtrar nuestras listas y eliminar aquellos elementos que no cumplan cierta condición. Al igual que `map`, recibe como parámetros una función y una _sequence_. Por ejemplo, vamos a extraer los elementos pares e impares de la sucesión de Fibonacci en listas separadas usando `filter`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049] ... [353410009178752575339944833520459068284945046358154977604109175253890696634271360121583566110064725510836075851584985143412396868586425109102723291106570618750075392710633321729992106743321640281356794177320, 571829406815633979529643697006273045106845980748991112071673038743714031497887739023091610769764627307772654802298784361803421747114571265690519449915873452164193174293407940201977897716937097604164288130909, 925239415994386554869588530526732113391791027107146089675782213997604728132159099144675176879829352818608730653883769505215818615700996374793242741022444070914268567004041261931970004460258737885521082308229, 1497068822810020534399232227533005158498637007856137201747455252741318759630046838167766787649593980126381385456182553867019240362815567640483762190938317523078461741297449202133947902177195835489685370439138, 2422308238804407089268820758059737271890428034963283291423237466738923487762205937312441964529423332944990116110066323372235058978516564015277004931960761593992730308301490464065917906637454573375206452747367, 3919377061614427623668052985592742430389065042819420493170692719480242247392252775480208752179017313071371501566248877239254299341332131655760767122899079117071192049598939666199865808814650408864891823186505, 6341685300418834712936873743652479702279493077782703784593930186219165735154458712792650716708440646016361617676315200611489358319848695671037772054859840711063922357900430130265783715452104982240098275933872, 10261062362033262336604926729245222132668558120602124277764622905699407982546711488272859468887457959087733119242564077850743657661180827326798539177758919828135114407499369796465649524266755391104990099120377, 16602747662452097049541800472897701834948051198384828062358553091918573717701170201065510185595898605104094736918879278462233015981029522997836311232618760539199036765399799926731433239718860373345088375054249, 26863810024485359386146727202142923967616609318986952340123175997617981700247881689338369654483356564191827856161443356312976673642210350324634850410377680367334151172899169723197082763985615764450078474174626]\n"
     ]
    }
   ],
   "source": [
    "def Fibonacci(n):\n",
    "    a, b = 0, 1\n",
    "    yield a\n",
    "    yield b\n",
    "    i = 0\n",
    "    while i < n-2:\n",
    "        a, b = b, a + b\n",
    "        yield b\n",
    "        i+=1\n",
    "\n",
    "pybonacci = list(Fibonacci(1000))\n",
    "print(pybonacci[0:50], '...', pybonacci[-10:])\n",
    "# Obtenemos los pares\n",
    "even = list(filter(lambda x: x%2==0, pybonacci))\n",
    "# Y los impares\n",
    "odd = list(filter(lambda x: x%2!=0, pybonacci))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Impares:\n",
      " [1, 1, 3, 5, 13, 21, 55, 89, 233, 377, 987, 1597, 4181, 6765, 17711, 28657, 75025, 121393, 317811, 514229, 1346269, 2178309, 5702887, 9227465, 24157817, 39088169, 102334155, 165580141, 433494437, 701408733, 1836311903, 2971215073, 7778742049, 12586269025, 32951280099, 53316291173, 139583862445, 225851433717, 591286729879, 956722026041, 2504730781961, 4052739537881, 10610209857723, 17167680177565, 44945570212853, 72723460248141, 190392490709135, 308061521170129, 806515533049393, 1304969544928657] ... 3919377061614427623668052985592742430389065042819420493170692719480242247392252775480208752179017313071371501566248877239254299341332131655760767122899079117071192049598939666199865808814650408864891823186505\n"
     ]
    }
   ],
   "source": [
    "print(\"Impares:\\n\", odd[:50], \"...\", odd[-3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pares:\n",
      " [0, 2, 8, 34, 144, 610, 2584, 10946, 46368, 196418, 832040, 3524578, 14930352, 63245986, 267914296, 1134903170, 4807526976, 20365011074, 86267571272, 365435296162, 1548008755920, 6557470319842, 27777890035288, 117669030460994, 498454011879264, 2111485077978050, 8944394323791464, 37889062373143906, 160500643816367088, 679891637638612258, 2880067194370816120, 12200160415121876738, 51680708854858323072, 218922995834555169026, 927372692193078999176, 3928413764606871165730, 16641027750620563662096, 70492524767089125814114, 298611126818977066918552, 1264937032042997393488322, 5358359254990966640871840, 22698374052006863956975682, 96151855463018422468774568, 407305795904080553832073954, 1725375039079340637797070384, 7308805952221443105020355490, 30960598847965113057878492344, 131151201344081895336534324866, 555565404224292694404015791808, 2353412818241252672952597492098] ... 1497068822810020534399232227533005158498637007856137201747455252741318759630046838167766787649593980126381385456182553867019240362815567640483762190938317523078461741297449202133947902177195835489685370439138\n"
     ]
    }
   ],
   "source": [
    "print(\"Pares:\\n\", even[:50], \"...\", even[-3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Función `reduce`\n",
    "\n",
    "La función `reduce` se encarga de, tal y como dice su nombre, reducir una lista a un único valor, mediante una función que hayamos definido. A diferencia de las otras dos, esta función no se encuentra en el ámbito por defecto de Python, es decir, no podemos acceder a ella cargando simplemente el prompt de Python en Python 3.\n",
    "\n",
    "Para poder usarla, tenemos que hacer lo siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "from functools import reduce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Con esto, ya podemos utilizar la función `reduce`. Al igual que las anteriores, recibe como primer argumento una función que aplicar sobre la lista que recibe como segundo argumento. Vamos a ver un ejemplo de cómo calcular el factorial de un número en una sola línea."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Factorial de un 10:  3628800\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "fact = reduce(lambda x,y:x*y, range(1,n+1))\n",
    "print(\"Factorial de un 10: \", fact)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### Ejercicio\n",
    "\n",
    "A veces, es necesario en nuestro problema, tener que eliminar los elementos repetidos de una lista, dejando aquellos que solo aparezcan una sola vez. Es muy común, que muchos usuarios llamen a la función `set` para esta tarea, haciendo de la lista un conjunto sin elementos repetidos, ordenándolos y luego, el resultado de esto, volverlo a convertir en una lista. Esto, puede no estar mal del todo, pero puede ser que en el caso peor, puede que estemos haciendo un gasto inútil de memoria, tiempo y cálculos, para que, en el caso de que no haya elementos repetidos, sólo obtengamos una lista ordenada.\n",
    "\n",
    "Es por ello, por lo que existe otra forma de hacerlo. Utilizando lo ya visto, obtén una lista sin elementos repetidos que mantengan el orden de la lista original. Para hacerlo aún más divertido, no uses más de 4 líneas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}