{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../static/aeropython_name_mini.png\" alt=\"AeroPython\" style=\"width: 300px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clase 2a: Introducción a NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Hasta ahora hemos visto los tipos de datos más básicos que nos ofrece Python: integer, real, complex, boolean, list, tuple...  Pero ¿no echas algo de menos? Efectivamente, los __arrays__. _\n",
    "\n",
    "_Durante esta nos adentraremos en el paquete NumPy: veremos como los arrays mejoran la eficiencia de nuestro código, aprenderemos a crearlos y a operar con ellos_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ¿Qué es un array? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un array es un __bloque de memoria que contiene elementos del mismo tipo__. Básicamente:\n",
    "\n",
    "* nos _recuerdan_ a los vectores, matrices, tensores...\n",
    "* podemos almacenar el array con un nombre y acceder a sus __elementos__ mediante sus __índices__.\n",
    "* ayudan a gestionar de manera eficiente la memoria y a acelerar los cálculos.\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "| Índice     | 0     | 1     | 2     | 3     | ...   | n-1   | n  |\n",
    "| ---------- | :---: | :---: | :---: | :---: | :---: | :---: | :---: |\n",
    "| Valor      | 2.1   | 3.6   | 7.8   | 1.5   | ...   | 5.4   | 6.3 |\n",
    "\n",
    "---\n",
    "\n",
    "__¿Qué solemos guardar en arrays?__\n",
    "\n",
    "* Vectores y matrices.\n",
    "* Datos de experimentos:\n",
    "    - En distintos instantes discretos.\n",
    "    - En distintos puntos del espacio.\n",
    "* Resultado de evaluar funciones con los datos anteriores.\n",
    "* Discretizaciones para usar algoritmos de: integración, derivación, interpolación...\n",
    "* ... "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ¿Qué es NumPy?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy es un paquete fundamental para la programación científica que __proporciona un objeto tipo array__ para almacenar datos de forma eficiente y una serie de __funciones__ para operar y manipular esos datos.\n",
    "Para usar NumPy lo primero que debemos hacer es importarlo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.9.0'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "#para ver la versión que tenemos instalada:\n",
    "np.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nuestro primer array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿No decíamos que Python era fácil? Pues __creemos nuestros primeros arrays__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Array de una dimensión\n",
    "mi_primer_array = np.array([1, 2, 3, 4]) \n",
    "mi_primer_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "# Podemos usar print\n",
    "print(mi_primer_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comprobar el tipo de mi_primer_array\n",
    "type(mi_primer_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comprobar el tipo de datos que contiene\n",
    "mi_primer_array.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los arrays de una dimensión se crean pasándole una lista como argumento a la función `np.array`. Para crear un array de dos dimensiones le pasaremos una _lista de listas_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Array de dos dimensiones\n",
    "mi_segundo_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">Podemos continuar en la siguiente línea usando `\\`, pero no es necesario escribirlo dentro de paréntesis o corchetes</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esto sería una buena manera de definirlo, de acuerdo con el [PEP 8 (indentation)](http://legacy.python.org/dev/peps/pep-0008/#indentation):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mi_segundo_array = np.array([\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9]\n",
    "    ]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones y constantes de NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hemos dicho que NumPy también incorporá __funciones__. Un ejemplo sencillo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Suma\n",
    "np.sum(mi_primer_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Máximo\n",
    "np.max(mi_primer_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.84147098,  0.90929743,  0.14112001],\n",
       "       [-0.7568025 , -0.95892427, -0.2794155 ],\n",
       "       [ 0.6569866 ,  0.98935825,  0.41211849]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Seno\n",
    "np.sin(mi_segundo_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y algunas __constantes__ que podemos neccesitar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.141592653589793, 2.718281828459045)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.pi, np.e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Características de los arrays de NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El objeto tipo array que proporciona NumPy (Python ya dispone de un tipo array que sirve para almacenar elementos de igual tipo pero no proporciona toda la artillería matemática necesaria como para hacer operaciones de manera rápida y eficiente) se caracteriza por:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1) Homogeneidad de tipo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comencemos viendo que ocurre con las __listas__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, (1+2j), True, 'aerodinamica', [1, 2, 3]]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [ 1, 1+2j, True, 'aerodinamica', [1, 2, 3] ]\n",
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el caso de los __arrays__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['1', '(1+2j)', 'True', 'aerodinamica'], \n",
       "      dtype='<U64')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array = np.array([ 1, 1+2j, True, 'aerodinamica'])\n",
    "array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__¿Todo bien? Pues no__. Mientras que en la lista cada elemento conserva su tipo, en el array, todos han de tener el mismo y NumPy ha considerado que todos van a ser string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2) Tamaño fijo en el momento de la creación:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__¡Tranquilo!__ los __allocate__ son automáticos...\n",
    "\n",
    "Igual que en el caso anterior, comencemos con la __lista__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "139998521305288\n",
      "[1, (1+2j), True, 'aerodinamica', [1, 2, 3], 'fluidos']\n",
      "139998521305288\n"
     ]
    }
   ],
   "source": [
    "print(id(lista))\n",
    "lista.append('fluidos')\n",
    "print(lista)\n",
    "print(id(lista))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "139998351447504\n",
      "['1' '(1+2j)' 'True' 'aerodinamica' 'fluidos']\n",
      "139998351448304\n"
     ]
    }
   ],
   "source": [
    "print(id(array))\n",
    "array = np.append(array, 'fluidos')\n",
    "print(array)\n",
    "print(id(array))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si consultamos la ayuda de la función `np.append` escribiendo en una celda `help(np.append)` podemos leer:\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    append : ndarray\n",
    "        A copy of `arr` with `values` appended to `axis`.  Note that `append` does not occur in-place: a new array is allocated and filled.  If `axis` is None, `out` is a flattened array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3) Eficiencia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hasta el momento los arrays han demostrado ser bastante menos flexibles que las listas, luego olvidemos estos últimos 10 minutos y manejemos siempre listas... ¿no? ¡Pues no! Los arrays realizan una gestión de la memoria mucho más eficiente que mejora el rendimiento.\n",
    "\n",
    "Prestemos atención ahora a la velocidad de ejecución gracias a la _función mágica_ `%%timeit`, que colocada al inicio de una celda nos indicará el tiempo que tarda en ejecutarse. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = list(range(0,100000))\n",
    "type(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000 loops, best of 3: 1.61 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "sum(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "array = np.arange(0, 100000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000 loops, best of 3: 98.2 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "np.sum(array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como ves, las mejoras en este caso son de 2 órdenes de magnitud. __NumPy nos ofrece funciones que se ejecutan prácticamente en tiempos de lenguaje compilado (Fortran, C, C++) y optimizado, pero escribiendo mucho menos código y con un nivel de abstracción mayor__. Conociendo una serie de buenas prácticas, podremos competir en velocidad con nuestros códigos en Python. Para casos en los que no sea posible, existen herramientas que nos permiten ejecutar desde Python nuestros códigos en otros lengujes como [f2py](http://docs.scipy.org/doc/numpy-dev/f2py/). Este tema puede resultarte algo avanzado a estas alturas, pero bastante útil; puedes consultar este [artículo de pybonacci](http://pybonacci.org/2013/02/22/integrar-fortran-con-python-usando-f2py/9) si lo necesitas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones para crear arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Demasiada teoría? vayamos a la práctica. Ya hemos visto que la función `np.array()` nos permite crear arrays con los valores que nosotros introduzcamos manualmente a través de listas. Más adelante, aprenderemos a leer ficheros y almacenarlos en arrays. Mientras tanto, ¿qué puede hacernos falta?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### array de ceros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,\n",
       "        0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,\n",
       "        0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,\n",
       "        0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,\n",
       "        0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,\n",
       "        0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,\n",
       "        0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,\n",
       "        0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# En una dimensión\n",
    "np.zeros(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# En dos dimensiones\n",
    "np.zeros([10,10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\"><strong>Nota:</strong> \n",
    "En el caso 1D es válido tanto `np.zeros([5])` como `np.zeros(5)` (sin los corchetes), pero no lo será para el caso nD\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### array \"vacío\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  6.91684881e-310,   2.03912117e-316,   0.00000000e+000,\n",
       "         0.00000000e+000,   0.00000000e+000,   0.00000000e+000,\n",
       "         0.00000000e+000,   0.00000000e+000,   0.00000000e+000,\n",
       "         0.00000000e+000])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.empty(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-error\"><strong>Importante:</strong> \n",
    "El array vacío se crea en un tiempo algo inferior al array de ceros. Sin embargo, el valor de sus elementos será arbitrario y dependerá del estado de la memoria. Si lo utilizas asegúrate de que luego llenas bien todos sus elementos porque podrías introducir resultados erróneos.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### array de unos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  1.],\n",
       "       [ 1.,  1.],\n",
       "       [ 1.,  1.]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones([3,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\"><strong>Nota:</strong> \n",
    "Otras funciones muy útiles son `np.zeros_like` y `np.ones_like`. Usa la ayuda para ver lo que hacen si lo necesitas.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### array identidad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  0.,  0.,  0.],\n",
       "       [ 0.,  1.,  0.,  0.],\n",
       "       [ 0.,  0.,  1.,  0.],\n",
       "       [ 0.,  0.,  0.,  1.]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.identity(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\"><strong>Nota:</strong> \n",
    "También puedes probar `np.eye()` y `np.diag()`.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rangos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### np.arange"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy, dame __un array que vaya de 0 a 5__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(0, 5)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Mira con atención el resultado anterior__, ¿hay algo que deberías grabar en tu cabeza para simpre?\n",
    "__El último elemento no es 5 sino 4__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy, dame __un array que vaya de 0 a 10, de 3 en 3__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 3, 6, 9])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(0,11,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### np.linspace"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si has tenido que usar MATLAB alguna vez, seguro que esto te suena:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0. ,   0.5,   1. ,   1.5,   2. ,   2.5,   3. ,   3.5,   4. ,\n",
       "         4.5,   5. ,   5.5,   6. ,   6.5,   7. ,   7.5,   8. ,   8.5,\n",
       "         9. ,   9.5,  10. ])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 10, 21)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso sí que se incluye el último elemento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\"><strong>Nota:</strong> \n",
    "También puedes probar `np.logspace()`\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### reshape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con `np.arange()` es posible crear \"vectores\" cuyos elementos tomen valores consecutivos o equiespaciados, como hemos visto anteriormente. ¿Podemos hacer lo mismo con \"matrices\"? Pues sí, pero no usando una sola función. Imagina que quieres crear algo como esto:\n",
    "\n",
    "\\begin{pmatrix}\n",
    "    1 & 2 & 3\\\\ \n",
    "    4 & 5 & 6\\\\\n",
    "    7 & 8 & 9\\\\\n",
    "    \\end{pmatrix}\n",
    "    \n",
    "* Comenzaremos por crear un array 1d con los valores $(1,2,3,4,5,6,7,8,9)$ usando `np.arange()`.\n",
    "* Luego le daremos forma de array 2d. con `np.reshape(array, (dim0, dim1))`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(1,10)\n",
    "M = np.reshape(a, [3,3])\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# También funciona como método\n",
    "N = a.reshape([3,3])\n",
    "N"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\"><strong>Nota:</strong> \n",
    "No vamos a entrar demasiado en qué son los métodos, pero debes saber que están asociados a la programación orientada a objetos y que en Python todo es un objeto. Lo que debes pensar es que son unas funciones especiales en las que el argumento más importante (sobre el que se realiza la acción) se escribe delante seguido de un punto. Por ejemplo: `<objeto>.método(argumentos)`\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importación"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python es un lenguaje que está altamente modularizado: está dividido en __bibliotecas que realizan tareas específicas__. Para hacer uso de ellas debemos importarlas. Podemos importar cosas de la [biblioteca estándar](https://docs.python.org/3.4/library/), de paquetes que hayamos descargado (o se enceuntren en [nuestra distribución](http://docs.continuum.io/anaconda/pkg-docs.html)) o de módulos que nosotros mismos construyamos. \n",
    "\n",
    "Existen varias formas de importar:\n",
    "\n",
    "    import numpy\n",
    "    \n",
    "Cada vez que queramos acceder a una función de numpy, deberemos escribir:\n",
    "    \n",
    "    numpy.sin(5)\n",
    "    numpy.linspace(0,100,50)\n",
    "    \n",
    "---\n",
    "Como esto puede resultar tedioso, suele utilizarse un __namespace__, el recomendado en la documentación oficial y que usaremos en el curso es:\n",
    "\n",
    "    import numpy as np\n",
    "    \n",
    "Ahora podremos llamar a funciones escribiendo:\n",
    "\n",
    "    np.sin(5)\n",
    "    np.linspace(0,100,50)\n",
    "    \n",
    "---\n",
    "Si esto te sigue pareciendo demasido escribir puedes hacer (__altamente no recomendado__):\n",
    "\n",
    "    from numpy import *\n",
    "    \n",
    "El asterisco, quiere decir _TODO_. Esto genera varios problemas: \n",
    "\n",
    "* __Imporatará gran cantidad de funciones y clases que puede que no necesites__.\n",
    "* El nombre de estas funciones, puede coincidir con el de alguna de otro módulo que hayas importado, de manera que \"la machacará\", por lo que __se producirán ambigüedades__."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ejemplo: ¿por qué no hacer from numpy import * ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.84147098,  0.90929743,  0.14112001, -0.7568025 , -0.95892427])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy import *\n",
    "\n",
    "a = [1,2,3,4,5]\n",
    "sin(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "a float is required",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-37-bd5f2f081266>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0mmath\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[1;33m*\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0msin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: a float is required"
     ]
    }
   ],
   "source": [
    "from math import *\n",
    "\n",
    "sin(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__La función seno que incorporá math no es la misma que la de NumPy__. Ambas proporcionarán el seno de un número, evidentemente, el mismo resultado para el mismo número, pero una acepta listas y la otra no. Al hacer la segunda importación, la función seno de NumPy se ha sustituido por la de math y la misma sentencia, da un error. Esto puede hacer que te vuelvas un poco loco si tu código es grande o acabes volviendo loco a alguien si usa tu código.\n",
    "\n",
    "¿Suficiente? Ahora ya sabes por qué tendrás que escribir `np.loquesea` __siempre__."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-error\"><strong>Importante:</strong> Reiniciemos el kernel e importemos bien NumPy para continuar.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operaciones elemento a elemento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora que pocas cosas se nos escapan de los arrays, probemos a hacer algunas operaciones. El funcionamiento es el habitual en FORTRAN y MATLAB y poco hay que añadir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#crear un arra y y sumarle un número\n",
    "arr = np.arange(11)\n",
    "arr + 55"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#multiplicarlo por un número\n",
    "arr * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,   1,   4,   9,  16,  25,  36,  49,  64,  81, 100])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#elevarlo al cuadrado\n",
    "arr ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.76159416,  0.96402758,  0.99505475,  0.9993293 ,\n",
       "        0.9999092 ,  0.99998771,  0.99999834,  0.99999977,  0.99999997,  1.        ])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#calcular una función\n",
    "np.tanh(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\"><strong>Entrenamiento:</strong> \n",
    "Puedes tratar de comparar la diferencia de tiempo entre realizar la operación en bloque, como ahora, y realizarla elemento a elemento, recorriendo el array con un bucle.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Si las operaciones involucran dos arrays también se realizan elemento a elemento__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#creamos dos arrays\n",
    "arr1 = np.arange(0,11)\n",
    "arr2 = np.arange(20,31)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#los sumamos\n",
    "arr1 + arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,  21,  44,  69,  96, 125, 156, 189, 224, 261, 300])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#multiplicamos\n",
    "arr1 * arr2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comparaciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False, False, False, False, False,\n",
       "       False, False], dtype=bool)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# >,<\n",
    "arr1 > arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False, False, False, False, False,\n",
       "       False, False], dtype=bool)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ==\n",
    "arr1 == arr2 # ¡ojo! los arrays son de integers, no de floats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\"><strong>Nota:</strong> \n",
    "Por cierto, ¿qúe ocurrirá si los arrays con los que se quiere operar no tiene la misma forma? ¿apuestas? Quizá más adelante te interese buscar algo de información sobre __broadcasting__.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicios\n",
    "\n",
    "1. Crear un array z1 3x4 lleno de ceros de tipo entero.\n",
    "2. Crear un array z2 3x4 lleno de ceros salvo la primera fila que serán todo unos.\n",
    "3. Crear un array z3 3x4 lleno de ceros salvo la última fila que será el rango entre 5 y 8.\n",
    "4. Crea un vector de 10 elementos, siendo los impares unos y los pares doses.\n",
    "5. Crea un «tablero de ajedrez», con unos en las casillas negras y ceros en las blancas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.zeros((3, 4))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  1.,  1.,  1.],\n",
       "       [ 0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0, :] = 1\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.],\n",
       "       [ 5.,  6.,  7.,  8.]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.zeros((3, 4))\n",
    "b[-1] = np.arange(5, 9)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2.,  1.,  2.,  1.,  2.,  1.,  2.,  1.,  2.,  1.])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = np.ones(10)\n",
    "v[::2] = 2\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  1.,  0.,  1.,  0.,  1.,  0.,  1.],\n",
       "       [ 1.,  0.,  1.,  0.,  1.,  0.,  1.,  0.],\n",
       "       [ 0.,  1.,  0.,  1.,  0.,  1.,  0.,  1.],\n",
       "       [ 1.,  0.,  1.,  0.,  1.,  0.,  1.,  0.],\n",
       "       [ 0.,  1.,  0.,  1.,  0.,  1.,  0.,  1.],\n",
       "       [ 1.,  0.,  1.,  0.,  1.,  0.,  1.,  0.],\n",
       "       [ 0.,  1.,  0.,  1.,  0.,  1.,  0.,  1.],\n",
       "       [ 1.,  0.,  1.,  0.,  1.,  0.,  1.,  0.]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tablero = np.zeros((8, 8))\n",
    "tablero[1::2, ::2] = 1\n",
    "tablero[::2, 1::2] = 1\n",
    "tablero"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extra:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fd334544358>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPYAAAD7CAYAAABZjGkWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAADDVJREFUeJzt3V2MXVUZxvHnaYcGWrBEMXxIk9ZEiCZGIIQQCnLQQoCA\nemEiJEiCCVcqJEYimkjnSm404I03fDSIfCSWYEBFUOQkELF8zYTSFiMNmIJQmkCKgCYgrxez24xD\n6dkzs9Y+57zz/yWT7jlzOGu9E56z1tmz9l6OCAHIZdmwOwCgPIINJESwgYQINpAQwQYSIthAQkMJ\ntu3zbT9v+++2f1C5rVtt77a9tWY7s9pbY/sR29tsP2f7qsrtHWp7i+1p29ttX1+zvabN5banbN9f\nu62mvZdsP9u0+UTlto60vdn2jub3eXrFtk5satr3tbfY/y8R0emXpOWSXpC0VtIhkqYlfbZie2dJ\nOlnS1o7qO0bSSc3x4ZL+VrO+pp2Vzb8Tkv4q6czK7X1P0h2S7uvod/qipI931NZtkr416/e5uqN2\nl0l6VdKaEq83jBH7NEkvRMRLEfGepLslfbVWYxHxqKQ3a73+Adp7LSKmm+O3Je2QdFzlNt9tDldo\n5o3zjVpt2T5e0oWSbpbkWu0cqOnqDdirJZ0VEbdKUkS8HxF7a7fb2CBpZ0TsKvFiwwj2pyTN7vzL\nzWPp2F6rmdnClsrtLLM9LWm3pEciYnvF5m6QdI2kDyq2MVdI+pPtp2xfWbGddZL22N5k+xnbN9le\nWbG92S6RdGepFxtGsJfEGlbbh0vaLOnqZuSuJiI+iIiTJB0v6Yu2ezXasX2RpNcjYkrdjtbrI+Jk\nSRdI+rbtsyq1MyHpFEm/iIhTJL0j6dpKbe1ne4WkiyX9utRrDiPYr0haM+v7NZoZtdOwfYikeyT9\nKiJ+01W7zbTxd5JOrdTEGZK+YvtFSXdJ+pLtX1Zqa7+IeLX5d4+kezXzca6GlyW9HBFPNt9v1kzQ\na7tA0tNNfUUMI9hPSfqM7bXNO9U3JN03hH5UYduSbpG0PSJu7KC9o2wf2RwfJulcSVM12oqIH0XE\nmohYp5mp458j4vIabe1je6XtI5rjVZLOk1TlLxwR8ZqkXbZPaB7aIGlbjbbmuFQzb5TFTJR8sTYi\n4n3b35H0oGZO9NwSETtqtWf7LklnS/qE7V2SrouITbXak7Re0mWSnrW9L2A/jIg/VGrvWEm32V6m\nmTfq2yPi4UptzdXFx6qjJd07836pCUl3RMRDFdv7rqQ7mkFnp6QrKra1781qg6Si5w7cnGoHkAgr\nz4CECDaQEMEGEiLYQEIEG0ho0X/uss1pdWCIIuJDqwCLjNgLufpk48aNC70KplMLvbqG+sa7xnGq\n70CYigMJEWwgoaEFu9frDavpTlDfeBv3+ha9pNR2dPm5olkz3JmuPzNlr0/KX+MQ6qtz8gzAaCHY\nQEIEG0hoYLC7vFUwgDIOevLM9nLN3D53g2ZuafSkpEtn3xiBk2dlZa9Pyl/jOJw86/RWwQDKGBTs\nJXOrYCCTQcEejYWvAOZl0NVdrW4VPDk5uf+41+uN/aodYNwNOnk2oZmTZ1+W9E9JT4iTZ1Vlr0/K\nX+MonDw76IgdHd8qGEAZrBUfYAm823fanpS/xlEYsVl5BiREsIGECDaQEMEGEiLYQEIEG0iIYAMJ\nEWwgIYINJLToLX6kblfaLIFVRJ2213V9Uv4aR2ElJiM2kBDBBhIi2EBCBBtIiGADCRFsICGCDSRE\nsIGECDaQUJu9u261vdv21i46BGDx2ozYmySdX7sjAMoZGOyIeFTSmx30BUAhfMYGEipydReAbvT7\nffX7/YHPa7VhgO21ku6PiM8f4GedXoPHJX9lcdlmeV1ftsmGAcAS0ebPXXdJ+oukE2zvsn1F/W4B\nWIwie3cV6ksrTOPKYipeHlNxAFUQbCAhgg0kRLCBhAg2kBDBBhIi2EBCBBtIiGADCRW5umsU9iqq\nhVVS5WWvcRir+eZixAYSIthAQgQbSIhgAwkRbCAhgg0kRLCBhAg2kBDBBhJqczPDNbYfsb3N9nO2\nr+qiYwAWbuDNDG0fI+mYiJi2fbikpyV9LSJ2ND8PlpSWk70+KX+NQ6hv/jczjIjXImK6OX5b0g5J\nx5XvHoBS5vUZu9kR5GRJW2p0BkAZra/uaqbhmyVd3Yzc+01OTu4/7vV66vV6hboHYCHa7t11iKTf\nSnogIm6c8zM+YxeUvT4pf41j8RnbM728RdL2uaEGMJrafMZeL+kySefYnmq+zq/cLwCLUGTvLqbi\n5WSvT8pf41hMxQGMH4INJESwgYQINpAQwQYSIthAQgQbSIhgAwkRbCChInt3dbnSZgmsIuq0vWHs\nM5W9xlFYicmIDSREsIGECDaQEMEGEiLYQEIEG0iIYAMJEWwgIYINJNTmLqWH2t5ie9r2dtvXd9Ex\nAAs3cElpRPzH9jkR8a7tCUmP2T4zIh7roH8AFqDVVDwi3m0OV0haLumNaj0CsGitgm17me1pSbsl\nPRIR2+t2C8BitLq6KyI+kHSS7dWSHrTdi4h+1Z4B+JB+v69+vz/wefPeMMD2jyX9OyJ+2nzf6TV4\nXPJXFpdtltf1ZZsL3bvrKNtHNseHSTpX0lT5LgIopc1U/FhJt9leppk3gtsj4uG63QKwGEX27irU\nl1aYxpXFVLy8sZiKAxg/BBtIiGADCRFsICGCDSREsIGECDaQEMEGEiLYQEJF9u4ahb2KamGVVHnZ\naxzGar65GLGBhAg2kBDBBhIi2EBCBBtIiGADCRFsICGCDSREsIGE2m4YsNz2lO37a3cIwOK1HbGv\nlrRdUvfrDwHMW5v7ih8v6UJJN0sa/iJYAAO1GbFvkHSNpA8q9wVAIQe9usv2RZJej4gp272Pet7k\n5OT+416vp17vI58KoAMH3TDA9k8kfVPS+5IOlfQxSfdExOWznhNctllO9vqk/DUOob4PNdh6JxDb\nZ0v6fkRcPOdxgl1Q9vqk/DWOQrDn+3dszooDY6DI3l2M2OVkr0/KX+M4jtgAxgDBBhIi2EBCBBtI\niGADCRFsICGCDSREsIGECDaQUJG9u7pcabMEVhF12t4w9pnKXuMorMRkxAYSIthAQgQbSIhgAwkR\nbCAhgg0kRLCBhAg2kBDBBhJqtfLM9kuS3pL0X0nvRcRpNTsFYHHaLikNSb2IeKNmZwCUMZ+pOPt2\nAWOibbBD0p9sP2X7ypodArB4bafi6yPiVduflPRH289HxKM1Owbgw/r9vvr9/sDnzXvDANsbJb0d\nET9rvu/0Gjwu+SuLyzbL6/qyzQVtGGB7pe0jmuNVks6TtLV8FwGU0mYqfrSke5t3vQlJd0TEQ1V7\nBWBRiuzdVagvrTCNK4upeHljMRUHMH4INpAQwQYSIthAQgQbSIhgAwkRbCAhgg0kRLCBhIrs3TUK\nexXVwiqp8rLXOIzVfHMxYgMJEWwgIYINJESwgYQINpAQwQYSIthAQgQbSIhgAwm1uUvpkbY3295h\ne7vt07voGICFa7Ok9OeSfh8RX7c9IWlV5T4BWKSD3qXU9mpJUxHx6YM8J1grXk72+qT8NQ6hvnnf\npXSdpD22N9l+xvZNtlfW6R6AUgaN2KdKelzSGRHxpO0bJb0VEdfNek5s3Lhx/3/T6/XU6/XqdZh3\n+6IYscsbhRF7ULCPkfR4RKxrvj9T0rURcdGs5zAVLyh7fVL+Gkch2AedikfEa5J22T6heWiDpG0V\n+gagoIFb/Nj+gqSbJa2QtFPSFRGxd9bPGbELyl6flL/GURixi+zdRbDLyV6flL/GUQg2K8+AhAg2\nkBDBBhIi2EBCBBtIiGADCRFsICGCDSREsIGEiuzd1eVKmyWwiqjT9oaxz1T2GkdhJSYjNpAQwQYS\nIthAQgQbSIhgAwkRbCAhgg0kRLCBhNps8XOi7alZX3ttX9VF5wAszLzueWZ7maRXJJ0WEbuaxzpd\nRsSqpbJYeVZe1yvPStzzbIOknftCDWA0zTfYl0i6s0ZHAJTTeipue4VmpuGfi4g9sx5nKl5Q9vqk\n/DWOwlR8Pld3XSDp6dmhBtCtfr+vfr8/8HnzGbHvlvRARNw253FG7IKy1yflr3EURuxWwba9StI/\nJK2LiH/N+RnBLih7fVL+Gkch2K2m4hHxjqSjivcKQBWsPAMSIthAQgQbSIhgAwkRbCAhgg0ktGSC\n3Wa1zjijvvFWuj6CnQT1jTeCDWAggg0kNK87qBzwBTpeKw7g/y34IhAA44WpOJAQwQYSIthAQgQb\nSIhgAwn9D4CVTnEA1ECjAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fd34c25d748>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.matshow(tablero, cmap=plt.cm.gray_r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___Hemos aprendido:___\n",
    "\n",
    "* Las características de los arrays de NumPy:\n",
    "    - Homogeneidad de tipo.\n",
    "    - Tamaño fijo en el momento de la creación.\n",
    "* A usar las principales funciones para crear arrays.\n",
    "* A operar con arrays.\n",
    "\n",
    "_En definitiva:_\n",
    "* __Ingenieros y científicos $\\heartsuit$ arrays.__\n",
    "* __Ingenieros y científicos necesitan NumPy.__\n",
    "\n",
    "__El próximo día__ aprenderemos cómo acceder a elementos de un array _slicing_, cómo realizar algunas operaciones de álgebra lineal (determinantes, trazas, autovalores...)  y practicaremos todo lo aprendido.\n",
    "\n",
    "__¡Quiero más!__Algunos enlaces:\n",
    "\n",
    "Algunos enlaces en Pybonacci:\n",
    "\n",
    "* [Cómo crear matrices en Python con NumPy](http://pybonacci.wordpress.com/2012/06/11/como-crear-matrices-en-python-con-numpy/).\n",
    "* [Números aleatorios en Python con NumPy y SciPy](http://pybonacci.wordpress.com/2013/01/11/numeros-aleatorios-en-python-con-numpy-y-scipy/).\n",
    "\n",
    "\n",
    "Algunos enlaces en otros sitios:\n",
    "\n",
    "* [100 numpy exercises](http://www.labri.fr/perso/nrougier/teaching/numpy.100/index.html). Es posible que de momento sólo sepas hacer los primeros, pero tranquilo, pronto sabrás más...\n",
    "* [NumPy and IPython SciPy 2013 Tutorial](http://conference.scipy.org/scipy2013/tutorial_detail.php?id=100).\n",
    "* [NumPy and SciPy documentation](http://docs.scipy.org/doc/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "Clase en vídeo, parte del [Curso de Python para científicos e ingenieros](http://cacheme.org/curso-online-python-cientifico-ingenieros/) grabado en la Escuela Politécnica Superior de la Universidad de Alicante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"560\"\n",
       "            height=\"315\"\n",
       "            src=\"https://www.youtube.com/embed/UltVlYCacD0?list=PLGBbVX_WvN7bMwYe7wWV5TZt1a58jTggB\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.YouTubeVideo at 0x7f61e04dfb70>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "\n",
    "YouTubeVideo(\"UltVlYCacD0\", width=560, height=315, list=\"PLGBbVX_WvN7bMwYe7wWV5TZt1a58jTggB\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si te ha gustado esta clase:\n",
    "\n",
    "<a href=\"https://twitter.com/share\" class=\"twitter-share-button\" data-url=\"https://github.com/AeroPython/Curso-AeroPython-UC3M/\" data-text=\"Aprendiendo Python con\" data-via=\"AeroPython\" data-size=\"large\" data-hashtags=\"AeroPython\">Tweet</a>\n",
    "<script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <h4 align=\"right\">¡Síguenos en Twitter!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### <a href=\"https://twitter.com/AeroPython\" class=\"twitter-follow-button\" data-show-count=\"false\">Follow @AeroPython</a> <script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/deed.es\"><img alt=\"Licencia Creative Commons\" style=\"border-width:0\" src=\"http://i.creativecommons.org/l/by/4.0/88x31.png\" /></a><br /><span xmlns:dct=\"http://purl.org/dc/terms/\" property=\"dct:title\">Curso AeroPython</span> por <span xmlns:cc=\"http://creativecommons.org/ns#\" property=\"cc:attributionName\">Juan Luis Cano Rodriguez y Alejandro Sáez Mollejo</span> se distribuye bajo una <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/deed.es\">Licencia Creative Commons Atribución 4.0 Internacional</a>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### <script src=\"//platform.linkedin.com/in.js\" type=\"text/javascript\"></script> <script type=\"IN/MemberProfile\" data-id=\"http://es.linkedin.com/in/juanluiscanor\" data-format=\"inline\" data-related=\"false\"></script> <script src=\"//platform.linkedin.com/in.js\" type=\"text/javascript\"></script> <script type=\"IN/MemberProfile\" data-id=\"http://es.linkedin.com/in/alejandrosaezm\" data-format=\"inline\" data-related=\"false\"></script>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "_Las siguientes celdas contienen configuración del Notebook_\n",
    "\n",
    "_Para visualizar y utlizar los enlaces a Twitter el notebook debe ejecutarse como [seguro](http://ipython.org/ipython-doc/dev/notebook/security.html)_\n",
    "\n",
    "    File > Trusted Notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<a href=\"https://twitter.com/AeroPython\" class=\"twitter-follow-button\" data-show-count=\"false\">Follow @AeroPython</a>\n",
       "<script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML at 0x430e208>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<a href=\"https://twitter.com/AeroPython\" class=\"twitter-follow-button\" data-show-count=\"false\">Follow @AeroPython</a>\n",
    "<script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Source+Sans+Pro|Josefin+Sans:400,700,400italic|Ubuntu+Condensed' rel='stylesheet' type='text/css'>\n",
       "\n",
       "El estilo se ha aplicado =)\n",
       "\n",
       "<style>\n",
       "\n",
       "\n",
       "\n",
       "#notebook_panel { /* main background */\n",
       "    background: #f7f7f7;\n",
       "}\n",
       "\n",
       "div.cell { /* set cell width */\n",
       "    width: 900px;\n",
       "}\n",
       "\n",
       "div #notebook { /* centre the content */\n",
       "    background: #fff; /* white background for content */\n",
       "    width: 950px;\n",
       "    margin: auto;\n",
       "    padding-left: 0em;\n",
       "}\n",
       "\n",
       "#notebook li { /* More space between bullet points */\n",
       "    margin-top:0.7em;\n",
       "}\n",
       "\n",
       "/* draw border around running cells */\n",
       "div.cell.border-box-sizing.code_cell.running { \n",
       "    border: 1px solid #111;\n",
       "}\n",
       "\n",
       "/* Put a solid color box around each cell and its output, visually linking them*/\n",
       "div.cell.code_cell {\n",
       "    font-family: 'Source Sans Pro', sans-serif;\n",
       "    background-color: rgb(256,256,256);\n",
       "    font-size: 110%;\n",
       "    border-radius: 0px; \n",
       "    padding: 0.5em;\n",
       "    margin-left:1em;\n",
       "    margin-top: 1em;\n",
       "}\n",
       "\n",
       "div.text_cell_render{\n",
       "    font-family: 'Josefin Sans', serif;\n",
       "    line-height: 145%;\n",
       "    font-size: 125%;\n",
       "    font-weight: 500;\n",
       "    width:750px;\n",
       "    margin-left:auto;\n",
       "    margin-right:auto;\n",
       "}\n",
       "\n",
       "\n",
       "/* Formatting for header cells */\n",
       ".text_cell_render h1, .text_cell_render h2, .text_cell_render h3,\n",
       ".text_cell_render h4, .text_cell_render h5 {\n",
       "    font-family: 'Ubuntu Condensed', sans-serif;\n",
       "}\n",
       "/*\n",
       ".text_cell_render h1 {\n",
       "    font-family: Flux, 'Ubuntu Condensed', serif;\n",
       "    font-style:regular;\n",
       "    font-weight: 400;    \n",
       "    font-size: 30pt;\n",
       "    text-align: center;\n",
       "    line-height: 100%;\n",
       "    color: #335082;\n",
       "    margin-bottom: 0.5em;\n",
       "    margin-top: 0.5em;\n",
       "    display: block;\n",
       "}\n",
       "*/\n",
       ".text_cell_render h1 {\n",
       "    font-weight: 600;\n",
       "    font-size: 35pt;\n",
       "    line-height: 100%;\n",
       "    color: #234765;\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.3em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h2 {\n",
       "    margin-top:16px;\n",
       "    font-size: 27pt;\n",
       "    font-weight: 550;\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.3em;\n",
       "    font-style: regular;\n",
       "    color: #234765;\n",
       "}\t\n",
       "\n",
       ".text_cell_render h3 {\n",
       "    font-size: 20pt;\n",
       "    font-weight: 550\n",
       "    text-align: left;\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.3em;\n",
       "    font-style: regular;\n",
       "    color:  #376f9e;\n",
       "}\n",
       "\n",
       ".text_cell_render h4 {    /*Use this for captions*/\n",
       "    font-size: 18pt;\n",
       "    font-weight: 450\n",
       "    text-align: left;\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.3em;\n",
       "    font-style: regular;\n",
       "    color:  #376f9e;\n",
       "}\n",
       "\n",
       ".text_cell_render h5 {  /*Use this for small titles*/\n",
       "    font-size: 18pt;\n",
       "    font-weight: 550;\n",
       "    color: rgb(163,0,0);\n",
       "    font-style: italic;\n",
       "    margin-bottom: .1em;\n",
       "    margin-top: 0.8em;\n",
       "    display: block;\n",
       "    color:  #b21c0d;\n",
       "}\n",
       "\n",
       ".text_cell_render h6 { /*use this for copyright note*/\n",
       "    font-family: 'Ubuntu Condensed', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 14pt;\n",
       "    line-height: 100%;\n",
       "    color: #252525;\n",
       "    text-align: right;\n",
       "    margin-bottom: 1px;\n",
       "    margin-top: 1px;\n",
       "}\n",
       "\n",
       ".CodeMirror{\n",
       "        font-family: 'Duru Sans', sans-serif;\n",
       "        font-size: 100%;\n",
       "}\n",
       "\n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"],\n",
       "                           equationNumbers: { autoNumber: \"AMS\", useLabelIds: true}\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {'.MathJax_Display': {\"margin\": 4}}\n",
       "                }\n",
       "        });\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML at 0x430e358>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Esta celda da el estilo al notebook\n",
    "from IPython.core.display import HTML\n",
    "css_file = '../static/styles/style.css'\n",
    "HTML(open(css_file, \"r\").read())"
   ]
  }
 ],
 "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}