notebooks_v2/02.04-Computation-on-arrays-aggregates.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--BOOK_INFORMATION-->\n",
    "<img align=\"left\" style=\"padding-right:10px;\" src=\"figures/PDSH-cover-small.png\">\n",
    "\n",
    "*This notebook contains an excerpt from the [Python Data Science Handbook](http://shop.oreilly.com/product/0636920034919.do) by Jake VanderPlas; the content is available [on GitHub](https://github.com/jakevdp/PythonDataScienceHandbook).*\n",
    "\n",
    "*The text is released under the [CC-BY-NC-ND license](https://creativecommons.org/licenses/by-nc-nd/3.0/us/legalcode), and code is released under the [MIT license](https://opensource.org/licenses/MIT). If you find this content useful, please consider supporting the work by [buying the book](http://shop.oreilly.com/product/0636920034919.do)!*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [Computation on NumPy Arrays: Universal Functions](02.03-Computation-on-arrays-ufuncs.ipynb) | [Contents](Index.ipynb) | [Computation on Arrays: Broadcasting](02.05-Computation-on-arrays-broadcasting.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/02.04-Computation-on-arrays-aggregates.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aggregations: Min, Max, and Everything In Between"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A first step in exploring any dataset is often to compute various summary statistics.\n",
    "Perhaps the most common summary statistics are the mean and standard deviation, which allow you to summarize the \"typical\" values in a dataset, but other aggregations are useful as well (the sum, product, median, minimum and maximum, quantiles, etc.).\n",
    "\n",
    "NumPy has fast built-in aggregation functions for working on arrays; we'll discuss and demonstrate some of them here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summing the Values in an Array\n",
    "\n",
    "As a quick example, consider computing the sum of all values in an array.\n",
    "Python itself can do this using the built-in ``sum`` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "rng = np.random.default_rng()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52.76825337322368"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = rng.random(100)\n",
    "sum(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The syntax is quite similar to that of NumPy's ``sum`` function, and the result is the same in the simplest case:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52.76825337322366"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, because it executes the operation in compiled code, NumPy's version of the operation is computed much more quickly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "89.9 ms ± 233 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "521 µs ± 8.37 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "big_array = rng.random(1000000)\n",
    "%timeit sum(big_array)\n",
    "%timeit np.sum(big_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Be careful, though: the ``sum`` function and the ``np.sum`` function are not identical, which can sometimes lead to confusion!\n",
    "In particular, their optional arguments have different meanings, and ``np.sum`` is aware of multiple array dimensions, as we will see in the following section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Minimum and Maximum\n",
    "\n",
    "Similarly, Python has built-in ``min`` and ``max`` functions, used to find the minimum value and maximum value of any given array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.0114398036064074e-07, 0.9999997912802653)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(big_array), max(big_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy's corresponding functions have similar syntax, and again operate much more quickly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.0114398036064074e-07, 0.9999997912802653)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.min(big_array), np.max(big_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "72 ms ± 177 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "564 µs ± 3.11 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit min(big_array)\n",
    "%timeit np.min(big_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For ``min``, ``max``, ``sum``, and several other NumPy aggregates, a shorter syntax is to use methods of the array object itself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0114398036064074e-07 0.9999997912802653 499854.0273321711\n"
     ]
    }
   ],
   "source": [
    "print(big_array.min(), big_array.max(), big_array.sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whenever possible, make sure that you are using the NumPy version of these aggregates when operating on NumPy arrays!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multi dimensional aggregates\n",
    "\n",
    "One common type of aggregation operation is an aggregate along a row or column.\n",
    "Say you have some data stored in a two-dimensional array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 3 1 2]\n",
      " [1 9 7 0]\n",
      " [4 8 3 7]]\n"
     ]
    }
   ],
   "source": [
    "M = rng.integers(0, 10, (3, 4))\n",
    "print(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy aggregations will apply across all elements of a multi-dimensional array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aggregation functions take an additional argument specifying the *axis* along which the aggregate is computed. For example, we can find the minimum value within each column by specifying ``axis=0``:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 3, 1, 0])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.min(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function returns four values, corresponding to the four columns of numbers.\n",
    "\n",
    "Similarly, we can find the maximum value within each row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 9, 8])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.max(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The way the axis is specified here can be confusing to users coming from other languages.\n",
    "The ``axis`` keyword specifies the *dimension of the array that will be collapsed*, rather than the dimension that will be returned.\n",
    "So specifying ``axis=0`` means that the first axis will be collapsed: for two-dimensional arrays, values within each column will be aggregated."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other aggregation functions\n",
    "\n",
    "NumPy provides several other aggregation functions with a similar API, and additionally most have a ``NaN``-safe counterpart that computes the result while ignoring missing values, which are marked by the special IEEE floating-point ``NaN`` value (see [Handling Missing Data](03.04-Missing-Values.ipynb)).\n",
    "\n",
    "The following table provides a list of useful aggregation functions available in NumPy:\n",
    "\n",
    "|Function Name      |   NaN-safe Version  | Description                                   |\n",
    "|-------------------|---------------------|-----------------------------------------------|\n",
    "| ``np.sum``        | ``np.nansum``       | Compute sum of elements                       |\n",
    "| ``np.prod``       | ``np.nanprod``      | Compute product of elements                   |\n",
    "| ``np.mean``       | ``np.nanmean``      | Compute mean of elements                      |\n",
    "| ``np.std``        | ``np.nanstd``       | Compute standard deviation                    |\n",
    "| ``np.var``        | ``np.nanvar``       | Compute variance                              |\n",
    "| ``np.min``        | ``np.nanmin``       | Find minimum value                            |\n",
    "| ``np.max``        | ``np.nanmax``       | Find maximum value                            |\n",
    "| ``np.argmin``     | ``np.nanargmin``    | Find index of minimum value                   |\n",
    "| ``np.argmax``     | ``np.nanargmax``    | Find index of maximum value                   |\n",
    "| ``np.median``     | ``np.nanmedian``    | Compute median of elements                    |\n",
    "| ``np.percentile`` | ``np.nanpercentile``| Compute rank-based statistics of elements     |\n",
    "| ``np.any``        | N/A                 | Evaluate whether any elements are true        |\n",
    "| ``np.all``        | N/A                 | Evaluate whether all elements are true        |\n",
    "\n",
    "We will see these aggregates often throughout the rest of the book."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: What is the Average Height of US Presidents?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aggregates available in NumPy can act as summary statistics for a set of values.\n",
    "As a simple example, let's consider the heights of all US presidents.\n",
    "This data is available in the file *president_heights.csv*, which is a simple comma-separated list of labels and values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "order,name,height(cm)\n",
      "1,George Washington,189\n",
      "2,John Adams,170\n",
      "3,Thomas Jefferson,189\n"
     ]
    }
   ],
   "source": [
    "!head -4 data/president_heights.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll use the Pandas package, which we'll explore more fully in [Chapter 3](03.00-Introduction-to-Pandas.ipynb), to read the file and extract this information (note that the heights are measured in centimeters)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[189 170 189 163 183 171 185 168 173 183 173 173 175 178 183 193 178 173\n",
      " 174 183 183 168 170 178 182 180 183 178 182 188 175 179 183 193 182 183\n",
      " 177 185 188 188 182 185 191 182]\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "data = pd.read_csv('data/president_heights.csv')\n",
    "heights = np.array(data['height(cm)'])\n",
    "print(heights)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have this data array, we can compute a variety of summary statistics:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean height:        180.04545454545453\n",
      "Standard deviation: 6.983599441335736\n",
      "Minimum height:     163\n",
      "Maximum height:     193\n"
     ]
    }
   ],
   "source": [
    "print(\"Mean height:       \", heights.mean())\n",
    "print(\"Standard deviation:\", heights.std())\n",
    "print(\"Minimum height:    \", heights.min())\n",
    "print(\"Maximum height:    \", heights.max())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that in each case, the aggregation operation reduced the entire array to a single summarizing value, which gives us information about the distribution of values.\n",
    "We may also wish to compute quantiles:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25th percentile:    174.75\n",
      "Median:             182.0\n",
      "75th percentile:    183.5\n"
     ]
    }
   ],
   "source": [
    "print(\"25th percentile:   \", np.percentile(heights, 25))\n",
    "print(\"Median:            \", np.median(heights))\n",
    "print(\"75th percentile:   \", np.percentile(heights, 75))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the median height of US presidents is 182 cm, or just shy of six feet.\n",
    "\n",
    "Of course, sometimes it's more useful to see a visual representation of this data, which we can accomplish using tools in Matplotlib (we'll discuss Matplotlib more fully in [Chapter 4](04.00-Introduction-To-Matplotlib.ipynb)). For example, this code generates the following chart:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('seaborn-whitegrid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(heights)\n",
    "plt.title('Height Distribution of US Presidents')\n",
    "plt.xlabel('height (cm)')\n",
    "plt.ylabel('number');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [Computation on NumPy Arrays: Universal Functions](02.03-Computation-on-arrays-ufuncs.ipynb) | [Contents](Index.ipynb) | [Computation on Arrays: Broadcasting](02.05-Computation-on-arrays-broadcasting.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/02.04-Computation-on-arrays-aggregates.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "jupytext": {
   "formats": "ipynb,md"
  },
  "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}