gridded_data_tutorial_0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**0: NumPy and the ndarray** | [1: Introduction to xarray](gridded_data_tutorial_1.ipynb)  | [2: Daymet data access](gridded_data_tutorial_2.ipynb) | [3: Investigating SWE at Mt. Rainier with Daymet](gridded_data_tutorial_3.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notebook 0: NumPy and the ndarray\n",
    "Waterhackweek 2020 | \n",
    "Steven Pestana (spestana@uw.edu)\n",
    "\n",
    "**By the end of this notebook you will be able to:**\n",
    "* Create and manipulate ndarrays\n",
    "* Index and slice ndarrays\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy: working with multi-dimensional arrays in python\n",
    "\n",
    "The [NumPy](https://numpy.org/) library is at the core of the \"[scientific python ecosystem](https://www.scipy.org/)\". NumPy provides an `ndarray` data type which can be used to represent multi-dimensional gridded data. It also includes linear algebra functions and other useful math functions. \n",
    "\n",
    "See these resources for more detailed NumPy information and tutorials:\n",
    "* [NumPy: the absolute basics for beginners](https://numpy.org/devdocs/user/absolute_beginners.html)\n",
    "* [NumPy: creating and manipulating numerical data](https://scipy-lectures.org/intro/numpy/index.html)\n",
    "* [Advanced NumPy](https://scipy-lectures.org/advanced/advanced_numpy/index.html)\n",
    "* [NumPy for MATLAB users](https://numpy.org/doc/stable/user/numpy-for-matlab-users.html)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**To get started, import NumPy and give it an alias `np` (this shorthand is commonly used in the python community)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Take a quick look at the `np.array()` function that lets us create an array.** The main input that this function needs is an \"array_like\" object. We can create a python list of integer values and pass it to this function to turn that list into an `ndarray`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function array in module numpy:\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.\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_like : Return an empty array with shape and type of input.\n",
      "    ones_like : Return an array of ones with shape and type of input.\n",
      "    zeros_like : Return an array of zeros with shape and type of input.\n",
      "    full_like : Return a new array with shape of input filled with value.\n",
      "    empty : Return a new uninitialized array.\n",
      "    ones : Return a new array setting values to one.\n",
      "    zeros : Return a new array setting values to zero.\n",
      "    full : Return a new array of given shape filled with value.\n",
      "    \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": "markdown",
   "metadata": {},
   "source": [
    "**Create a 1-dimensional array from a list object:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [0,1,2,3,4,5,6,7,8,9]\n",
    "\n",
    "# check the type of my_list\n",
    "type(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create an array from this list\n",
    "one_dimensional_array = np.array(my_list) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "print(one_dimensional_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**We can check the data type of this object, and see that it is an `ndarray`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(one_dimensional_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**We can also look at the array's shape, and [data type](https://numpy.org/doc/stable/user/basics.types.html) of its contents.** Because we didn't specify in the `np.array()` function what data type we wanted, it will by default pick a data type for us based on the values in the list object we provided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10,)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_dimensional_array.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_dimensional_array.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Create a 2-dimensional array (this array has three rows and three columns):**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.44 2.5  3.72]\n",
      " [1.98 2.12 3.89]\n",
      " [1.04 2.63 3.17]]\n",
      "\n",
      " Our array has a shape of (3, 3)\n"
     ]
    }
   ],
   "source": [
    "two_dimensional_array = np.array([[1.44, 2.50, 3.72],\n",
    "                                  [1.98, 2.12, 3.89],\n",
    "                                  [1.04, 2.63, 3.17]])\n",
    "\n",
    "print( two_dimensional_array )\n",
    "\n",
    "print(\"\\n Our array has a shape of {}\".format( two_dimensional_array.shape ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Check the data type of the array's contents.** Note that because we provided numbers with some fractional value, numpy chose a floating-point data type for us. We could have also specified this ourselves by including the argument `dtype=np.float64` when we created the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dimensional_array.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Create an array filled with zeros using `np.zeros()`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array of zeros:\n",
      "[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# create a 5 by 10 array of just zeros\n",
    "array_of_zeros = np.zeros((5,10))\n",
    "print(\"Array of zeros:\\n{}\".format(array_of_zeros))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Create an array filled with ones using `np.ones()`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array of ones:\n",
      "[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "# create a 1 dimensional array of just ones\n",
    "array_of_ones = np.ones(10)\n",
    "print(\"Array of ones:\\n{}\".format(array_of_ones))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Create an array filled with ones, with the same shape as another array, using `np.ones_like()` (also try `np.zeros_like()`)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array of ones like two_dimensional_array:\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# create an array of ones with the same shape as our earlier 2D array:\n",
    "array_of_ones_2d = np.ones_like(two_dimensional_array)\n",
    "print(\"Array of ones like two_dimensional_array:\\n{}\".format(array_of_ones_2d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Create an empty array with `np.empty()`, then fill it with a specific value we want.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My array:\n",
      "[3.14 3.14 3.14 3.14 3.14 3.14 3.14 3.14 3.14 3.14]\n"
     ]
    }
   ],
   "source": [
    "# create an empty array\n",
    "my_array = np.empty(10)\n",
    "# then fill it with some value\n",
    "my_array.fill(3.14)\n",
    "print(\"My array:\\n{}\".format(my_array))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Use `np.arange()` to get values spaced evenly within an interval.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array with values between 1 and 100, incrementing by 5 with each step:\n",
      "[ 1  6 11 16 21 26 31 36 41 46 51 56 61 66 71 76 81 86 91 96]\n"
     ]
    }
   ],
   "source": [
    "# create an array with values between 1 and 100, incrementing by 5 with each step\n",
    "my_arange_array = np.arange(1, 100, 5)\n",
    "print(\"Array with values between 1 and 100, incrementing by 5 with each step:\\n{}\".format(my_arange_array))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Use `np.linspace()` and `np.logspace()` to get linear and logarithmic arrays between an interval.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear array:\n",
      "[   10.  3340.  6670. 10000.]\n",
      "\n",
      "Logarithmic array:\n",
      "[   10.   100.  1000. 10000.]\n"
     ]
    }
   ],
   "source": [
    "# create a linear array with values between 10 and 10000\n",
    "my_linear_array = np.linspace(10, 10000, 4)\n",
    "print(\"Linear array:\\n{}\".format(my_linear_array))\n",
    "\n",
    "# create a logarithmic array with values between 10**1 and 10**4\n",
    "my_log_array = np.logspace(1, 4, 4)\n",
    "print(\"\\nLogarithmic array:\\n{}\".format(my_log_array))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Finally, create arrays filled with $10^5$ random numbers sampled from different distributions using `np.random` functions.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random samples from a normal distribution with mean=0, variance=1:\n",
      "[-0.00757252 -0.66049993  0.64982572 ...  0.32073466 -0.01704125\n",
      "  1.06092611]\n",
      "\n",
      "Random samples from a normal distribution with mean=20, variance=5:\n",
      "[29.16648342 23.62604337 15.60549875 ... 15.08201433 20.20685545\n",
      " 19.873711  ]\n",
      "\n",
      "Random samples from a uniform distribution between -1 and 5:\n",
      "[ 1.82154101 -0.91150724  3.05211754 ... -0.88233708  1.03586968\n",
      "  4.5336232 ]\n"
     ]
    }
   ],
   "source": [
    "# create an array of 5 random samples from a normal distribution with mean=0, variance=1\n",
    "my_random_array_1 = np.random.randn(10**5)\n",
    "print(\"Random samples from a normal distribution with mean=0, variance=1:\\n{}\".format(my_random_array_1))\n",
    "\n",
    "# create an array of 5 random samples from a normal distribution with mean=20, variance=5\n",
    "my_random_array_2 = np.random.normal(20, 5, 10**5)\n",
    "print(\"\\nRandom samples from a normal distribution with mean=20, variance=5:\\n{}\".format(my_random_array_2))\n",
    "\n",
    "# create an array of 5 random samples from a uniform distribution between -1 and 5\n",
    "my_random_array_3 = np.random.uniform(-1, 5, 10**5)\n",
    "print(\"\\nRandom samples from a uniform distribution between -1 and 5:\\n{}\".format(my_random_array_3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Import matplotlib and plot these random samples from different distributions:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7ff7fc6d17b8>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(my_random_array_1, bins=100, label='Normal distribution with mean=0, variance=1')\n",
    "plt.hist(my_random_array_2, bins=100, label='Normal distribution with mean=20, variance=5')\n",
    "plt.hist(my_random_array_3, bins=100, label='Uniform distribution between -1 and 5');\n",
    "\n",
    "plt.xlabel('Value')\n",
    "plt.ylabel('Number of Random Samples')\n",
    "\n",
    "plt.legend(loc=(0.1,-0.4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Index/slicing ndarrays\n",
    "\n",
    "**To select specific elements within an ndarray, you can use slicing, or indexing.**\n",
    "\n",
    "The syntax for specifying a **slice** is `x[i:j:k]` where for an array `x`, `i` specifies the index to start the slice at, `j` the index to end the slice, and `k` the step size to take moving between `i` and `j`. A step size of 1 does not need to be explicitly stated, it is the default when no step size is provided (`x[i:j]`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " A one dimensional array:\n",
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "# Create a one dimensional array to work with\n",
    "one_dimensional_array = np.arange(0,10,1)\n",
    "# Print out our array\n",
    "print(\"\\n A one dimensional array:\\n{}\".format(one_dimensional_array) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Slicing an array:** Starting at the first element (index=0), slice until the fifth element, with a step size of 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Starting at the first element (index=0), slice until the fifth element, with a step size of 2\n",
    "one_dimensional_array[0:5:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Negative indexes** will count backwards from the last element in an array (where the last element has index of -1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Select the second-to-last element of this one-dimensional array\n",
    "one_dimensional_array[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**We can use these methods to change the values in the array.** To do this, we first specify the index we want to change, then assign a new value with `=`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Our modified array:\n",
      "[10  1  2  3  4  5  6  7  8  9]\n"
     ]
    }
   ],
   "source": [
    "one_dimensional_array[0] = 10\n",
    "\n",
    "# Print out the array now that we've change one of its values\n",
    "print(\"\\n Our modified array:\\n{}\".format(one_dimensional_array) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**And can perform all sorts of math functions on the entire array or segments of the array.**\n",
    "\n",
    "Note that here we're using a shorthand syntax where `x = x * 2` is equivalent to `x *= 2` (similarly `x = x + 1` is equivalent to `x += 1`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiply the first four values by two, and replace the original values with the new values\n",
    "one_dimensional_array[0:4] *= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20,  2,  4,  6,  4,  5,  6,  7,  8,  9])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_dimensional_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**We can also use conditional statements to create arrays of boolean values** (`True`/`False`), and use these boolean arrays to select elements from an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True  True  True  True  True False  True False  True False]\n"
     ]
    }
   ],
   "source": [
    "# Find even numbers by taking modulo 2\n",
    "even_number_conditional = one_dimensional_array % 2 == 0\n",
    "print(even_number_conditional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20,  2,  4,  6,  4,  6,  8])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now use this to select only where our boolean array is True\n",
    "one_dimensional_array[even_number_conditional]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False False False False False  True False  True False  True]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([5, 7, 9])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can use the \"~\" (bitwise not) operator to invert our boolean array values, and then select only odd numbers\n",
    "print(~even_number_conditional)\n",
    "one_dimensional_array[~even_number_conditional]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Working with more than one dimension\n",
    "\n",
    "**We can slice through multiple dimensions**, separating the slice for each dimension with a comma like `x[i:j:k,l:m:n]` where `i`, `j`, and `k` slice the first dimension, and `l`, `m`, and `n` slice the second dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " A two dimensional array:\n",
      "[[-0.74664529  0.53067262  0.45067967]\n",
      " [-1.01182386  0.02002937 -0.54327277]\n",
      " [-0.1460555   0.25628652  0.04196928]]\n"
     ]
    }
   ],
   "source": [
    "# Create a two dimensional array to work with\n",
    "two_dimensional_array = np.random.normal(0, 1, (3,3))\n",
    "print(\"\\n A two dimensional array:\\n{}\".format(two_dimensional_array) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.74664529,  0.53067262],\n",
       "       [-1.01182386,  0.02002937]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Select the first two indices of each dimension from a 2-dimensional array\n",
    "two_dimensional_array[0:2, 0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A single index can also be specified to select a single element from the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.020029370780407105"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Select the single value from the center of this 3x3 array\n",
    "two_dimensional_array[1,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:whw]",
   "language": "python",
   "name": "conda-env-whw-py"
  },
  "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}