numpy/SciPy Numpy Extended Lectures Part 1 - Numpy Array Object.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "# NumPy: creating and manipulating numerical data "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## Section 1:  What is NumPy and numpy arrays\n",
    "\n",
    "**Python:** - has built-in\n",
    "- containers (costless insertion and append), dictionnaries (fast lookup)\n",
    "- high-level number objects (integers, floating points)\n",
    "\n",
    "**NumPy** is:\n",
    "- extension package to Python to multidimensional arrays\n",
    "- faster (as you'll see below)\n",
    "- convenient and tested by scientific community"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true,
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0,1,2,3])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "357 µs ± 5.95 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "l = range(1000)\n",
    "\n",
    "%timeit [i**2 for i in l]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.76 µs ± 27.8 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(1000)\n",
    "%timeit a**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function array in module numpy.core.multiarray:\n",
      "\n",
      "array(...)\n",
      "    array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)\n",
      "    \n",
      "    Create an array.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    object : array_like\n",
      "        An array, any object exposing the array interface, an object whose\n",
      "        __array__ method returns an array, or any (nested) sequence.\n",
      "    dtype : data-type, optional\n",
      "        The desired data-type for the array.  If not given, then the type will\n",
      "        be determined as the minimum type required to hold the objects in the\n",
      "        sequence.  This argument can only be used to 'upcast' the array.  For\n",
      "        downcasting, use the .astype(t) method.\n",
      "    copy : bool, optional\n",
      "        If true (default), then the object is copied.  Otherwise, a copy will\n",
      "        only be made if __array__ returns a copy, if obj is a nested sequence,\n",
      "        or if a copy is needed to satisfy any of the other requirements\n",
      "        (`dtype`, `order`, etc.).\n",
      "    order : {'K', 'A', 'C', 'F'}, optional\n",
      "        Specify the memory layout of the array. If object is not an array, the\n",
      "        newly created array will be in C order (row major) unless 'F' is\n",
      "        specified, in which case it will be in Fortran order (column major).\n",
      "        If object is an array the following holds.\n",
      "    \n",
      "        ===== ========= ===================================================\n",
      "        order  no copy                     copy=True\n",
      "        ===== ========= ===================================================\n",
      "        'K'   unchanged F & C order preserved, otherwise most similar order\n",
      "        'A'   unchanged F order if input is F and not C, otherwise C order\n",
      "        'C'   C order   C order\n",
      "        'F'   F order   F order\n",
      "        ===== ========= ===================================================\n",
      "    \n",
      "        When ``copy=False`` and a copy is made for other reasons, the result is\n",
      "        the same as if ``copy=True``, with some exceptions for `A`, see the\n",
      "        Notes section. The default order is 'K'.\n",
      "    subok : bool, optional\n",
      "        If True, then sub-classes will be passed-through, otherwise\n",
      "        the returned array will be forced to be a base-class array (default).\n",
      "    ndmin : int, optional\n",
      "        Specifies the minimum number of dimensions that the resulting\n",
      "        array should have.  Ones will be pre-pended to the shape as\n",
      "        needed to meet this requirement.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    out : ndarray\n",
      "        An array object satisfying the specified requirements.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    empty, empty_like, zeros, zeros_like, ones, ones_like, full, full_like\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    When order is 'A' and `object` is an array in neither 'C' nor 'F' order,\n",
      "    and a copy is forced by a change in dtype, then the order of the result is\n",
      "    not necessarily 'C' as expected. This is likely a bug.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.array([1, 2, 3])\n",
      "    array([1, 2, 3])\n",
      "    \n",
      "    Upcasting:\n",
      "    \n",
      "    >>> np.array([1, 2, 3.0])\n",
      "    array([ 1.,  2.,  3.])\n",
      "    \n",
      "    More than one dimension:\n",
      "    \n",
      "    >>> np.array([[1, 2], [3, 4]])\n",
      "    array([[1, 2],\n",
      "           [3, 4]])\n",
      "    \n",
      "    Minimum dimensions 2:\n",
      "    \n",
      "    >>> np.array([1, 2, 3], ndmin=2)\n",
      "    array([[1, 2, 3]])\n",
      "    \n",
      "    Type provided:\n",
      "    \n",
      "    >>> np.array([1, 2, 3], dtype=complex)\n",
      "    array([ 1.+0.j,  2.+0.j,  3.+0.j])\n",
      "    \n",
      "    Data-type consisting of more than one element:\n",
      "    \n",
      "    >>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])\n",
      "    >>> x['a']\n",
      "    array([1, 3])\n",
      "    \n",
      "    Creating an array from sub-classes:\n",
      "    \n",
      "    >>> np.array(np.mat('1 2; 3 4'))\n",
      "    array([[1, 2],\n",
      "           [3, 4]])\n",
      "    \n",
      "    >>> np.array(np.mat('1 2; 3 4'), subok=True)\n",
      "    matrix([[1, 2],\n",
      "            [3, 4]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Search results for 'create array'\n",
      "---------------------------------\n",
      "numpy.array\n",
      "    Create an array.\n",
      "numpy.memmap\n",
      "    Create a memory-map to an array stored in a *binary* file on disk.\n",
      "numpy.diagflat\n",
      "    Create a two-dimensional array with the flattened input as a diagonal.\n",
      "numpy.fromiter\n",
      "    Create a new 1-dimensional array from an iterable object.\n",
      "numpy.partition\n",
      "    Return a partitioned copy of an array.\n",
      "numpy.ctypeslib.as_array\n",
      "    Create a numpy array from a ctypes array or a ctypes POINTER.\n",
      "numpy.ma.diagflat\n",
      "    Create a two-dimensional array with the flattened input as a diagonal.\n",
      "numpy.ma.make_mask\n",
      "    Create a boolean mask from an array.\n",
      "numpy.ctypeslib.as_ctypes\n",
      "    Create and return a ctypes object from a numpy array.  Actually\n",
      "numpy.ma.mrecords.fromarrays\n",
      "    Creates a mrecarray from a (flat) list of masked arrays.\n",
      "numpy.ma.mvoid.__new__\n",
      "    Create a new masked array from scratch.\n",
      "numpy.lib.format.open_memmap\n",
      "    Open a .npy file as a memory-mapped array.\n",
      "numpy.ma.MaskedArray.__new__\n",
      "    Create a new masked array from scratch.\n",
      "numpy.lib.arrayterator.Arrayterator\n",
      "    Buffered iterator for big arrays.\n",
      "numpy.ma.mrecords.fromtextfile\n",
      "    Creates a mrecarray from data stored in the file `filename`.\n",
      "numpy.asarray\n",
      "    Convert the input to an array.\n",
      "numpy.ndarray\n",
      "    ndarray(shape, dtype=float, buffer=None, offset=0,\n",
      "numpy.recarray\n",
      "    Construct an ndarray that allows field access using attributes.\n",
      "numpy.chararray\n",
      "    chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0,\n",
      "numpy.pad\n",
      "    Pads an array.\n",
      "numpy.asanyarray\n",
      "    Convert the input to an ndarray, but pass ndarray subclasses through.\n",
      "numpy.copy\n",
      "    Return an array copy of the given object.\n",
      "numpy.diag\n",
      "    Extract a diagonal or construct a diagonal array.\n",
      "numpy.load\n",
      "    Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files.\n",
      "numpy.sort\n",
      "    Return a sorted copy of an array.\n",
      "numpy.array_equiv\n",
      "    Returns True if input arrays are shape consistent and all elements equal.\n",
      "numpy.dtype\n",
      "    Create a data type object.\n",
      "numpy.choose\n",
      "    Construct an array from an index array and a set of arrays to choose from.\n",
      "numpy.nditer\n",
      "    Efficient multi-dimensional iterator object to iterate over arrays.\n",
      "numpy.swapaxes\n",
      "    Interchange two axes of an array.\n",
      "numpy.full_like\n",
      "    Return a full array with the same shape and type as a given array.\n",
      "numpy.ones_like\n",
      "    Return an array of ones with the same shape and type as a given array.\n",
      "numpy.empty_like\n",
      "    Return a new array with the same shape and type as a given array.\n",
      "numpy.ma.mrecords.MaskedRecords.__new__\n",
      "    Create a new masked array from scratch.\n",
      "numpy.nan_to_num\n",
      "    Replace nan with zero and inf with finite numbers.\n",
      "numpy.zeros_like\n",
      "    Return an array of zeros with the same shape and type as a given array.\n",
      "numpy.asarray_chkfinite\n",
      "    Convert the input to an array, checking for NaNs or Infs.\n",
      "numpy.diag_indices\n",
      "    Return the indices to access the main diagonal of an array.\n",
      "numpy.chararray.tolist\n",
      "    a.tolist()\n",
      "numpy.ma.choose\n",
      "    Use an index array to construct a new array from a set of choices.\n",
      "numpy.savez_compressed\n",
      "    Save several arrays into a single file in compressed ``.npz`` format.\n",
      "numpy.matlib.rand\n",
      "    Return a matrix of random values with given shape.\n",
      "numpy.ma.empty_like\n",
      "    Return a new array with the same shape and type as a given array.\n",
      "numpy.ma.make_mask_none\n",
      "    Return a boolean mask of the given shape, filled with False.\n",
      "numpy.ma.mrecords.fromrecords\n",
      "    Creates a MaskedRecords from a list of records.\n",
      "numpy.around\n",
      "    Evenly round to the given number of decimals.\n",
      "numpy.source\n",
      "    Print or write to a file the source code for a NumPy object.\n",
      "numpy.diagonal\n",
      "    Return specified diagonals.\n",
      "numpy.einsum_path\n",
      "    Evaluates the lowest cost contraction order for an einsum expression by\n",
      "numpy.histogram2d\n",
      "    Compute the bi-dimensional histogram of two data samples.\n",
      "numpy.fft.ifft\n",
      "    Compute the one-dimensional inverse discrete Fourier Transform.\n",
      "numpy.fft.ifftn\n",
      "    Compute the N-dimensional inverse discrete Fourier Transform.\n",
      "numpy.busdaycalendar\n",
      "    A business day calendar object that efficiently stores information"
     ]
    }
   ],
   "source": [
    "np.lookfor('create array')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function lookfor in module numpy.lib.utils:\n",
      "\n",
      "lookfor(what, module=None, import_modules=True, regenerate=False, output=None)\n",
      "    Do a keyword search on docstrings.\n",
      "    \n",
      "    A list of of objects that matched the search is displayed,\n",
      "    sorted by relevance. All given keywords need to be found in the\n",
      "    docstring for it to be returned as a result, but the order does\n",
      "    not matter.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    what : str\n",
      "        String containing words to look for.\n",
      "    module : str or list, optional\n",
      "        Name of module(s) whose docstrings to go through.\n",
      "    import_modules : bool, optional\n",
      "        Whether to import sub-modules in packages. Default is True.\n",
      "    regenerate : bool, optional\n",
      "        Whether to re-generate the docstring cache. Default is False.\n",
      "    output : file-like, optional\n",
      "        File-like object to write the output to. If omitted, use a pager.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    source, info\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    Relevance is determined only roughly, by checking if the keywords occur\n",
      "    in the function name, at the start of a docstring, etc.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.lookfor('binary representation')\n",
      "    Search results for 'binary representation'\n",
      "    ------------------------------------------\n",
      "    numpy.binary_repr\n",
      "        Return the binary representation of the input number as a string.\n",
      "    numpy.core.setup_common.long_double_representation\n",
      "        Given a binary dump as given by GNU od -b, look for long double\n",
      "    numpy.base_repr\n",
      "        Return a string representation of a number in the given base system.\n",
      "    ...\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.lookfor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## Creating Arrays\n",
    "\n",
    "### 1-Dimensional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0,1,2,3])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### 2-D, 3-D and more "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.array([[0, 1, 2], [3, 4, 5]])\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1],\n",
       "        [2]],\n",
       "\n",
       "       [[3],\n",
       "        [4]]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = np.array([[[1], [2]], [[3], [4]]])\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2, 1)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of dimensions in array c:  3\n"
     ]
    }
   ],
   "source": [
    "print(\"Number of dimensions in array c: \",c.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Evenly spaced "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Evenly spaced - notice how it always starts with 0 .. (n-1) and not 1!\n",
    "a = np.arange(10)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### or,  number of points using linspace "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.   ,  0.125,  0.25 ,  0.375,  0.5  ,  0.625,  0.75 ,  0.875,  1.   ])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# number of points\n",
    "c = np.linspace(0, 1, 9) # start, end, number of points\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0. ,  0.2,  0.4,  0.6,  0.8])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = np.linspace(0, 1, 5, endpoint=False) # meaning it doesn't stop at 1.\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Common arrays "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.ones((3, 3)) # (3, 3) would be a tuple here\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.],\n",
       "       [ 0.,  0.]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.zeros((2 ,2))\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  0.,  0.],\n",
       "       [ 0.,  1.,  0.],\n",
       "       [ 0.,  0.,  1.]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = np.eye(3) # An identity matrix\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0, 0],\n",
       "       [0, 2, 0, 0],\n",
       "       [0, 0, 3, 0],\n",
       "       [0, 0, 0, 4]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = np.diag(np.array([1,2,3,4]))\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Random numbers "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.42638175,  0.71417744,  0.3370914 ,  0.17486232])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e = np.random.rand(4) # uniform in [0, 1]\n",
    "e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.25793493,  0.97254164, -0.25065458,  0.0813759 ])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = np.random.randn(4) #Gaussian\n",
    "f\n",
    "# type help(np.random.randn) to understand more"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function seed:\n",
      "\n",
      "seed(...) method of mtrand.RandomState instance\n",
      "    seed(seed=None)\n",
      "    \n",
      "    Seed the generator.\n",
      "    \n",
      "    This method is called when `RandomState` is initialized. It can be\n",
      "    called again to re-seed the generator. For details, see `RandomState`.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    seed : int or array_like, optional\n",
      "        Seed for `RandomState`.\n",
      "        Must be convertible to 32 bit unsigned integers.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    RandomState\n",
      "\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(1234) #setting the random seed\n",
    "help(np.random.seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## Exercise 1\n",
    "\n",
    "**Create an array that looks like this:**\n",
    "\n",
    "$$x = \n",
    "\\begin{bmatrix}\n",
    "    1 & 1 & 1 & 1 \\\\\n",
    "    1 & 1 & 1 & 1 \\\\\n",
    "    1 & 1 & 1 & 8 \\\\\n",
    "    1 & 6 & 1 & 1 \\\\\n",
    "\\end{bmatrix}\\tag{1}$$ and, \n",
    "\n",
    "**another one** that looks like this:\n",
    "\n",
    "$$y = \n",
    "\\begin{bmatrix}\n",
    "    0. & 0. & 0. & 0. & 0.\\\\\n",
    "    7. & 0. & 0. & 0. & 0.\\\\\n",
    "    0. & 8. & 0. & 0. & 0.\\\\\n",
    "    0. & 0. & 9. & 0. & 0.\\\\\n",
    "    0. & 0. & 0. & 10. & 0.\\\\\n",
    "    0. & 0. & 0. & 0. & 11.\\\\\n",
    "\\end{bmatrix}\\tag{2}$$\n",
    "\n",
    "and lastly,\n",
    "\n",
    "**create** this simple array\n",
    "\n",
    "$$\\begin{bmatrix}\n",
    "    0. & 0. & 0. & 0. & 0.\\\\\n",
    "    0. & 0. & 0. & 0. & 0.\\\\\n",
    "    1. & 0. & 0. & 0. & 0.\\\\\n",
    "    0. & 1. & 0. & 0. & 0.\\\\\n",
    "    0. & 0. & 1. & 0. & 0.\\\\\n",
    "    0. & 0. & 0. & 1. & 0.\\\\\n",
    "\\end{bmatrix}\\tag{3}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function eye in module numpy.lib.twodim_base:\n",
      "\n",
      "eye(N, M=None, k=0, dtype=<class 'float'>)\n",
      "    Return a 2-D array with ones on the diagonal and zeros elsewhere.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    N : int\n",
      "      Number of rows in the output.\n",
      "    M : int, optional\n",
      "      Number of columns in the output. If None, defaults to `N`.\n",
      "    k : int, optional\n",
      "      Index of the diagonal: 0 (the default) refers to the main diagonal,\n",
      "      a positive value refers to an upper diagonal, and a negative value\n",
      "      to a lower diagonal.\n",
      "    dtype : data-type, optional\n",
      "      Data-type of the returned array.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    I : ndarray of shape (N,M)\n",
      "      An array where all elements are equal to zero, except for the `k`-th\n",
      "      diagonal, whose values are equal to one.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    identity : (almost) equivalent function\n",
      "    diag : diagonal 2-D array from a 1-D array specified by the user.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.eye(2, dtype=int)\n",
      "    array([[1, 0],\n",
      "           [0, 1]])\n",
      "    >>> np.eye(3, k=1)\n",
      "    array([[ 0.,  1.,  0.],\n",
      "           [ 0.,  0.,  1.],\n",
      "           [ 0.,  0.,  0.]])\n",
      "\n",
      "Help on function diag in module numpy.lib.twodim_base:\n",
      "\n",
      "diag(v, k=0)\n",
      "    Extract a diagonal or construct a diagonal array.\n",
      "    \n",
      "    See the more detailed documentation for ``numpy.diagonal`` if you use this\n",
      "    function to extract a diagonal and wish to write to the resulting array;\n",
      "    whether it returns a copy or a view depends on what version of numpy you\n",
      "    are using.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    v : array_like\n",
      "        If `v` is a 2-D array, return a copy of its `k`-th diagonal.\n",
      "        If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th\n",
      "        diagonal.\n",
      "    k : int, optional\n",
      "        Diagonal in question. The default is 0. Use `k>0` for diagonals\n",
      "        above the main diagonal, and `k<0` for diagonals below the main\n",
      "        diagonal.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    out : ndarray\n",
      "        The extracted diagonal or constructed diagonal array.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    diagonal : Return specified diagonals.\n",
      "    diagflat : Create a 2-D array with the flattened input as a diagonal.\n",
      "    trace : Sum along diagonals.\n",
      "    triu : Upper triangle of an array.\n",
      "    tril : Lower triangle of an array.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> x = np.arange(9).reshape((3,3))\n",
      "    >>> x\n",
      "    array([[0, 1, 2],\n",
      "           [3, 4, 5],\n",
      "           [6, 7, 8]])\n",
      "    \n",
      "    >>> np.diag(x)\n",
      "    array([0, 4, 8])\n",
      "    >>> np.diag(x, k=1)\n",
      "    array([1, 5])\n",
      "    >>> np.diag(x, k=-1)\n",
      "    array([3, 7])\n",
      "    \n",
      "    >>> np.diag(np.diag(x))\n",
      "    array([[0, 0, 0],\n",
      "           [0, 4, 0],\n",
      "           [0, 0, 8]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.eye)\n",
    "help(np.diag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Basic Data Types "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1,2,3])\n",
    "a.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.array([1., 2., 3.])\n",
    "b.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Note: Datatype and performance\n",
    "\n",
    "Remember, different datatypes allow us to store data more compactly but most of the time folks as well as the interpreter auto-detects the datatype from input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make it explicit\n",
    "c = np.array([1, 2, 3], dtype=float)\n",
    "c.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Default data type is automatically float\n",
    "a = np.ones((3,3))\n",
    "a.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### More datatypes\n",
    "\n",
    "**Complex**\n",
    "\n",
    "** Bool **\n",
    "\n",
    "** Strings **\n",
    "\n",
    "** Integers **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('complex128')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Complex\n",
    "\n",
    "d = np.array([1+2j, 4+5j, 6+8*1j])\n",
    "d.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('bool')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Bool\n",
    "e = np.array([True, False, False, True])\n",
    "e.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('<U10')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = np.array(['Bonjour', 'Hi', 'Hola', 'Ole', 'Namaste Ji'])\n",
    "f.dtype # outputs string containing max 10 letters..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## Some Basic Visualization "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true,
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x109133780>]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAD8CAYAAABXe05zAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n3CIiLqPiFhFxGRW3iIjLqLhFRFzm/wCSSvLTtSZfAAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x108d32518>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 3, 20)\n",
    "y = np.linspace(0, 9, 20)\n",
    "plt.plot(x, y) # plots a line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x108be53c8>]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAD8CAYAAABXe05zAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nghsAkiG4ASAZghsAkiG4ASAZghsAkvlfwm91zivpCP0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x108681c88>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x, y, 'o')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### 2D arrays "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x109ace550>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS4AAAD8CAYAAADJwUnTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nl9y1F1Ya9AAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x109776320>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image = np.random.rand(40, 40)\n",
    "plt.imshow(image, cmap=plt.cm.Blues)\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x109718d30>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJztnXuc1WW1/98rkiNh4wVBCDHSMBUt0q15VNJM0kgPSscb\naZBllJdDmh7FQ3mJvHI0yzTUENRQpPCCeiQKUVMzNoTgHbVRJHCURJQ0U5/fH3vTb2avz4PjzDAw\nftf79eI1sz+s723vWbNnr+96PstSSgRBUDw+tK5PIAiCdUMkfxAUlEj+ICgokfxBUFAi+YOgoETy\nB0FBieQPgoISyR8EBaVVyW9mB5jZk2b2tJmd3lYnFQTB2sda2uFnZp2Ap4BBwAvAHODIlNJjuW26\nmqVNa7SXM7E77iDEZzLBG3rp3Vd16Id2+YgXX/67jH36Oa99sp8IrNsic2Li6ha9o4+1Uhxrl856\nt397y2uvZU7h41t77fFndez2PYT4utA66e3fFifx4Y107MN+v4vf1qF9unit4Q0d22N7ry143Guf\n/rDe/lVxDst1KG8KbYfumeCteokdL9WxrwjtY5n91vw41S+Dl19NloluQuYpaBa7AU+nlJ4FMLMb\ngSFANvk3BU6s0a7OxJZvEOJhmeBPeemN23Rol/KOXpzwJxk75Jteu/WnIvCAr2dO7JdeGvw3GXnQ\n/3ltermn3u2Nz3vt7swpjL/Qa7v+p46d8zUh3i+0jfX2L8/02uY769ju9zppVOad4NLthPZnHTtq\nstf6fNZr5W56++kveu1aHcoioZW/mgm+4ltem/gjHXuz0H6Y2e+Kpg9Lx2XiBK35s783sLjR4xeq\nWhAEHYDWvPM3CzP7NvBtgE3W9sGCIGg2rXnnXwL0afR4y6rWhJTSlSmlUkqp1LUVBwuCoG1pTcHv\nw1QKfl+kkvRzgGEppUdz25RK/VK5/JMm2qV2oIwddbsQB2V23Pl3Qnxax479jtdEzQCAEV5aJmqD\nPdODmR2M9NIPF8jIE8THv1yNR1QSEJUMAG5N/jP37jZPxv5CaAPSP73YbQO5/R9FOUNH6o+1Y9NL\nOniYqKJlPi7zaaH9XGh/yGz/X0JbLDSAr9RWsGCV/UyGdv2S1y77rd6tehZyte7rv9z0cel+KK/t\ngl9K6W0zOwGYQaX8O2FNiR8EwfpFqz7zp5TuBO5so3MJgqAdiQ6/ICgokfxBUFAi+YOgoLS42t8S\nShtYcp1Vy76gg58XLWuq6w/gG0Lrocq+wOui2v7rzH5Ft1eDWMHQQ8QBnCm6fs9W1XOAZ0RdfIQO\nnS8q1QMO0bFTRVn90Jt07Daig1KF7vJ9vT3jDvVat6kydJW4M9D1ycx+t1W9y/oWTb391WmqPXeX\ntJs+Vj/f7blH5saRaDzMMkE8t09kXoftPi7E+kwrMHs3eVQqPUe5/Gazqv3xzh8EBSWSPwgKSiR/\nEBSUSP4gKCjtW/Dra6lcuzTxmOsz0XOdcoxdIiMnqMLJZs0/r2P20/qEpBZtDvFS58wq5uOFpq0D\nGHel104Ry3wBen7Za7pJGq4+1WuzLtKxM4TmFmsA16etMkd7yEt3iXXswAniGi4Trcig25H/mLEk\n4BNzvDZ2Vyfd8gO9uVoZnWudHiq0bmmsDn5+jJPGq8IeMDL56u0cUw3RsLDm8TlAfWpee2+88wdB\nQYnkD4KCEskfBAUlkj8ICkokfxAUlPat9u9iqVxbEP6wdp58xnzb7zYZR17qvJnGJPt3GTo87eG0\nHvaAjG1I/hymmT/fyzKnNSsJl8mVwk0S4ACh/V6HrhQGxLdmzuFoaTRycSZamI/gXShusXfl1gcn\n73pxnPURkXC5aFHeeS99VvOU5+l5OpYLheNxH+F2vDjjDHOjMCE94i4du7N40eZl2so/KtrK99Wh\n/EZoD2did2naplwqPUK5vCqq/UEQ5InkD4KCEskfBAUlkj8ICkqrPPzMrJ7KoKh3gLdTSqU1b7Ad\nfPiaJtK0TGFuqGrZFca7ABzp9zFcDZ8B6OeLe5nuXtjZF/eGft6HDf2u3nwT88W9FUmbB/R50E/R\nWfxjvV815ejkX+lY+ojnd/F9mWBfVVopinvnZLbuJIp7l+feXkQn8LxMa+x15ltjjxbF2AqznDL8\nBV//es5EYQ+YLdx7Dz9SVWNhipxEdoc+rUtF4fMYPa9qX/PTfWalcXq/6RStN4O2GNrxhZRSbuRe\nEATrKfFnfxAUlNYmfwJ+Z2Zzq2O5HGb2bTMrm1n5pZdWqJAgCNYBrU3+vVJKA4AvA8ebmftE3Hhc\nV/fuMa0vCNYXWpX8KaUl1a8NVCYwZVwRgyBY32jNrL6uwIdSSq9Vv58JnJNSyvRCQmmApXLNfLIx\nwuEWYOxPvdZTzVEDliXvWLG/aceKGapInBkRVzv7HKDbC167LbO595HV/h4ADUndMsg8OQx3ymj7\nhIw8T90F8DcWABj5b14br3b7nN5+uej67ZYyrio7iZ7dzOvQINyRe3xGx44XbbDK3Lmzvskk70KM\n1d3MjEm3ePEXB8vY+8TLO1CYdlRQk/kyF9ztuiYPS69C+e21PKuPyk/mzWa2ej+T15T4QRCsX7Rm\nUOezZH8dBUGwvhO3+oKgoETyB0FBadf1/J3NUm0Jq3smdp5Ysz4643x7ntAvFdsDXCO0+bkxYEcI\nN9nLvZPsrpkq3hxVr1umyk8AW3pp2I906D1CW5KpliXxDJv3NADgh771eZA4hZm5OuSNQtvnjUxw\n7dw2yLXGniC8HR7J7HW2eBo5V2hH1/reVumzk5PGiCIvwNjkx5MNMj2ebGY632ndTMx+A7YWWsbq\ngBNqHh8MLAz33iAI1kQkfxAUlEj+ICgokfxBUFAi+YOgoLRrtb/OLH2uRpu5fSZ4spfmZIxvlXPt\nWO2ZAXVCG5QxSthBGCX8TMTpjk4Qhq0I11oAjlZtsLWDDSvsbt9z2h914Zg6X2RmZdJmHifYQKft\nL+IOyr1mwjiXa3XoQtEetlOmjZb+XtrucR3630JTnijP5MxPTvTS/so9GJghRjQO30HHqvWst2bM\nWjhD/PDunenJvqepIUip9CPK5fqo9gdBkCeSPwgKSiR/EBSUSP4gKCjtWvDrbpaG1GhXX5kJHiy0\n3rqKt6v5YsicTGfsLT/wWq7ONPQfXrtYrHk/Oele4rnm+46FTQGgJzcNT7lW4A291O8KHSo6lJly\ntI7tfZ3XxDS1Qz+lN5+aThKqmj0FdHveSU9lCmsjhPZAUr3EAG976cCjnHRBxmT3NOUQfYV6EgG2\nccr+mfbeGUkMdbu3tjm3Qo+9vdZwsz6Dy2osAS4Eno/23iAI1kQkfxAUlEj+ICgokfxBUFDes+Bn\nZhOAA4GGlNKOVW0zYArQF6gHDkspvfJeByuVNk7l8p41qh5CP9X8THXRfAXAR4W2SI37AiYf5rVh\nSbWmAbPFXPd9tnJSX/PFK4D6/xHi9fpQfExoOUfEumOFmBng/vifvLa9LpxOE4VT9e6QG9c1L93u\ntP52oIx9VHQZzhUdhgC7iMLrfaLwCjDQNz8y+SdeGzZCb881ohh6lyiEAvO/7LUByrUVWChe351S\n7idaVSNFFRBgbFOHitIVUF7SdgW/iUDtsLLTgd+nlPpRyd5Mc2kQBOsr75n8KaV7gdqbMEOASdXv\nJ5Hvbg+CYD2lpZ/5t0gpLa1+v4y8wXzNuC7xZ3QQBOuEVhf8UqVokC0cNB3XlflsHQRBu9PS5H/R\nzHoBVL82tN0pBUHQHjSrvdfM+gK3N6r2XwQsTymdb2anA5ullNRS6iaUtrVU/nmNOEh5lQJvPeu1\n8zI73sBLS1SlHej9Na/dklnbffCRQpysXF/flNs32K5O00O1wHvG5seA9VC/ssVzAMCbf3HSVZnR\nXn8W2uViVBbbZo61Qi1mF+22AHzRKUNMtyjfqirovSbq3Y4e4bUZIm5ezvDhfqeMs0tkpGjYzb4M\ni9R4m/kHydhTbLo/h6RvEw2zpq3LM4DlbdXea2Y3AA8CnzKzF8zsm8D5wCAzWwTsV30cBEEH4j3H\ndaWU1PsfqF/dQRB0GKLDLwgKSiR/EBSU1ozofv/UAYNqf99kPj10PsNJ0876lgwdKoqWvc/IOGXu\n71tID87Nat/PS4PMl+aWZTZXZcBV/2qPqGFgL6/9NrNjVWk6XIceJYp7nTK7nfRJIfbwI6nYQ69Z\nlz9ObwmXS6D/vz3ltEfTWXq3dwl9yxE69h1RwD5vFyf1FK3MAMuE30OuiFefdvPiaNFODTBLaHf4\nwh7AOOmX8LqMnVwzSqykfDAyxDt/EBSUSP4gKCiR/EFQUCL5g6CgRPIHQUFpV/feUqlTKpc3qlFV\n/yhcal2cNupLer/9RVVcW4RAT2E4wee04QSqIHyqKrU/Jzc/yC5y2vQv6EOtFC65dUm4UADyObtK\n9z7v/G2vzUuL9W6P6uO1699w0kDx2gB4j1wYmcSFAQwUT0TmRVsijDt6535u7xKdrfO89E6m/Vu9\nG+bcnTs96bWjMs7G16cHhTpcxr5h/k5Il40zJ7FX04elP0B5Rbj3BkGwBiL5g6CgRPIHQUGJ5A+C\ngtKu7b2vz32X+21lE23Pv+vi0Sg1+ulsva760UVe28MvYwfgEeEmu/JUHcupYn36ADFiSa3VBoS5\nK/xTx9Yl5Wug18LvYb64N0jvVhsAq8IeMFX4Ghy6v399+mWONVI4I8NcGTtKdF9f2tk7IwP0vsm7\nI9eZrmn9TGjDRWGuLlPwW5V6OK3TDtqrZr4o7ukV+tDDfA95w//p2C5CP0r+MMH1t2/WVCi9mjkD\nT7zzB0FBieQPgoISyR8EBSWSPwgKSnM8/CaYWYOZPdJIO8vMlpjZ/Oq/97GKOAiC9YHmzOr7PBUn\ngWsbufeeBbyeUhr3fg62vVm6tkYTnZcA/E5oOc+Nk5Nyjf1NJnpDoV0oI08SbrKXCOPb3J2Fq4SW\nGSHI2ekQL95ysw4W8uDaJ7bKnU8LcRvtt3qU+alr178mAr+ij9XnXq8tzlSpucdLI/+uQ8cn8QSP\nzfggjxHmIyu9+ciwTLvs5JLXVpV1rHrnzNzMoU4Yw/C5TLDq1P5FJvbYpvdzSqUTKZefapv23sy4\nriAIOjit+cx/opktqH4s2LTNzigIgnahpcl/BbA1MABYCvxvLrDxrL4VLTxYEARtT4uSP6X0Ykrp\nnZTSu1Q+2gonw3/F/mtW3yYtPcsgCNqcFrX3mlmvRlN6DwEeWVP8ahYDJ9ZofjhShZGqUPXx3J59\nBWq0bS8jzxPL+fnKWTJ2b6ENErWnB1Jm9FM3bwjwRK56stRX8U4SNUCASz7rtTszy+Y3EY68K0b4\nwh7A9dd4bfhHvTZJzfUCFg/wz8OEjEvuMeK1HF+fG6E1xUuZ5wYudsqsjX3Br3tuc2FK8Fqm4Ke8\nIb4m2scBps0XovBaAOBcoR2be25qU8/7L+R4z+SvjuvaB9jczF4AzgT2MbMBVKbz1gMjm33EIAjW\nC1o6ruuXa+FcgiBoR6LDLwgKSiR/EBSUSP4gKCjtaubRC/hhjdZJzYcDlgm9Z8Z0Y/ZF3iVX15iB\nr4x10i02RoYeLMxzn/2eisx0MIghb1NS7f2OCivN21BckjF74ICXnDTWdP16hWhX5RrdlT3TTnGa\nnFOXcw556TgnZRd9yMp+rvwt2q/7b5uJ9Xd+/Cuu7glUWeiljNcxPRnvtH0zsfUve62v6jQHxoub\nMSNPE/3QAPy05vENmThPvPMHQUGJ5A+CghLJHwQFJZI/CApK+47r2tlSuXbN9xY6drRY2z0ws9/B\nas35f2SCVV0stwhb2ATM/7HXDs5sXp+Ud66YPQWMNj++KtdJ1aCKpBMzwXs+LsT+meDtvHTvY06a\nqvqege8IbXnKzCebLPqRh2XsIUb7QiSzdKiq9I78b6+JrmUAHhLaxEysskW4WHdOc3L6mFDPkbHD\n7FtOmyx/lgCaWi6XSndQLi+PcV1BEOSJ5A+CghLJHwQFJZI/CApKJH8QFJR2be/lQ8BGNb9vXnlX\nhu4qiuKDk6pcA28J446cacYsdWsg49Zwla9Uf0mENWQ6L9+xA5x2bOa0VAG9IWUmv90/3Wt7ZmL7\niOdGbA7AAO+w8ejevtr/Ymbz5WmiULfUwcNuc1Kd6Rq8mmJY2ya+mnv+5LXx6o7SsozlMmJg4Wjd\n/q3uOJycviFDh5h3Srm17Kv6IP1EmC5+lgAOqvWAeR9eefHOHwQFJZI/CApKJH8QFJTmjOvqY2Z3\nm9ljZvaomY2q6puZ2UwzW1T9Gt79QdCBaM64rl5Ar5TSPDP7KDCXSkfrCOBvKaXzzex0YNOU0mlr\n2lep9JlULs+oUT8lYxtspdN6pDoZO1bE5mzCT1A+w7n2XrXkXI1YyswRmytaiY/IHGqRGDm23Hyx\nDWCR0J7M7He4qm9uJIwKALUWfpT1c1puffu0tJnT+pquvNaLMV7PZPwLtkkPOq2H6SdddT4/IIrH\n9/9DH0uVn71LQQX11O6UiZ2e1Ii0uTL2cvNuw8dlatJLavwaBgMPp9Rm47qWppTmVb9/DXgc6A0M\nASZVwyaRb3EPgmA95H195jezvsBnqax/2KKRd/8yskt0giBYH2l28pvZRlRG334vpdTk7+xU+ewg\nPz80Htf10kvLW3WyQRC0Hc1KfjPbgEri/yqlNK0qv1itB6yuCzSobRuP6+revVtbnHMQBG1Acyb2\nGJWl5Y+nlBr7Ht4GDAfOr3699T2P9uQC2LtXU+0ePXi8R/qiUN+UsWPSjl5ckKl5qGXVm/pCFQAb\n+2LVANFuNl80hYE+20Wv6tg+ori3OKmSEnSb7jvhds8YobKRL5axSaZCubN3J71U+Bdk3VGv88+X\nKuwBcOeNTlpsuhy6Dd6FtCFtJWPH2/Ne/K2Xemc8CfqqkXDP6dh6ZY6a7bDzL/y+orAHIAd+Pav3\n2vvapo83yLU+CprT3rsncDSw0MxWTxw7g0rS32Rm36Ty9BzW/MMGQbCuac64rj8AuVsH6u05CIIO\nQHT4BUFBieQPgoISyR8EBaVd3Xu7mrkm1jlX6NiB3/Warn2DalZVLbAAxyax4x30SXQT9gGqGfmB\nTAWfOn/GyzJr1nuK1tapmUr5od/3Wo//zZyDoCEXe/LvhPi00B7V23f3I8fqxJgq0P4FfusKfUVL\ndn9xgwcq3Wa1LFc/IKOUSwBwqSir5yZlHS801cUL8i7TO9d6DaDTV702+jc6trat+27glbZq7w2C\n4INJJH8QFJRI/iAoKJH8QVBQ2ndcV2mHVC43rXIMt11l7KS9hHhfpuR3tiii5Qw8P++lVZl21QFC\n6ys0NeIJYKVYo8/Oeo3+uX/22hmZYijfUSaRuRX9XZ2yv82UkdOENl9oe96UOZR6IsZljEU5Q2je\nT6CCn7f1R9NzsXY/S4iixqt+DgB4YpCTZmWer33TD5z2hv1IxnZJb3jxui76HP7qpWmZMWC1XgPL\ngX9GwS8IgjURyR8EBSWSPwgKSiR/EBSUSP4gKCjtW+3f3FK5tvh7jf7908+8j+qitFDveGvhmfrs\nzpmz8F6s802PTRpwgxCP2MNrOz2gD6U8Qu6ZmDmvIU45M+OG/l9C65Z7brjSS6/oRtpjxPlOSC95\n8T+FLTHAQC/VeX+QyikITd1tALhQaDmX3AnijsNc4bicu6+wQGg90mgZe4qd57Rx+mYObCP2K1yF\nARpUZf88cecIYI+mBywtgPLrUe0PgmANRPIHQUGJ5A+CgtKacV1nmdkSM5tf/Td47Z9uEARtRWvG\ndR0GvJ5SGtfcg5VKPVK5XNNLm1lLLx1iVeUHZKEJP8Erv99TlwoR3rJeTuucxCL/tL3cfoz41To2\n6XbXZNOdtrmMhOWirXRupq10F1W0fFHvt14U5/qqtf85R97tfft1/4x/waPpUC8O0W62O9+WOZ5g\nnnBS7v01ry3JjOuaKopwyj8BYJV4blRLOMAiNRIuU/DrIWaGZSaZ8XDN43OA+ma29zbHwHMpsLT6\n/WtmtnpcVxAEHZjWjOsCONHMFpjZhJjSGwQdi9aM67oC2JrKXzpLAWkO1XRcl1jZFATBOqHF47pS\nSi+mlN5JKb0LXAXsprZtOq4rs4QxCIJ2pznVfjmua/WcviqHAMJmMQiC9ZXmVPv3Au4DFgKr65Bn\nAEdS+ZM/AfXAyEYjuyUbmqU+NdqiuzPB+9zutQPlFDM9x+wxUZUH2FBU5o/MnMM1xwrRD3PbycbI\nzRcqh9me+lArhXGuvocASz7itcv/rmNF4Tgz8RBOSScJ1bdD72v95PbKamVi5ljqM+I7mdhJSbRq\nz5wnY5d/yWvd1J2F6/Sdhfu/7rU91R0e4Hnzr9BWub7h27cVoq639xdzG0WTNQANNW7BpZ9B+YW2\nq/bnxnXd2ZwDBEGwfhIdfkFQUCL5g6CgRPIHQUFp1/X8O5qlX9do2/1HJljN23pMFaSAly/xWs69\nV62x31wVY4CLnvLaqXc5abIdIDcfpgqJkzNjojYRVUt/KABG/rvXxid1YcB88UQMEAUwAH4qtEle\nmqqtZOsO89rKzHnNN39eA+TNYuAhb7V7ud0rQ49TDsK/FdoYUVAGuMsXlWdm2pmvEdrkF3Qsk4Wm\npqMBzBjrtc66qMxbTa+jVPoe5fKiWM8fBEGeSP4gKCiR/EFQUCL5g6CgRPIHQUFpX/fez1oq31Mj\n1qmyPsDFQntaRh4nZqldnnQpdbjt57RJSc8AnC6MKA5KD/rAE0T5Hdjp515bmDHzGCfMPE5JZ8lY\nyYaZ2Df9nYyTTNzFAC5Jf/HnYJ9wmp6uCIeLNtxvmW7DrTWhAMj5LY/3pwAXZIJv9dIAYfCRY77y\nlvnOFzLRfmhhg2ln4x7qGp7trHd70VtOus6PKwS8N82ewLyY1RcEwZqI5A+CghLJHwQFJZI/CApK\n+xb8+lsq19ZI+l+tg+8QI7Rezex4itA+k4ldLLTMGvvp53vtINW+2VsUAQFQtq9nZGK9F0qd6Tba\nlaruuU3mHJIoRvopUwB0/R+vrUrecGGV6QLYSKFdr9bSA6vMr6fvqoqpwK7mryE7riv5F+0U8TyO\nS8pOF06xDXys+DkAGCxenjulJwIcY74FfULKjOAa6tfzP3WzDt22piO7dBGUn4+CXxAEayCSPwgK\nSiR/EBSU5hh4bmhmfzKzh6vjus6u6puZ2UwzW1T9Gr79QdCBaI6BpwFdU0qvVy28/wCMAoYCf0sp\nnW9mpwObppROW9O+SqV+qVz+SY2aab8aJuZM1W66JmZl9CPUrPUtZGhf8/OrLhJxp2YOpUo/o5Je\nHH62+YFMZ2ZqeN8SNbyrM4U1EMPpR5+iQ4UtAsqrc+HRevvB1zlpXGbOlFixzh06lD3VevzrM8GT\nRJ/gHr7LcFLmuR0unDJ766Y9lii/6ownwVBhsLq/DmXkX4XYS1/waDuqyeOJwNK26vBLFV6vPtyg\n+i8BQ/j/Tg+TqMzvC4Kgg9DcoR2dzGw+0ADMTCk9BGzRyKp7Gbm3zyAI1kualfzVyTwDgC2B3cxs\nx5r/T1T+GnA0HdeVu1EfBEF7876q/SmlFcDdwAHAi6un9lS/NmS2aTSua+PWnm8QBG1Ec6r93c1s\nk+r3XYBBwBPAbcDwathw5GLKIAjWV5pT7f80lYJeJyq/LG5KKZ1jZt2oLGjeCngOOCyllPPMBeAj\nZmm7Gm3etzPB430LaV/Ts73qk7e5HZRx1J2p5kRlKtKjhSXAeaJqe7EYnwVwsriRcd3XdOzRaSsv\nDntexk4XN0Jya+HPFNrATOxw5bTbyb+k/dUMMEAV0OvSQhn7jvkG3XGZ81L+AfuqOwAAF6qDeWn/\nzJi4GbV+EwCf/0HmYOKH6Q49N22smDQ3PrPXxenPXhzyWRk75bamj88Anmlmtb8547oWAO7IKaXl\nwBebc5AgCNY/osMvCApKJH8QFJRI/iAoKO27nn9LS+VRNeKph2SiRVvqSL2+vf5Kr/VNe8jYV+wB\np+WmRC1SRbg3RBGuizYAnSIMQA/PjXNSBo9vKfMB2MP6OO0BfQoM8afwr1s0tdQLbZDQdvpxZgeq\nEDgmM5PqRm+kyhG6bDlSmIBmlrfTsL0QvTcqbJNZpC/LYH116Odq7TOBzOvbV7TsfixzBqq7t2sm\n9viaxxcAz4WBZxAEayKSPwgKSiR/EBSUSP4gKCiR/EFQUNq32t/TUvmoGnFczqHjXKfMNrl2CNWR\neWbOGVU1JZ7yMx26tZf2qS2voj16AT4ltG2THtE0yfyIpuHX6P0O/YbXpmVfx3299Ibube0t2pR/\nI+KezRxJtRKLpxCAGV/xWreMm4fojGWSnpAGT3rpctF0rirqAGOlq+9hmehNhJaxgsbPbquzlTJS\nTeaaltnrvJqbJqWHoLwyqv1BEKyBSP4gKCiR/EFQUCL5g6CgvOeS3jblLfy4rAXeIReAb3ppn3Sf\nDN2Hw73YyY88AmA/r3fNrA1XxrXzNxLixXr7CcKrYFv2lLHD00NOW2Z6bfgQqarSHLCHKO5tqEOX\n7CjEvb30kK9dAbBIeRXk5mqd5t2Gl+d+HM/2BgbnnqVDzxCTxHYQT8FxSXsu14txXcv0odhdTS3L\nmFHvKnp5V34ns+MrfNFxzEf9eQFQ277dKbNPQbzzB0FBieQPgoISyR8EBSWSPwgKSmtm9Z1lZkvM\nbH713+C1f7pBELQVrZnVdwDwekopZ7rqKJU+mcrlpo6no01P+TpPtG8uy8xX65kmenHiCB0sDCf6\niTsLAIuSaD2+WNydyJmW3+NLvFeZbixVjrrbZVqBnxCtwJlaMNscKcTJwqUX4GLfB9tD9C43qH5q\nAGEoMkv15gL7KtONx3ro4A19W/e0f+jQoaKV9xhxubm2Y/VSio5hAFYmYT5yuDceAWDKsUK8PLNn\ncZuoa6bX+/6mD0vDoPxY27n3JkDN6guCoAPTmll9ACea2QIzm5Ab0d10XJdeyBAEQfvTmll9V1D5\n62kAsBQ5waB2XFddG512EAStpcWz+lJKL1Z/KbwLXEXeBzMIgvWQ9/zMb2bdgX+mlFY0mtV3gZn1\najSi+xDUPdYjAAAFp0lEQVTgkZacwHm5rUR9o+d3deihNsJpqzK7FZ7ALEq/zkSLp0f1/N5zUmb7\nzzjl2PRVGdlbOP32E4U9gNnpJacNs+4ydrKY8jTB9FS1Y0SsWlsu52cBI4UfwBQdyorH5ghVzdoC\n3rzfSUNnZ1bkz/DSBPW29JAu+Y05ybsVbJOxnGgQrsI90rY6eOJVTjr8G14DmKLa2FcJAwRgsDV1\nEF6kjy5pTm9/L2CSmTWe1Xe7mV1nZgOoFP/qgZHv47hBEKxjWjOr7+i1ckZBELQL0eEXBAUlkj8I\nCkokfxAUlHY183hk7jNsV9POm/GVYP6rQlQdksBUX1SH+Vdn9qw8dXUlVd4bEKbAK+0SuXWd8ot4\naYSMXZIWevHAjBPGGF3Zl4gbEZvJEj6c8GevXaZap0ePkNurlyFLZ3/L4CplnAscK7pdVVUf4Mzn\nvHb27SJw54wHsbij9MzGOpQVquy1i44937eFqxtHFbzD9OjMnZ/aZ3F+dp+eeOcPgoISyR8EBSWS\nPwgKSiR/EBSU9h3XVeqWyuWa4tor18nYXcUa7Dk/yOxYLYbP1cQGjPXasDE6drJv++1d004JsCTj\nBAu+UjTQ9LHuS77SNNuukLH7pEO8+JebZewq0cWaqZuyQmh3pk/749sCuf1ssc7/BOH+C3CZmoDl\nu5YBPV2sy8M6FvVSzPBOwUNtqtx8P6FlLAnYKgmzhH7eaRjgtKe9dkGmrfwW8TN28C/1OfSs8aJY\nDvwzxbiuIAjWQCR/EBSUSP4gKCiR/EFQUCL5g6CgtO+sPgDebvLoiYyRrLTHyJmDf9JLvTPV/iXp\neKd1u0FX4JdPfttpqkgNb+qDzb7ISV5Zje9X3efHuVjfdrzT1rrav9CPAGTy15u9W6C3U2ZvoKv9\ns0Rlv5w51K43eW2OqOoDdJkl+o6/IZxHAGZ4R93DRWV/2lmZExNe1MNf9xrApBtFZf/3OvYCNaLx\nBF/VB1AjD1cJoxTw3ea551sR7/xBUFAi+YOgoETyB0FBieQPgoLSru29ZvYSsHrF9ebAy+128PYj\nrqvj8UG6to+nlJpl+NCuyd/kwGbllFJpnRx8LRLX1fH4IF/bmog/+4OgoETyB0FBWZfJf+U6PPba\nJK6r4/FBvrYs6+wzfxAE65b4sz8ICkq7J7+ZHWBmT5rZ02Z2ensfvy0xswlm1mBmjzTSNjOzmWa2\nqPp103V5ji3BzPqY2d1m9piZPWpmo6p6h742M9vQzP5kZg9Xr+vsqt6hr6ultGvyV4d9/hz4MpU1\nCUeamXDC7zBMBA6o0U4Hfp9S6kdlmUdH/AX3NvD9lNIOwO7A8dXXqaNf2z+AfVNKnwEGAAeY2e50\n/OtqEe39zr8b8HRK6dmU0lvAjcCQdj6HNiOldC9QO+96CDCp+v0k4GA6GCmlpSmledXvXwMep7K8\nr0NfW6qweo3eBtV/iQ5+XS2lvZO/N7C40eMXUGtGOzZbpJSWVr9fBmyxLk+mtZhZXypTmh/iA3Bt\nZtbJzOYDDcDMlNIH4rpaQhT81iKpciulw95OMbONgN8A30sprWz8fx312lJK76SUBgBbAruZ2Y41\n/98hr6sltHfyLwH6NHq8ZVX7IPGimfUCqH5tWMfn0yLMbAMqif+rlNK0qvyBuDaAlNIK4G4qNZsP\nzHW9H9o7+ecA/czsE2bWGTgCuK2dz2FtcxswvPr9cODWdXguLcLMDPgl8HhK6eJG/9Whr83MupvZ\nJtXvuwCDgCfo4NfVUtq9ycfMBgM/AToBE1JKWbOq9R0zuwHYh8qqsBeBM4FbgJuAraisYDwspVRb\nFFyvMbO9gPuAhcC7VfkMKp/7O+y1mdmnqRT0OlF547sppXSOmXWjA19XS4kOvyAoKFHwC4KCEskf\nBAUlkj8ICkokfxAUlEj+ICgokfxBUFAi+YOgoETyB0FB+X/F2WPGzREINgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1088bfeb8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# or...\n",
    "plt.imshow(image, cmap=plt.cm.hot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## Indexing and Slicing \n",
    "\n",
    "- In 2D, the first dimension corresponds to rows, the second to columns.\n",
    "- for multidimensional a, a[0] is interpreted by taking all elements in the unspecified dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "a # indexing begins at 0 , unlike fortran or "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0],\n",
       "       [0, 1, 0],\n",
       "       [0, 0, 2]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# For multi-dimensional arrays, indexing are tuples of integers\n",
    "a = np.diag(np.arange(3))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[1,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 0])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true,
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "a[2, 1] = 10 # replaces row 3, second value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  0,  0],\n",
       "       [ 0,  1,  0],\n",
       "       [ 0, 10,  2]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing\n",
    "a = np.arange(10)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 5, 8])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2:9:3] # [start:end:step]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:4] # note: last index isn't included"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "# all three slice components are not required"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### An illustration of Numpy indexing and splicing\n",
    "\n",
    "<img src=\"figures/numpy_indexing.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Answer to above questions is: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5],\n",
       "       [10, 11, 12, 13, 14, 15],\n",
       "       [20, 21, 22, 23, 24, 25],\n",
       "       [30, 31, 32, 33, 34, 35],\n",
       "       [40, 41, 42, 43, 44, 45],\n",
       "       [50, 51, 52, 53, 54, 55]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(6) + np.arange(0, 51, 10)[:, np.newaxis]\n",
    "print(\"Answer to above questions is: \")\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Orange is:  [3 4]\n"
     ]
    }
   ],
   "source": [
    "print(\"Orange is: \", a[0, 3:5])\n",
    "# Try similarly others to get more answers and play with this array a bit more"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 0, 0, 0],\n",
       "       [0, 4, 0, 0],\n",
       "       [0, 0, 4, 0],\n",
       "       [0, 0, 0, 4]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(np.tile(4,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([0, 1, 2])\n",
    "np.tile(x, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2, 1, 2],\n",
       "       [3, 4, 3, 4, 3, 4]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.array([[1,2], [3,4]])\n",
    "np.tile(y, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Solve this puzzel to arrive to the following answer:\n",
    "\n",
    "$$x = \n",
    "\\begin{bmatrix}\n",
    "    4 & 5 & 4 & 5 & 4 & 5 \\\\\n",
    "    6 & 7 & 6 & 7 & 6 & 7 \\\\\n",
    "    4 & 5 & 4 & 5 & 4 & 5 \\\\\n",
    "    6 & 7 & 6 & 7 & 6 & 7 \\\\\n",
    "\\end{bmatrix}\\tag{1}$$\n",
    "\n",
    "**Hint**: play with np.tile()\n",
    "\n",
    "##### I will publish a full solution page later..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## Copies and views\n",
    "\n",
    "A slicing operation creates a view on the original array, which is just a way of accessing array data. Thus the original array is not copied in memory. You can use `np.may_share_memory()` to check if two arrays share the same memory block. Note however, that this uses heuristics and may give you false positives."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "a # you get  the range from 0 to 9 - total of 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = a[::2]\n",
    "b # you get every 3rd object, as 0,1 -->2, 2,2 -->4 and so on"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.may_share_memory(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12,  2,  4,  6,  8])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[0] = 12 #we replace 0 with 12\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12,  1,  2,  3,  4,  5,  6,  7,  8,  9])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# So what is a then?\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's rearrange\n",
    "a = np.arange(10)\n",
    "c = a[::2].copy() # we force copy\n",
    "c[0] = 12\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "#### So, what happened?\n",
    "\n",
    "Let's do it step by step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = a[::2].copy()\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12,  2,  4,  6,  8])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c[0] = 12\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "#### They simply didnt share the same memory block and thus giving you a false positive!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.may_share_memory(a, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## Fancy Indexing\n",
    "\n",
    "NumPy arrays can be indexed with slices, but also with boolean or integer arrays **(masks)**. This method is called fancy indexing. It creates copies **not** views."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10,  3,  8,  0, 19, 10, 11,  9, 10,  6,  0, 12,  7, 14, 17])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(3)\n",
    "a = np.random.randint(0, 20, 15)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True, False,  True, False, False, False,  True, False,\n",
       "        True,  True,  True, False, False, False], dtype=bool)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a % 3 ==0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  0,  9,  6,  0, 12])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = (a % 3 == 0)\n",
    "get_from_a = a[mask]\n",
    "get_from_a # you extract a sub-array from mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "hideCode": false,
    "hideOutput": true,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, -1,  8, -1, 19, 10, 11, -1, 10, -1, -1, -1,  7, 14, 17])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indexing with mask can be fun to assign a new value to a sub-array\n",
    "a[a % 3 == 0] = -1\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## Indexing with array of integers "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "a = np.arange(10)\n",
    "idx = np.array([[3,4], [6,7]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "idx.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 4],\n",
       "       [6, 7]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[idx]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Here's another fun exercise to play with...\n",
    "\n",
    "This image shows various ways to index, play with these and come back with your own results 👇\n",
    "\n",
    "<img src='figures/numpy_fancy_indexing.png'>\n",
    "\n",
    "and your little exercise could be:\n",
    "\n",
    "### Exercise 2 : Reproduce this fancy index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hideOutput": true,
    "hidePrompt": false
   },
   "source": [
    "# SOLUTIONS\n",
    "\n",
    "## Exercise 1, Solutions 1, 2, 3\n",
    "\n",
    "**Hint**: use help(np.diag) for info.\n",
    "\n",
    "and also try out some more yourself!\n",
    "\n",
    "**NOTE**: As this Numpy lecture expands, the exercise portion will expand too and the solutions will be provided in another ipynb notebook later"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### --------------------------------------------------------------------------------------------------------------###\n",
    "# Solutions and explanations to exercises \n",
    "### --------------------------------------------------------------------------------------------------------------###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Exercise 1: Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function diag in module numpy.lib.twodim_base:\n",
      "\n",
      "diag(v, k=0)\n",
      "    Extract a diagonal or construct a diagonal array.\n",
      "    \n",
      "    See the more detailed documentation for ``numpy.diagonal`` if you use this\n",
      "    function to extract a diagonal and wish to write to the resulting array;\n",
      "    whether it returns a copy or a view depends on what version of numpy you\n",
      "    are using.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    v : array_like\n",
      "        If `v` is a 2-D array, return a copy of its `k`-th diagonal.\n",
      "        If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th\n",
      "        diagonal.\n",
      "    k : int, optional\n",
      "        Diagonal in question. The default is 0. Use `k>0` for diagonals\n",
      "        above the main diagonal, and `k<0` for diagonals below the main\n",
      "        diagonal.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    out : ndarray\n",
      "        The extracted diagonal or constructed diagonal array.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    diagonal : Return specified diagonals.\n",
      "    diagflat : Create a 2-D array with the flattened input as a diagonal.\n",
      "    trace : Sum along diagonals.\n",
      "    triu : Upper triangle of an array.\n",
      "    tril : Lower triangle of an array.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> x = np.arange(9).reshape((3,3))\n",
      "    >>> x\n",
      "    array([[0, 1, 2],\n",
      "           [3, 4, 5],\n",
      "           [6, 7, 8]])\n",
      "    \n",
      "    >>> np.diag(x)\n",
      "    array([0, 4, 8])\n",
      "    >>> np.diag(x, k=1)\n",
      "    array([1, 5])\n",
      "    >>> np.diag(x, k=-1)\n",
      "    array([3, 7])\n",
      "    \n",
      "    >>> np.diag(np.diag(x))\n",
      "    array([[0, 0, 0],\n",
      "           [0, 4, 0],\n",
      "           [0, 0, 8]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.diag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Exercise 1: Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1 1 1]\n",
      " [1 1 1 1]\n",
      " [1 1 1 8]\n",
      " [1 6 1 1]]\n"
     ]
    }
   ],
   "source": [
    "a = np.ones((4, 4), dtype=int)\n",
    "a[3, 1] = 6\n",
    "a[2, 3] = 8\n",
    "#a[[3, 1], [2, 3]] = [6, 8] -  - yoc can also do them together\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Exercise 1: Solution 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0.,   0.,   0.,   0.,   0.],\n",
       "       [  7.,   0.,   0.,   0.,   0.],\n",
       "       [  0.,   8.,   0.,   0.,   0.],\n",
       "       [  0.,   0.,   9.,   0.,   0.],\n",
       "       [  0.,   0.,   0.,  10.,   0.],\n",
       "       [  0.,   0.,   0.,   0.,  11.]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.zeros((6, 5))\n",
    "b[1:] = np.diag(np.arange(7,12))\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Exercise 1: Solution 3 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.],\n",
       "       [ 1.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  1.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  1.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  1.,  0.]])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.eye(6, 5, k=-2, dtype=float)\n",
    "y"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Hide code",
  "hide_code_all_hidden": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}