session-three/session-three-teaching-solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python for Data Science Teaching Session 3: Data Processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Session Objectives"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Creating arrays and accessing elements\n",
    "- Reshaping and combining arrays\n",
    "- Arithmetic and aggregations\n",
    "- Filtering and sorting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting Started with NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What is NumPy?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In one word, fast. NumPy is a Python package (and part of the SciPy stack) devoted to processing and performing mathematical operations on data. Although faster solutions do exist ([Numba](https://numba.pydata.org/), [TensorFlow](https://www.tensorflow.org/overview), etc.), NumPy is powerful enough for almost all use cases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The backbone of NumPy is the array. These arrays differ from Pandas dataframes and base Python lists in two ways:\n",
    "\n",
    "- The same datatype must be used for all elements in an array\n",
    "- Every axis (dimension) must contain blocks of the same shape (i.e. arrays are rectangular, cuboidal, etc.)\n",
    "\n",
    "Because we have consistent types and structure, operations on NumPy arrays can be performed much faster than methods we've seen so far."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Technical Note**\n",
    ">\n",
    "> Technically, the second rule can be relaxed, in which case we obtain what is known as a _ragged array_. This however loses most of the efficiency of NumPy so is advised against."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Typically we import `numpy` under the alias `np`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import packages\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating an Array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### From Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The simplest way to create an array is by passing a number, list, list-of-lists, etc. into `np.array`. As with, Pandas dataframes, we can then view the dimensions of the array with the `.shape` attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "# Create a 0-D array and print its shape\n",
    "arr = np.array(42)\n",
    "print(arr)\n",
    "print(arr.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "(3,)\n"
     ]
    }
   ],
   "source": [
    "# Create a 1-D array and print its shape\n",
    "arr = np.array([1, 2, 3])\n",
    "print(arr)\n",
    "print(arr.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **An Idea to Ponder**\n",
    ">\n",
    "> What is the difference between `(3)` and `(3,)`? Perhaps look at their `type(...)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "# Create a 2-D array and print its shape\n",
    "arr = np.array([\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6]\n",
    "])\n",
    "print(arr)\n",
    "print(arr.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we provide lists containing different datatypes, NumPy will try to coerce them into the same type (giving an error if this process fails)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2.],\n",
       "       [3., 4.]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create an array from different data types\n",
    "arr = np.array([\n",
    "    [True, 2],\n",
    "    [3.0, 4]\n",
    "])\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, it can be hard to predict what datatype you will obtain when doing this, so it is best practice to ensure that you have the same datatype _before_ creating an array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Further Reading**\n",
    ">\n",
    "> You can convert between types by using the `.astype()` method of a NumPy array, passing in one of the types listed [here](https://numpy.org/devdocs/user/basics.types.html). E.g. `arr.astype(np.int32)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice, that by nesting lists in lists, you can create arrays with different dimensions that contain the same data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "() (1, 1)\n"
     ]
    }
   ],
   "source": [
    "# Create arr1, arr2 with the same data but different dimensions\n",
    "arr1 = np.array(1)\n",
    "arr2 = np.array([[1]])\n",
    "print(arr1.shape, arr2.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy has the ability to create random arrays. This is done using the `random` submodule whose documentation can be found [here](https://numpy.org/doc/1.16/reference/routines.random.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[56, 73, 25],\n",
       "        [32, 45, 56]],\n",
       "\n",
       "       [[40, 89, 13],\n",
       "        [42, 60, 72]],\n",
       "\n",
       "       [[44, 21, 87],\n",
       "        [75, 66, 11]]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a 3x2x3 grid of random integers between 1 and 100\n",
    "arr = np.random.randint(1, 101, size=(3, 2, 3))\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Warning**\n",
    ">\n",
    "> All `np.random` functions use the parameter `size` to specify the arrays `shape`. This is because many distributions such as `gamma` already have a `shape` parameter. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can create reproducible randomness using `np.random.seed(...)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.49671415, -0.1382643 ,  0.64768854,  1.52302986, -0.23415337,\n",
       "       -0.23413696,  1.57921282,  0.76743473, -0.46947439,  0.54256004])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set the random seed to 42 and generate 10 random standard normal samples\n",
    "np.random.seed(42)\n",
    "np.random.standard_normal(size=(10,))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Arrays from Dataframes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can convert entire dataframes, series or indexes into NumPy arrays, using the `.to_numpy()` method. It is important to only do this when datatypes are consistent else this may result in unexpected type conversions or a errors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Good to Know**\n",
    ">\n",
    "> In older versions of Pandas, the same effect could be achieved using the `.values` attribute. This is however being fazed out for the more consistent `.to_numpy()` approach. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, we can extract the predictors from the iris dataset as a NumPy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal_length</th>\n",
       "      <th>sepal_width</th>\n",
       "      <th>petal_length</th>\n",
       "      <th>petal_width</th>\n",
       "      <th>species</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal_length  sepal_width  petal_length  petal_width species\n",
       "0           5.1          3.5           1.4          0.2  setosa\n",
       "1           4.9          3.0           1.4          0.2  setosa\n",
       "2           4.7          3.2           1.3          0.2  setosa\n",
       "3           4.6          3.1           1.5          0.2  setosa\n",
       "4           5.0          3.6           1.4          0.2  setosa"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load the iris dataset\n",
    "iris = pd.read_csv('https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv')\n",
    "iris.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5.1, 3.5, 1.4, 0.2],\n",
       "       [4.9, 3. , 1.4, 0.2],\n",
       "       [4.7, 3.2, 1.3, 0.2],\n",
       "       [4.6, 3.1, 1.5, 0.2],\n",
       "       [5. , 3.6, 1.4, 0.2],\n",
       "       [5.4, 3.9, 1.7, 0.4],\n",
       "       [4.6, 3.4, 1.4, 0.3],\n",
       "       [5. , 3.4, 1.5, 0.2],\n",
       "       [4.4, 2.9, 1.4, 0.2],\n",
       "       [4.9, 3.1, 1.5, 0.1]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extract the first 10 rows predictors as an array, X\n",
    "X = iris.drop('species', axis=1).head(10).to_numpy()\n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact, Pandas dataframes are built on top of NumPy arrays. More on this in the project session."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have already seen the `shape` attribute of NumPy arrays. There are a few more of interest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Number of dimensions of X\n",
    "X.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Datatype of X\n",
    "X.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "600"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Number of elements in X\n",
    "X.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Storage size for each element in X\n",
    "X.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4800"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Total storage size of X (= X.size * X.itemsize)\n",
    "X.nbytes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing and Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access individual elements of an array or create sub-arrays in the exact same way we would with Python lists or Pandas dataframes using `iloc`. We can specify as many indexes or slices as we like up to number of dimensions in the array, separated by commas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> If your knowledge of slicing is lacking, checkout [session five](https://education.wdss.io/beginners-python/session-four/) of WDSS's Beginner's Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an array to slice\n",
    "np.random.seed(253)\n",
    "arr = np.random.random(size=(10, 5, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7114843937577212"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extract the element in position (7, 4, 2)\n",
    "arr[6, 3, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.13452044, 0.3347907 , 0.26034674])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extract the 1D array in position (3, 4)\n",
    "arr[2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.26205987, 0.50778879, 0.11435038, 0.41124492, 0.51218467],\n",
       "       [0.99028703, 0.6962767 , 0.64491784, 0.56633963, 0.45558134],\n",
       "       [0.31493584, 0.39719045, 0.84375933, 0.13452044, 0.76019337],\n",
       "       [0.93490772, 0.54227946, 0.51076185, 0.80784063, 0.72523742],\n",
       "       [0.50692926, 0.08742934, 0.64120215, 0.17624222, 0.86956274],\n",
       "       [0.76315917, 0.35952798, 0.58121045, 0.91715346, 0.09449829],\n",
       "       [0.0437028 , 0.07151266, 0.92069023, 0.8984425 , 0.73208314],\n",
       "       [0.43901714, 0.55206071, 0.07054807, 0.2126681 , 0.07618652],\n",
       "       [0.70016563, 0.70240438, 0.75154075, 0.1491439 , 0.66730866],\n",
       "       [0.97202415, 0.85226302, 0.38743678, 0.50585151, 0.79759033]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extract the first value of the 3rd dimension\n",
    "arr[:, :, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0.51218467, 0.92913747, 0.74809565],\n",
       "        [0.41124492, 0.77063842, 0.38333664],\n",
       "        [0.11435038, 0.278223  , 0.21797983],\n",
       "        [0.50778879, 0.04692032, 0.62099122],\n",
       "        [0.26205987, 0.68349235, 0.52008663]],\n",
       "\n",
       "       [[0.72523742, 0.8791117 , 0.60874428],\n",
       "        [0.80784063, 0.25522802, 0.42375193],\n",
       "        [0.51076185, 0.47426722, 0.3435387 ],\n",
       "        [0.54227946, 0.52854479, 0.17747127],\n",
       "        [0.93490772, 0.98928119, 0.86569364]],\n",
       "\n",
       "       [[0.73208314, 0.45883571, 0.02274345],\n",
       "        [0.8984425 , 0.71148439, 0.81824145],\n",
       "        [0.92069023, 0.67437001, 0.26335589],\n",
       "        [0.07151266, 0.82908446, 0.92543517],\n",
       "        [0.0437028 , 0.01884263, 0.24144511]],\n",
       "\n",
       "       [[0.79759033, 0.48708846, 0.12075606],\n",
       "        [0.50585151, 0.82849029, 0.99082662],\n",
       "        [0.38743678, 0.92663656, 0.54344937],\n",
       "        [0.85226302, 0.16395977, 0.85765419],\n",
       "        [0.97202415, 0.30979346, 0.12241736]]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reverse the 2nd dimension and extract every 3rd value of the 1st dimension\n",
    "arr[::3, ::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with dataframes (but unlike lists) indexing and slicing copies by reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 4, 6],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.array([\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6]\n",
    "])\n",
    "X1 = X[0]\n",
    "X1 *= 2\n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create copies, we use the `.copy()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.array([\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6]\n",
    "])\n",
    "X1 = X[0].copy()\n",
    "X1 *= 2\n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Further Reading**\n",
    ">\n",
    "> NumPy also allows indexing using arrays. This is an incredibly powerful tool for manipulating array elements but is beyond the scope of this course. You can read more about it [here](https://numpy.org/doc/stable/user/basics.indexing.html#index-arrays)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reshaping and Combining Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshaping Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can reshape an array using the `.reshape()` method, passing in the new desired shape as a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.43596861, 0.19979843, 0.84330255, 0.00131699, 0.52015289,\n",
       "       0.37420111, 0.83538979, 0.78845628, 0.95699432, 0.80906816,\n",
       "       0.12208534, 0.01470883, 0.16476184, 0.71825449, 0.19086781,\n",
       "       0.86909496, 0.90120742, 0.22387314, 0.4913762 , 0.41367329,\n",
       "       0.83469178, 0.82570056, 0.38615197, 0.43278643, 0.27999835])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Flatten a 5x5 random array\n",
    "arr = np.random.random(size=(5, 5))\n",
    "arr.reshape((25,))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are allowed to set one dimension to have the value `-1`, in which case this will be chosen so that the size of the new array matches the original."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0.37534867, 0.23804203],\n",
       "        [0.85008402, 0.30866614]],\n",
       "\n",
       "       [[0.87730419, 0.32440306],\n",
       "        [0.52518887, 0.79391798]],\n",
       "\n",
       "       [[0.10959728, 0.91571619],\n",
       "        [0.11208416, 0.20789279]],\n",
       "\n",
       "       [[0.38367427, 0.27462576],\n",
       "        [0.92792254, 0.57448497]],\n",
       "\n",
       "       [[0.42028405, 0.62043924],\n",
       "        [0.27173533, 0.33807869]]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Group a flat array into 2x2 blocks\n",
    "arr = np.random.random(size=(20,))\n",
    "arr.reshape((-1, 2, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use `reshape` to add new dummy dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1, 2],\n",
       "        [3, 4]]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Turn a 2x2 array into a 1x2x2 array\n",
    "np.array([[1, 2], [3, 4]]).reshape((1, 2, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combining Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy has many functions for combining (and splitting arrays). For the sake of time, we will only focus on a few, though you may want to checkout the following documentation for yourself:\n",
    "\n",
    "- [block](https://numpy.org/doc/stable/reference/generated/numpy.block.html)\n",
    "- [split](https://numpy.org/doc/stable/reference/generated/numpy.split.html)\n",
    "- [vstack](https://numpy.org/doc/stable/reference/generated/numpy.vstack.html), [hstack](https://numpy.org/doc/stable/reference/generated/numpy.hstack.html), [dstack](https://numpy.org/doc/stable/reference/generated/numpy.dstack.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the functions we will cover is `concatenate`, which joins a sequence of arrays along an existing axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6, 2)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Combine 3 three random 2x2 arrays into a 6x2 array\n",
    "X = np.random.random(size=(2, 2))\n",
    "Y = np.random.random(size=(2, 2))\n",
    "Z = np.random.random(size=(2, 2))\n",
    "C = np.concatenate((X, Y, Z), axis=0)\n",
    "C.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A similar function is `stack`, which also joins a sequence of arrays, creating a _new_ axis in the process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2, 2)"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Combine 3 three random 2x2 arrays into a 3x2x2 array\n",
    "D = np.stack((X, Y, Z), axis=0)\n",
    "D.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Maths with NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The main reason we want to use NumPy is for quick and elegant mathematical operations. These take advantage of a technique called _vectorisation_ in which operations are applied element-wise rather than to the entire array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy comes with a wide array (eh?) of built-in mathematical functions. Most are written in low-level, optimised C code so are lightning fast. A full list can be found [here](https://numpy.org/doc/stable/reference/routines.math.html). We can also use most base Python operators, which are then converted to the faster underlying functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create arrays to play with\n",
    "A = np.array([[1, 2], [3, 4]])\n",
    "B = np.array([[5, 6], [7, 8]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6,  8],\n",
       "       [10, 12]])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add A and B\n",
    "A + B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6,  8],\n",
       "       [10, 12]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add A and B using underlying function\n",
    "np.add(A, B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5, 12],\n",
       "       [21, 32]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiply corresponding elements of A and B\n",
    "A * B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Note**\n",
    "> \n",
    "> You can perform matrix multiplication using `np.matmul` or the `@` operator (e.g. `A @ B`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 0.69314718],\n",
       "       [1.09861229, 1.38629436]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Square root the elements in A\n",
    "np.log(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5. , 3. ],\n",
       "       [2.3, 2. ]])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Divide the elements of B by A and round to 1dp\n",
    "np.round(B / A, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This brings us back to a faster way of plotting functions with `matplotlib`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "x = np.linspace(0, 10, 100)\n",
    "y = np.log(x + 1)\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Further Reading**\n",
    ">\n",
    "> It is possible (and incredibly powerful) to perform element-wise operations on arrays with different shapes. This is known as broadcasting and is an advanced NumPy feature documented [here](https://numpy.org/doc/stable/user/basics.broadcasting.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can vectorise our own functions for use with NumPy using `np.vectorize`, though performance will almost certainly suffer in the process. Note, there is no way in Python to make this function correspond to a new operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6, -4],\n",
       "       [10, 32]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def random_op(x, y):\n",
    "    rnd = np.random.random()\n",
    "    if rnd < 0.4:\n",
    "        return x + y\n",
    "    elif rnd < 0.8:\n",
    "        return x - y\n",
    "    else:\n",
    "        return x * y\n",
    "    \n",
    "random_op = np.vectorize(random_op)\n",
    "random_op(A, B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aggregations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whereas the above operations returned arrays the same size as the original, aggregate operations will return either a single value or a smaller array. The most common of these functions are listed [here](https://www.pythonprogramming.in/numpy-aggregate-and-statistical-functions.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create data to play with\n",
    "np.random.seed(42)\n",
    "# 2 groups, 5 participants in each, 3 repeat measurements for each\n",
    "arr = np.random.standard_normal(size=(2, 5, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-5.644406875531123"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sum all elements in arr\n",
    "arr.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.33537946,  0.35157984,  0.62572439, -0.12886247, -1.1320786 ],\n",
       "       [-0.42029044, -0.284893  , -0.52766543, -0.52815124, -0.17221147]])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Average value for each participant over the 3 measurements\n",
    "arr.mean(axis=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.57921282, 1.46564877])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Maximum value in each group\n",
    "arr.max(axis=(1, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A particularly interesting pair of aggregate functions is `argmin`/`argmax`. Rather than finding the smallest/largest element, they tell you where it is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 5])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Which participant of each group had the lowest variance?\n",
    "arr.var(axis=2).argmin(axis=1) + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Useful Tip**\n",
    ">\n",
    "> You can also reference axes using negative indices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accumulations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A related family of functions is accumulations. These apply a function over an axis, returning the result at each step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  3,  6],\n",
       "       [ 4,  9, 15]])"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Cummulative sum of arr\n",
    "arr = np.array([\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6]\n",
    "])\n",
    "np.cumsum(arr, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find a full list of these functions by searching for the prefix \"cum\" on the NumPy [function list](https://numpy.org/doc/stable/reference/routines.math.html?highlight=sum)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Further Reading**\n",
    ">\n",
    "> You are also free to create your own aggregations (specifically, [reductions](https://numpy.org/doc/stable/reference/generated/numpy.ufunc.reduce.html)) and [accumulations](https://numpy.org/doc/stable/reference/generated/numpy.ufunc.accumulate.html) using the documentation linked here, though do note that these are both quite advanced features of the package."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filtering and Sorting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we will look at how we can filter and sort arrays. We begin with filtering."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filtering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use comparison operators with NumPy arrays to create Boolean arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True, False, False,  True,  True,  True, False,  True,\n",
       "       False])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Which rows of A have a sum greater than one? Call the result B\n",
    "np.random.seed(253)\n",
    "A = np.random.standard_normal(size=(10, 10))\n",
    "B = np.sum(A, axis=1) > 0\n",
    "B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then use Boolean arrays to filter along an axis of an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.87157287, -1.13019516,  1.28219361,  3.30666723,  0.13063963,\n",
       "        -0.48921038, -0.34078095, -0.59258644, -0.43519562, -1.38283849],\n",
       "       [-0.57561558,  1.33532656,  0.78052562,  0.02216178,  0.65019844,\n",
       "        -0.8047665 , -0.79871126,  1.63540629,  2.17077612,  0.41283895],\n",
       "       [ 1.6907554 ,  2.50428286,  0.04413411, -1.32268295, -2.11490647,\n",
       "        -0.34783311, -0.60986001,  0.76699829,  1.63314801, -0.55285836],\n",
       "       [ 0.2685946 ,  0.93639279,  1.67594885,  0.04691898, -0.55740769,\n",
       "         0.25901479,  0.41432577,  0.49404523,  0.25059384,  0.07515829],\n",
       "       [-0.27629149, -0.30184233,  0.56891406,  0.17248246,  0.34852905,\n",
       "         0.8985324 ,  1.55793039,  0.27827483,  0.09287503, -0.18031924],\n",
       "       [ 0.40794901, -0.15202927,  0.23409006,  0.56477258,  0.4739841 ,\n",
       "        -0.28150999,  0.86380105,  0.57403094, -0.30289846,  1.70773309]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Select only rows with a sum greater than one\n",
    "A[B]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Review**\n",
    ">\n",
    "> Now that you are aware of Boolean arrays, you may want to review the aggregation functions `np.all` and `np.any`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also pass in a NumPy array of indexes (which could have been obtained from `argmin`, `argsort` (see later), or `argwhere` (read docs))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.66152006, -1.2110162 ],\n",
       "       [-1.12970685,  1.44156862],\n",
       "       [-0.15567724,  0.25442084],\n",
       "       [ 2.0754008 , -0.32602353],\n",
       "       [ 1.67643731, -0.21910053],\n",
       "       [-0.41528791,  2.27069286],\n",
       "       [-0.47765745,  0.33366211],\n",
       "       [-0.92216532,  1.35563786],\n",
       "       [-0.05558467, -1.12548905],\n",
       "       [ 0.47146836,  1.34542005]])"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Select 2nd and 4th columns using an array of indexes\n",
    "A[:, np.array([1, 3])]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point you are likely wondering what happens when we run code such as `A[np.array([1, 2], [4, 2])]` or `A[A > 0]`. The answer all comes down to broadcasting, which we will not cover here, but can be read about at [this link](https://numpy.org/doc/stable/user/basics.broadcasting.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sorting Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two ways to sort arrays in NumPy. The first is `arr.sort(...)` which sorts **in-place**, and the second is `np.sort(arr, ...`) which returns a sorted **copy** of the original. We will use the former but the same logic applies to the latter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The only argument we need to specify in most use cases is `axis` which determines the axis to sort over. It is generally difficult to handle ties although you will find ways if you search online."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0.65892394 0.71597223]\n",
      "  [0.02709599 0.22197216]]\n",
      "\n",
      " [[0.2310748  0.67189274]\n",
      "  [0.01971054 0.10410858]]]\n"
     ]
    }
   ],
   "source": [
    "# Sort A over the last dimension\n",
    "A = np.random.random(size=(2, 2, 2))\n",
    "A.sort(axis=-1)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using `np.sort()`, by setting `axis=None` we sort the flattened array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.01971054, 0.02709599, 0.10410858, 0.22197216, 0.2310748 ,\n",
       "       0.65892394, 0.67189274, 0.71597223])"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sort the flattened array of A\n",
    "np.sort(A, axis=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can use `np.argsort()` to return the indices that would result in a sorted array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 5, 0, 4, 3, 8, 9, 6, 7, 1])"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Argsort A, creating B\n",
    "np.random.seed(42)\n",
    "A = np.random.randint(100, size=(10,))\n",
    "B = A.argsort()\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.all(np.sort(A) == A[B])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wrapping Up"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving NumPy arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to save NumPy arrays to disk for later use. This isn't too common a requirement so we won't cover it in this session, but you can read more about it [here](https://numpy.org/doc/stable/reference/generated/numpy.save.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sparsity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The sparsity of an array is given by the proportion of zero elements out of all elements. When an array is highly sparse (typically >70-90% depending on the scenario), it can be stored in a different way to make operations faster and use less storage. NumPy only has the ability to work with _dense_ arrays, but thankfully, SciPy has us covered. The feature set of sparse arrays is more limited but when these meet you needs, they can often offer much faster computations with less storage requirements. Read more [here](https://docs.scipy.org/doc/scipy/reference/sparse.html)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python for Data Science",
   "language": "python",
   "name": "pyds"
  },
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}