nb02-numpy-basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy Basics - Resume\n",
    "### Diferencias con la sintaxis de matlab\n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# La convención para el uso de NumPy\n",
    "import numpy as np "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creando un arreglo, a partir de una lista de python\n",
    "lista_python = [0,1,2,3] \n",
    "\n",
    "mi_array = np.array( [0,1.0,2,3,5] , dtype='float' )\n",
    "mi_array.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```matlab\n",
    "% En matlab\n",
    "mi_array = [0 1 2 3] ;\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_array = np.arange(0,10)\n",
    "mi_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Usando metodos de creacion de arreglos multidimensionales\n",
    "# ones, zeros, identity, eye\n",
    "mi_array = np.ones( (3,3) )\n",
    "mi_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El resto de los metodos para crear arreglos que ofrece numpy:<br>\n",
    "http://docs.scipy.org/doc/numpy/reference/routines.array-creation.html<br>\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numero de elementos  9\n",
      "Forma dimensiones  (3, 3)\n",
      "Numero dimensiones  2\n",
      "Tipo de dato  float64\n"
     ]
    }
   ],
   "source": [
    "# Que hay dentro del objeto mi_arreglo\n",
    "print ('Numero de elementos ' , mi_array.size)\n",
    "print ('Forma dimensiones ' , mi_array.shape)\n",
    "print ('Numero dimensiones ' , mi_array.ndim)\n",
    "print ('Tipo de dato ' , mi_array.dtype)\n",
    "\n",
    "#dir(mi_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```matlab\n",
    "% En matlab\n",
    "numel(mi_array) \n",
    "size(mi_array)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizando la informacion\n",
    "- Ultimo eje (dimension) se visualiza de izquierda a derecha\n",
    "- Penultimo eje se visualiza de arriba a abajo.\n",
    "- El resto tambien se muestran de arriba a abajo, donde cada bloque es separado del siguiente por una linea vacia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "# arreglo 2D\n",
    "a = np.arange(12)\n",
    "\n",
    "a.resize(4,3)\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1  2  3]\n",
      "  [ 4  5  6  7]\n",
      "  [ 8  9 10 11]]\n",
      "\n",
      " [[12 13 14 15]\n",
      "  [16 17 18 19]\n",
      "  [20 21 22 23]]]\n"
     ]
    }
   ],
   "source": [
    "# arrreglo 3D\n",
    "c = np.arange(24).reshape(2,3,4)\n",
    "print (c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Las operaciones basicas\n",
    "Todas las operaciones aritmeticas sobre los arreglos de numpy se hacen elemento a elemento. Se genera un nuevo arreglo y se llena con el resultado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1]\n",
      " [2 3]]\n",
      "[[ 2.  2.]\n",
      " [ 2.  2.]]\n",
      "-\n",
      "[[ 0.  2.]\n",
      " [ 4.  6.]]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(4).reshape(2,2)\n",
    "b = np.ones((2,2))\n",
    "b = b + 1\n",
    "c = a * b \n",
    "\n",
    "\n",
    "print (a) \n",
    "print (b) \n",
    "print ('-')\n",
    "print (c)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```matlab\n",
    "% En matlab\n",
    ">> c = a .* b\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  2.   2.]\n",
      " [ 10.  10.]]\n"
     ]
    }
   ],
   "source": [
    "# El producto de matrices\n",
    "c = np.dot(a,b)\n",
    "print (c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```matlab\n",
    "% En matlab \n",
    ">>> c = a * b\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### \"Broadcasting\"\n",
    "Describe el como se comportan los arreglos de numpy de diferenctes dimensiones durante las operaciones aritmeticas.\n",
    "\n",
    "![alt text](images/np_broadcasting.png \"Ejemplos broadcasting\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]] - [ 1.  1.  1.]\n",
      "=\n",
      "[[ -1.   0.   1.]\n",
      " [  2.   3.   4.]\n",
      " [  5.   6.   7.]\n",
      " [  8.   9.  10.]]\n"
     ]
    }
   ],
   "source": [
    "# \"Broadcasting\" Operaciones sobre arreglos que no tienen la misma dimension, se repiten en los siguientes bloques\n",
    "# Regla del broadcasting dice que dos dimensiones son compatibles cuando: \n",
    "# - Son iguales en las primeras dimensiones\n",
    "# - Una de ellas es uno.\n",
    "\n",
    "a = np.arange(12).reshape(4,3)\n",
    "b = np.ones((3))\n",
    "\n",
    "print (a, '-', b)\n",
    "print ('=')\n",
    "print (a - b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: (4,)\n",
      "xx: (4, 1)\n",
      "[[0 0 0 0]\n",
      " [0 1 2 3]\n",
      " [0 2 4 6]\n",
      " [0 3 6 9]]\n"
     ]
    }
   ],
   "source": [
    "# Otro ejemplo de \"broadcasting\"\n",
    "x = np.arange(4)\n",
    "xx = x.reshape(4,1)\n",
    "\n",
    "\n",
    "print ('x:', x.shape)\n",
    "print ('xx:', xx.shape)\n",
    "print (xx * x) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y shape :  (3, 3)\n",
      "x shape :  (4,)\n",
      "y :  [[ 1.  1.  1.]\n",
      " [ 1.  1.  1.]\n",
      " [ 1.  1.  1.]]\n",
      "x :  [0 1 2 3]\n"
     ]
    }
   ],
   "source": [
    "y = np.ones((3,3))\n",
    "\n",
    "\n",
    "print (\"y shape : \" , y.shape)\n",
    "print (\"x shape : \" , x.shape)\n",
    "print (\"y : \" , y)\n",
    "print (\"x : \" , x )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (4,) (3,3) ",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-18-7b9f4765d73d>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mx\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0my\u001b[0m \u001b[1;31m# Generara un error pues las dimensiones no corresponden.\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: operands could not be broadcast together with shapes (4,) (3,3) "
     ]
    }
   ],
   "source": [
    "x + y # Generara un error pues las dimensiones no corresponden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y = np.ones((4,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0]\n",
      " [1]\n",
      " [2]\n",
      " [3]]\n",
      "[[ 1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  1.,  1.,  1.],\n",
       "       [ 2.,  2.,  2.,  2.],\n",
       "       [ 3.,  3.,  3.,  3.],\n",
       "       [ 4.,  4.,  4.,  4.]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print (xx)\n",
    "print (y)\n",
    "xx + y "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metodos ya incluidos en la clase ndarray\n",
    "Muchos metodos ya se encuentran integrados en la clase *ndarray* de NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.61163313,  0.75888746,  0.17213748],\n",
       "       [ 0.53532914,  0.15997021,  0.66072802]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.random.random((2,3))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.8986854295707514"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.17213748,  0.15997021])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.min(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.75888745530952761"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por default estas operaciones se hacen sobre todos los elementos del arreglo, salvo que se especifiquen, que solo se desea hacer la operacion sobre algun eje en especifico.\n",
    "\n",
    "![Alt Text](images/axis.png \"Numpy axis order\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.14696227,  0.91885766,  0.8328655 ])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# La suma de cada columna\n",
    "a.sum(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.54265807,  1.35602736])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# La suma de cada renglon\n",
    "a.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  6,  8, 10],\n",
       "       [12, 15, 18, 21]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# La suma aculumativa sobre cada renglon\n",
    "b = np.arange(12).reshape(3,4)\n",
    "b.cumsum(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones universales\n",
    "Funciones matematicas que se realizan de elemento a elemento\n",
    "\n",
    "Listado: http://docs.scipy.org/doc/numpy/reference/ufuncs.html#math-operations\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.        ,  1.        ,  1.41421356,  1.73205081],\n",
       "       [ 2.        ,  2.23606798,  2.44948974,  2.64575131],\n",
       "       [ 2.82842712,  3.        ,  3.16227766,  3.31662479]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.        ,  0.84147098,  0.90929743,  0.14112001],\n",
       "       [-0.7568025 , -0.95892427, -0.2794155 ,  0.6569866 ],\n",
       "       [ 0.98935825,  0.41211849, -0.54402111, -0.99999021]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sin(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9],\n",
       "       [10, 11, 12, 13]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = np.array([2,2,2,2])\n",
    "np.add(b,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seleccion de rangos, indexado e iteraciones\n",
    "- Arreglos 1D se pueden acceder por indices, recortar e iterar sobre sus elementos, como una lista de python.\n",
    "- Arreglos 2D, tienen un indice por eje, y estos indices se dan por un tipo de dato **tuple** \n",
    "- Arreglos multidimensionales tienen un indice por cada eje, de igual forma estan dados por un **tuple**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10)**2\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```matlab\n",
    "% En matlab\n",
    ">>> a = (0:9) .^ 2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([4, 5, 6, 7, 8, 9]),)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Buscar dentro del arreglo, y retornar indices\n",
    "np.where(a > 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "[ 4  9 16]\n",
      "[ 0  4 16 36 64]\n",
      "[ 4 16 36]\n"
     ]
    }
   ],
   "source": [
    "print (a[2])\n",
    "\n",
    "print (a[2:5])\n",
    "print (a[0:-1:2])             # Usando un paso de dos indices \n",
    "print (a[np.array([2,4,6])])  # Elementos con indice 2 , 4 y 6\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```matlab\n",
    "% En matlab\n",
    ">>> a(3)\n",
    ">>> a(3:5)\n",
    ">>> a(1:2:end)\n",
    ">>> a([3,5,7])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([25, 64,  1])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Usando los mismos arreglos ndarray para referirnos a indices de otro arreglo.\n",
    "indices = np.array([5,8,1])\n",
    "a[indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8,  9],\n",
       "       [10, 11, 12, 13, 14]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#\n",
    "# Visualizando la seleccion de rangos\n",
    "\n",
    "arr = np.arange(15).reshape(3,5)\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Alt Text](images/slicing1.png \"Rangos\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[0:2,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 12, 13, 14])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[2,1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   0,    1,    4,    9, -999, -999,   36,   49,   64,   81])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Modificando datos sobre una region del arreglo.\n",
    "a[4:6] = -999\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 ,\n",
      "1 ,\n",
      "4 ,\n",
      "9 ,\n",
      "16 ,\n",
      "25 ,\n",
      "36 ,\n",
      "49 ,\n",
      "64 ,\n",
      "81 ,\n"
     ]
    }
   ],
   "source": [
    "# Iterar sobre sus elementos.  \n",
    "for el in a:\n",
    "    print (el, ',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aunque alerta, para que quisieramos iterar sobre sus elementos si tenemos funciones universales y podemos vectorizar la mayoria de las operaciones.."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```matlab\n",
    "% En matlab\n",
    ">>> for idx = 1:numel(a)\n",
    "      a(idx)\n",
    "    end  \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0.,   1.,   2.,   3.],\n",
       "       [ 10.,  11.,  12.,  13.],\n",
       "       [ 20.,  21.,  22.,  23.],\n",
       "       [ 30.,  31.,  32.,  33.],\n",
       "       [ 40.,  41.,  42.,  43.]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Arreglos multidimensionales\n",
    "\n",
    "# Equivalente a \n",
    "# def func(x,y):\n",
    "#   return 10 * x+y \n",
    "func = lambda x,y : 10*x+y         # palabra reservada lambda produce una funcion inline\n",
    "\n",
    "b = np.fromfunction(func,(5,4))\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 10.,  11.,  12.,  13.])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Segundo renglon\n",
    "b[1,:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```matlab\n",
    "% En matlab\n",
    ">>> b(2,:)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  3.,  13.,  23.,  33.,  43.])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ultima columna\n",
    "b[:,-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```matlab\n",
    "% En matlab\n",
    ">>> b(:,end)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.  1.  2.  3.] ,\n",
      "[ 10.  11.  12.  13.] ,\n",
      "[ 20.  21.  22.  23.] ,\n",
      "[ 30.  31.  32.  33.] ,\n",
      "[ 40.  41.  42.  43.] ,\n"
     ]
    }
   ],
   "source": [
    "# Iterando sobre arreglos multidimensionales.\n",
    "for renglon in b:\n",
    "    print (renglon , ',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0 ,1.0 ,2.0 ,3.0 ,10.0 ,11.0 ,12.0 ,13.0 ,20.0 ,21.0 ,22.0 ,23.0 ,30.0 ,31.0 ,32.0 ,33.0 ,40.0 ,41.0 ,42.0 ,43.0 ,"
     ]
    }
   ],
   "source": [
    "# El atributo flat entrega el iterable de todos los elementos del arreglo\n",
    "for el in b.flat:\n",
    "    print (el, ',', end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ordenando, buscando y contando el arreglo.\n",
    "Metodos para la busqueda y ordenado de datos en arreglos de numpy<br>\n",
    "http://docs.scipy.org/doc/numpy/reference/routines.sort.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  4,  5],\n",
       "       [ 6,  7,  8],\n",
       "       [ 9, 10, 11]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(12).reshape(4,3)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5, 6, 7, 8])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Elementos del arreglo, con alguna condicion\n",
    "a[(a>2) & (a<9)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False],\n",
       "       [False, False,  True],\n",
       "       [ True,  True,  True],\n",
       "       [ True, False, False]], dtype=bool)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Los elementos que cumplan con alguna condición\n",
    "(a > 4) & (a<10) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[999, 999, 999],\n",
       "       [999, 999, 999],\n",
       "       [  6,   7,   8],\n",
       "       [  9,  10,  11]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy where(cond, x, y), si se cumple la condicion, recupera de \"x\", de otra forma, de \"y\"\n",
    "np.where(a >5 , a , 999)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0],\n",
       "       [1, 1],\n",
       "       [1, 2],\n",
       "       [2, 0],\n",
       "       [2, 1],\n",
       "       [2, 2]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indices de elementos que cumplan la siguiente condicion\n",
    "np.argwhere((a>2) & (a<9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "# Indices con minimo y maximo\n",
    "print (np.argmin(a))\n",
    "print (np.argmax(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manipulando la forma de un arreglo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5.,  0.,  7.,  1.],\n",
       "       [ 9.,  7.,  5.,  8.],\n",
       "       [ 0.,  4.,  2.,  1.]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.floor( np.random.random((3,4)) * 10 )\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5.,  0.,  7.,  1.,  9.,  7.,  5.,  8.,  0.,  4.,  2.,  1.])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Aplanamos el arreglo, (Regresa referencias al arreglo original!)\n",
    "a.ravel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```matlab\n",
    "% En matlab\n",
    ">>> a(:)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5.,  9.,  0.],\n",
       "       [ 0.,  7.,  4.],\n",
       "       [ 7.,  5.,  2.],\n",
       "       [ 1.,  8.,  1.]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# arreglo a transpuesto\n",
    "a.transpose() # O tambien a.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```matlab\n",
    "% En matlab\n",
    ">>> a.'\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5.,  0.],\n",
       "       [ 7.,  1.],\n",
       "       [ 9.,  7.],\n",
       "       [ 5.,  8.],\n",
       "       [ 0.,  4.],\n",
       "       [ 2.,  1.]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Modificamos la forma del arreglo con resize\n",
    "a.resize(6,2)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5.,  0.,  7.,  1.,  9.,  7.],\n",
       "       [ 5.,  8.,  0.,  4.,  2.,  1.]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reshape entrega un nuevo arreglo\n",
    "# Al incluir -1 en los parametros, dejamos que numpy calcule el tamaño adecuado\n",
    "a.reshape(-1,6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenando arreglos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = np.floor( 10 * np.random.random((2,2)) )\n",
    "b = np.floor( 10 * np.random.random((2,2)) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7.,  7.],\n",
       "       [ 5.,  9.]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7.,  4.],\n",
       "       [ 5.,  8.]])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7.,  7.],\n",
       "       [ 5.,  9.],\n",
       "       [ 7.,  4.],\n",
       "       [ 5.,  8.]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Apilando los arreglos verticalemente\n",
    "np.vstack( (a,b) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7.,  7.,  7.,  4.],\n",
       "       [ 5.,  9.,  5.,  8.]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Apilando horizontalmente\n",
    "np.hstack((a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```matlab\n",
    "% En matlab\n",
    ">>> [a b]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Un arreglo de 1D \n",
    "c = np.array([1,2,3,4,5,6])\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4],\n",
       "       [5],\n",
       "       [6]])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Al agregar np.newaxis, creamos un arreglo 2D con los datos ordenados en la columna\n",
    "d = c[ :, np.newaxis]\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```matlab\n",
    "% En matlab\n",
    ">>> [1:6]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4],\n",
       "       [5],\n",
       "       [6],\n",
       "       [1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4],\n",
       "       [5],\n",
       "       [6]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((d,d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1],\n",
       "       [2, 2, 2],\n",
       "       [3, 3, 3],\n",
       "       [4, 4, 4],\n",
       "       [5, 5, 5],\n",
       "       [6, 6, 6]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack((d,d,d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copia de datos y vistas\n",
    "Operando arreglos multidimensionales, en ocasiones los datos se copian a un nuevo arreglo y en otras no, para evitar confusiones veremos los casos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(12)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# El operador = no hace copia de los datos, solo pasa la referencia al \n",
    "# puntero donde esta la informacion\n",
    "b = a \n",
    "b is a "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Los cambios realizados en b, tambien afectan al arreglo a, esto sucede igual\n",
    "# al pasar parametros en una funcion\n",
    "b.resize(3,4)\n",
    "a.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vistas o copia ligera\n",
    "La diferencia con las vistas, es que dos objetos ndarray que observan a los mismos datos. <br>\n",
    "Al hacer un recorte de un arreglo, estamos creado una vista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = a.view()\n",
    "c is a "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Cambiamos la forma de los datos en c, sin que se afecte en a\n",
    "c.resize((12))\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-9999, -9999, -9999, -9999,     4,     5,     6,     7,     8,\n",
       "           9,    10,    11])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pero al cambiar un dato en el arreglo a ...\n",
    "a[0] = -9999\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Copia real de datos\n",
    "El metodo copy() hace una copia completa del arreglo y de sus datos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = a.copy()\n",
    "d is a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-9999, -9999, -9999, -9999],\n",
       "       [    4,     5,     6,     7],\n",
       "       [    8,     9,    10,    11]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[0,0] = 5555\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5555, -9999, -9999, -9999],\n",
       "       [    4,     5,     6,     7],\n",
       "       [    8,     9,    10,    11]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arreglos con mascara\n",
    "Para manejar arreglos de datos que puedan contener datos invalidos, por lo que es conveniente usar un arreglo con mascara para no incluir esos datos en las operaciones.<br>\n",
    "Documentacion completa: http://docs.scipy.org/doc/numpy/reference/maskedarray.generic.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Importar el modulo para arreglos con mascara\n",
    "import numpy.ma as ma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "masked_array(data = [1 2 -- 4 5 6 -- 8 9],\n",
       "             mask = [False False  True False False False  True False False],\n",
       "       fill_value = 999999)"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1,2,-1,4,5,6,-1,8,9])\n",
    "mx = ma.masked_array(x , mask=[0,0,1,0,0,0,1,0,0])\n",
    "mx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# En todas las operaciones sobre el arreglo no se contaran los datos enmascarados.\n",
    "mx.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "masked_array(data = [1 2 -- 4 5 6 -- 8 9],\n",
       "             mask = [False False  True False False False  True False False],\n",
       "       fill_value = 999999)"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Es posible crear una mascara con alguna condicion sobre el arreglo.\n",
    "nmx = ma.masked_array(x , mask=(x <0))\n",
    "nmx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True, False, False, False,  True, False, False], dtype=bool)"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Accediendo a la mascara\n",
    "mx.mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 4, 5, 6, 8, 9])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Recuperar los datos validos\n",
    "mx.compressed()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Salvando sesion de trabajo y compartir con matlab\n",
    "Metodos adicionales, para salvar, archivos de text, binarios comprimidos, etc: http://docs.scipy.org/doc/numpy/reference/routines.io.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Arreglos de trabajo\n",
    "a = np.random.random((5,5))\n",
    "b = np.floor(np.random.random((11,11)) * 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Salvar mis datos en el archivo misesion.npz\n",
    "np.savez('misesion',a=a,b=b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b']"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Recuperar mi sesion\n",
    "data = np.load('misesion.npz')\n",
    "data.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.02291248,  0.88256019,  0.08239387,  0.73586174,  0.86282627],\n",
       "       [ 0.13569382,  0.62066854,  0.07509948,  0.10983912,  0.15883764],\n",
       "       [ 0.23971668,  0.31251652,  0.06951513,  0.97498177,  0.39159056],\n",
       "       [ 0.34776182,  0.86918631,  0.49380112,  0.99237343,  0.37560431],\n",
       "       [ 0.50752342,  0.48611792,  0.31980899,  0.44692608,  0.17743277]])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['a']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Recuperar datos de un archivo .mat\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'__globals__': [],\n",
       " '__header__': b'MATLAB 5.0 MAT-file, Platform: PCWIN64, Created on: Wed Sep 30 22:28:07 2015',\n",
       " '__version__': '1.0',\n",
       " 'a': array([[ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81]], dtype=uint8),\n",
       " 'b': array([[1, 1, 1, 1],\n",
       "        [1, 1, 1, 1],\n",
       "        [1, 1, 1, 1],\n",
       "        [1, 1, 1, 1]], dtype=uint8)}"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.io import loadmat\n",
    "\n",
    "mat = loadmat('data/datos.mat')\n",
    "mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81]], dtype=uint8)"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat['a']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Salvar en un .mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from scipy.io import savemat\n",
    "\n",
    "savemat('salida.mat',{'a':a, 'b':b})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "hmedrano@cicese.mx"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}