Introduction to NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Numpy\n",
    "This is a NumPy cheat sheet that is created in the Treehouse course [Introduction to NumPy](https://teamtreehouse.com/library/introduction-to-numpy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.14.5'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "np.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Differences between lists and NumPy Arrays\n",
    "* An array's size is immutable.  You cannot append, insert or remove elements, like you can with a list.\n",
    "* All of an array's elements must be of the same [data type](https://docs.scipy.org/doc/numpy-1.14.0/user/basics.types.html).\n",
    "* A NumPy array behaves in a Pythonic fashion.  You can `len(my_array)` just like you would assume."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "gpas_as_list = [4.0, 3.286, 3.5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Whatevs'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can have elements appended to it\n",
    "gpas_as_list.append(4.0)\n",
    "# Can have multiple datatypes in it.\n",
    "gpas_as_list.insert(1, \"Whatevs\")\n",
    "# Can have items removed\n",
    "gpas_as_list.pop(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4.0, 3.286, 3.5, 4.0]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gpas_as_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "gpas = np.array(gpas_as_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gpas.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gpas.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gpas.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(gpas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gpas.nbytes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multidimensional Arrays\n",
    "* The data structure is actually called `ndarray`, representing any **n**umber of **d**imensions\n",
    "* Arrays can have multiple dimensions, you declare them on creation\n",
    "* Dimensions help define what each element in the array represents.  A two dimensional array is just an array of arrays\n",
    "* **Rank** defines how many dimensions an array contains \n",
    "* **Shape** defines the length of each of the array's dimensions\n",
    "* Each dimension is also referred to as an **axis**, and they are zero-indexed. Multiples are called **axes**.\n",
    "* A 2d array is AKA **matrix**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.   , 3.285, 3.5  , 4.   ],\n",
       "       [3.2  , 3.8  , 4.   , 4.   ],\n",
       "       [3.96 , 3.92 , 4.   , 4.   ]], dtype=float16)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students_gpas = np.array([\n",
    "    [4.0, 3.286, 3.5, 4.0],\n",
    "    [3.2, 3.8, 4.0, 4.0],\n",
    "    [3.96, 3.92, 4.0, 4.0]\n",
    "], np.float16)\n",
    "students_gpas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students_gpas.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students_gpas.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students_gpas.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(students_gpas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students_gpas.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students_gpas.itemsize * students_gpas.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable        Type       Data/Info\n",
      "------------------------------------\n",
      "gpas            ndarray    4: 4 elems, type `float64`, 32 bytes\n",
      "students_gpas   ndarray    3x4: 12 elems, type `float16`, 24 bytes\n"
     ]
    }
   ],
   "source": [
    "%whos ndarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "class:  ndarray\n",
      "shape:  (3, 4)\n",
      "strides:  (8, 2)\n",
      "itemsize:  2\n",
      "aligned:  True\n",
      "contiguous:  True\n",
      "fortran:  False\n",
      "data pointer: 0x7ff3ceb56fc0\n",
      "byteorder:  little\n",
      "byteswap:  False\n",
      "type: float16\n"
     ]
    }
   ],
   "source": [
    "np.info(students_gpas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.96, 3.92, 4.  , 4.  ], dtype=float16)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students_gpas[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students_gpas[2][3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.   , 3.285, 3.5  , 4.   ],\n",
       "       [3.2  , 3.8  , 4.   , 4.   ],\n",
       "       [3.96 , 3.92 , 4.   , 4.   ]], dtype=float16)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students_gpas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common Routines\n",
    "* Common [mathematical](https://docs.scipy.org/doc/numpy-1.14.0/reference/routines.math.html) [routines](https://docs.scipy.org/doc/numpy-1.14.0/reference/routines.html) are exposed so the formula can be abstracted away.\n",
    "    * [`mean`](https://docs.scipy.org/doc/numpy-1.14.0/reference/generated/numpy.mean.html#numpy.mean) is a [statistics](https://docs.scipy.org/doc/numpy-1.14.0/reference/routines.statistics.html) routine used to calculate the average.\n",
    "* Reduction functions take a dimension and collapse it into a single value.\n",
    "    * These functions define an axis parameter, and you should remember that the function works across the dimension.\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.805"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students_gpas.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.695, 3.75 , 3.97 ], dtype=float16)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students_gpas.mean(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.boxplot(students_gpas.T)\n",
    "plt.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## About data types\n",
    "* By choosing the proper [data type](https://docs.scipy.org/doc/numpy-1.14.0/user/basics.types.html) you can greatly reduce the size required to store objects\n",
    "* Data types are maintained by wrapping values in a [scalar representation](https://docs.scipy.org/doc/numpy-1.14.0/reference/arrays.scalars.html)\n",
    "* `np.zeros` is a handy way to create an empty array filled with zeros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=uint16)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "study_minutes = np.zeros(100, np.uint16)\n",
    "study_minutes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable        Type       Data/Info\n",
      "------------------------------------\n",
      "gpas            ndarray    4: 4 elems, type `float64`, 32 bytes\n",
      "gpas_as_list    list       n=4\n",
      "np              module     <module 'numpy' from '/Us<...>kages/numpy/__init__.py'>\n",
      "plt             module     <module 'matplotlib.pyplo<...>es/matplotlib/pyplot.py'>\n",
      "students_gpas   ndarray    3x4: 12 elems, type `float16`, 24 bytes\n",
      "study_minutes   ndarray    100: 100 elems, type `uint16`, 200 bytes\n"
     ]
    }
   ],
   "source": [
    "%whos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1440"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "60 * 24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "study_minutes[0] = 150"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_day_minutes = study_minutes[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "150"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_day_minutes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.uint16"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(first_day_minutes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Add 60 minutes to the second day in the study_minutes array\n",
    "study_minutes[1] = 60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "study_minutes[2:6] = [80, 60, 30, 90]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creation \n",
    "* You can create a random but bound grouping of values using the `np.random` package.  \n",
    "  * `RandomState` let's you seed your randomness in a way that is repeatable.\n",
    "* You can append a row in a couple of ways\n",
    "   * You can use the `np.append` method.  Make sure the new row is the same shape.\n",
    "   * You can create/reassign a new array by including the existing array as part of the iterable in creation.\n",
    "\n",
    "\n",
    "## Indexing\n",
    "* You can use an indexing shortcut by separating dimensions with a comma.  \n",
    "* You can index using a `list` or `np.array`.  Values will be pulled out at that specific index.  This is known as fancy indexing.\n",
    "  * Resulting array shape matches the index array layout.  Be careful to distinguish between the tuple shortcut and fancy indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "study_minutes = np.array([\n",
    "    study_minutes,\n",
    "    np.zeros(100, np.uint16)\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 100)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "study_minutes.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set round 2 day 1 to 60\n",
    "study_minutes[1][0] = 60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "study_minutes[1, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 0)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1, 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([132, 122, 128,  44, 136, 129, 101,  95,  50, 132, 151,  64, 104,\n",
       "       175, 117, 146, 139, 129, 133, 176,  98, 160, 179,  99,  82, 142,\n",
       "        31, 106, 117,  56,  98,  67, 121, 159,  81, 170,  31,  50,  49,\n",
       "        87, 179,  51, 116, 177, 118,  78, 171, 117,  88, 123, 102,  44,\n",
       "        79,  31, 108,  80,  59, 137,  84,  93, 155, 160,  67,  80, 166,\n",
       "       164,  70,  50, 102, 113,  47, 131, 161, 118,  82,  89,  81,  43,\n",
       "        81,  38, 119,  52,  82,  31, 159,  57, 113,  71, 121, 140,  91,\n",
       "        70,  37, 106,  64, 127, 110,  58,  93,  79], dtype=uint16)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rand = np.random.RandomState(42)\n",
    "fake_log = rand.randint(30, 180, size=100, dtype=np.uint16)\n",
    "fake_log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[44, 50]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[fake_log[3], fake_log[8]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([44, 50], dtype=uint16)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fake_log[[3, 8]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 44,  50],\n",
       "       [132, 122]], dtype=uint16)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = np.array([\n",
    "    [3, 8],\n",
    "    [0, 1]\n",
    "])\n",
    "fake_log[index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "study_minutes = np.append(study_minutes, [fake_log], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "study_minutes[1, 1] = 360"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boolean Array Indexing\n",
    "* You can create a boolean array by using comparison operators on an array.\n",
    "  * You can use boolean arrays for fancy indexing.\n",
    "  * Boolean arrays can be compared by using bitwise operators (`&`, `|`)\n",
    "      * Do not use the `and` keyword.\n",
    "      * Remember to mind the order of operations when combining\n",
    "* Even though boolean indexing returns a new array, you can update an existing array using a boolean index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([44, 50, 31, 56, 31, 50, 49, 51, 44, 31, 59, 50, 47, 43, 38, 52, 31,\n",
       "       57, 37, 58], dtype=uint16)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fake_log[fake_log < 60]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([44, 50, 31, 56, 31, 50, 49, 51, 44, 31, 59, 50, 47, 43, 38, 52, 31,\n",
       "       57, 37, 58], dtype=uint16)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = []\n",
    "for value in fake_log:\n",
    "    if value < 60:\n",
    "        results.append(value)\n",
    "np.array(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n",
       "        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n",
       "        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n",
       "        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n",
       "        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n",
       "        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n",
       "        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n",
       "        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n",
       "        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n",
       "        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n",
       "        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,\n",
       "        0,  0,  0,  0,  0,  0, 44, 50, 31, 56, 31, 50, 49, 51, 44, 31, 59,\n",
       "       50, 47, 43, 38, 52, 31, 57, 37, 58], dtype=uint16)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "study_minutes[study_minutes < 60]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([False, True, True]) & np.array([True, False, True])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30, 44, 50, 31, 56, 31, 50, 49, 51, 44, 31, 59, 50, 47, 43, 38, 52,\n",
       "       31, 57, 37, 58], dtype=uint16)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "study_minutes[(study_minutes < 60) & (study_minutes > 0)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "study_minutes[study_minutes < 60] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([132, 122, 128,   0, 136, 129, 101,  95,   0, 132, 151,  64, 104,\n",
       "       175, 117, 146, 139, 129, 133, 176,  98, 160, 179,  99,  82, 142,\n",
       "         0, 106, 117,   0,  98,  67, 121, 159,  81, 170,   0,   0,   0,\n",
       "        87, 179,   0, 116, 177, 118,  78, 171, 117,  88, 123, 102,   0,\n",
       "        79,   0, 108,  80,   0, 137,  84,  93, 155, 160,  67,  80, 166,\n",
       "       164,  70,   0, 102, 113,   0, 131, 161, 118,  82,  89,  81,   0,\n",
       "        81,   0, 119,   0,  82,   0, 159,   0, 113,  71, 121, 140,  91,\n",
       "        70,   0, 106,  64, 127, 110,   0,  93,  79], dtype=uint16)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "study_minutes[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Universal Functions - Reduce / Accumulate\n",
    "* Universal Functions expose a function to [`reduce`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ufunc.reduce.html) an array to a single value.\n",
    "* There is also a function named [`accumulate`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ufunc.accumulate.html) which will show the reduction and it's accumulation as it happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "440"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add.reduce(study_minutes[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([150, 210, 290, 350, 350, 440, 440, 440, 440, 440, 440, 440, 440,\n",
       "       440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440,\n",
       "       440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440,\n",
       "       440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440,\n",
       "       440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440,\n",
       "       440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440,\n",
       "       440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440, 440,\n",
       "       440, 440, 440, 440, 440, 440, 440, 440, 440], dtype=uint64)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add.accumulate(study_minutes[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "440"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(study_minutes[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 440,  420, 9290], dtype=uint64)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(study_minutes, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Pass in a one dimensional array of all the minutes that are \n",
    "#  greater than zero\n",
    "plt.hist(study_minutes[study_minutes > 0])\n",
    "plt.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing\n",
    "* Works a lot like normal list slicing.\n",
    "* You can use commas to separate each dimension slice.\n",
    "* Always returns a data view **not a copy**\n",
    "* You can access the base object using the `ndarray.base` property"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit = [\"apple\", \"banana\", \"cherry\", \"durian\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['banana', 'cherry']"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruit[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'banana', 'cherry']"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruit[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['durian']"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruit[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'banana', 'cherry', 'durian']"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruit[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "copied = fruit[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['apple', 'banana', 'cherry', 'durian'],\n",
       " ['apple', 'banana', 'cherry', 'cheese'])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "copied[3] = 'cheese'\n",
    "# Slicing a list returns a copy\n",
    "fruit, copied"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'cherry']"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruit[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['durian', 'cherry', 'banana', 'apple']"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruit[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10, 11],\n",
       "       [12, 13, 14, 15, 16, 17],\n",
       "       [18, 19, 20, 21, 22, 23],\n",
       "       [24, 25, 26, 27, 28, 29],\n",
       "       [30, 31, 32, 33, 34, 35],\n",
       "       [36, 37, 38, 39, 40, 41]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "practice = np.arange(42)\n",
    "practice.shape = (7, 6)\n",
    "practice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[15, 17],\n",
       "       [21, 23],\n",
       "       [27, 29]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "practice[2:5, 3::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[90210,     1,     2,     3,     4,     5],\n",
       "        [    6,     7,     8,     9,    10,    11],\n",
       "        [   12,    13,    14,    15,    16,    17],\n",
       "        [   18,    19,    20,    21,    22,    23],\n",
       "        [   24,    25,    26,    27,    28,    29],\n",
       "        [   30,    31,    32,    33,    34,    35],\n",
       "        [   36,    37,    38,    39,    40,    41]]),\n",
       " array([[90210,     1,     2,     3,     4,     5],\n",
       "        [    6,     7,     8,     9,    10,    11],\n",
       "        [   12,    13,    14,    15,    16,    17],\n",
       "        [   18,    19,    20,    21,    22,    23],\n",
       "        [   24,    25,    26,    27,    28,    29],\n",
       "        [   30,    31,    32,    33,    34,    35],\n",
       "        [   36,    37,    38,    39,    40,    41]]))"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Any slicing of ndarray returns a view and not a copy!\n",
    "not_copied = practice[:]\n",
    "not_copied[0, 0] = 90210\n",
    "practice, not_copied"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "practice.base is None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not_copied.base is None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not_copied.base is practice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "practice.flags['OWNDATA'], not_copied.flags['OWNDATA']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array Manipulation\n",
    "* The documentation on [Array Manipulation](https://docs.scipy.org/doc/numpy/reference/routines.array-manipulation.html) is a good one to keep bookmarked.\n",
    "* `ndarray.reshape` creates a view with a new shape\n",
    "  * You can use `-1` as a value to infer the missing dimension\n",
    "* `ndarray.ravel` returns a single dimensional view of the array.\n",
    "* `ndarray.flatten` can be used to make a single dimensional copy.\n",
    "* `np.lookfor` is great for searching docstrings from within a notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[90210,     1,     2,     3,     4,     5],\n",
       "        [    6,     7,     8,     9,    10,    11],\n",
       "        [   12,    13,    14,    15,    16,    17],\n",
       "        [   18,    19,    20,    21,    22,    23],\n",
       "        [   24,    25,    26,    27,    28,    29],\n",
       "        [   30,    31,    32,    33,    34,    35],\n",
       "        [   36,    37,    38,    39,    40,    41]]),\n",
       " array([[90210,     1,     2,     3,     4,     5,     6,     7,     8,\n",
       "             9,    10,    11,    12,    13],\n",
       "        [   14,    15,    16,    17,    18,    19,    20,    21,    22,\n",
       "            23,    24,    25,    26,    27],\n",
       "        [   28,    29,    30,    31,    32,    33,    34,    35,    36,\n",
       "            37,    38,    39,    40,    41]]),\n",
       " True)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "practice_view = practice.reshape(3, 14)\n",
    "practice, practice_view, practice_view.base is practice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(21, 2)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "practice.reshape(-1, 2).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([90210,     1,     2,     3,     4,     5,     6,     7,     8,\n",
       "           9,    10,    11,    12,    13,    14,    15,    16,    17,\n",
       "          18,    19,    20,    21,    22,    23,    24,    25,    26,\n",
       "          27,    28,    29,    30,    31,    32,    33,    34,    35,\n",
       "          36,    37,    38,    39,    40,    41])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "practice.ravel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Algebra\n",
    "* There is a module for linear algebra, [linalg](https://docs.scipy.org/doc/numpy/reference/routines.linalg.html)\n",
    "* You can solve for a system of equations using the [solve function](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.solve.html#numpy.linalg.solve)\n",
    "    * You can create a square 2 dimensional matrix and a constant row vector and solve for each variable column\n",
    "    * You can double check the answer using the inner product or [dot](https://docs.scipy.org/doc/numpy/reference/generated/numpy.dot.html#numpy.dot).\n",
    "* You can use the `@` to produce the dot product of two arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.5 , 8.  , 1.25, 2.  ])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "orders = np.array([\n",
    "    [2, 0, 0, 0],\n",
    "    [4, 1, 2, 2],\n",
    "    [0, 1, 0, 1],\n",
    "    [6, 0, 1, 2]\n",
    "])\n",
    "totals = np.array([3, 20.50, 10, 14.25])\n",
    "prices = np.linalg.solve(orders, totals)\n",
    "prices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3.  , 20.5 , 10.  , 14.25])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A • B\n",
    "orders @ prices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3.  , 20.5 , 10.  , 14.25])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "orders.dot(prices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Universal Functions\n",
    "* [ufuncs](https://docs.scipy.org/doc/numpy/reference/ufuncs.html) are commonly needed vectorized functions\n",
    "  * Vectorized functions allow you to operate element by element without using a loop\n",
    "* The standard math and comparison operations have all been overloaded so that they can make use of vectorization\n",
    "* Values can be [broadcasted](https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html), or stretched to be applied to the ufuncs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1, 2, 3, 4, 5]), array([ 6,  7,  8,  9, 10]))"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, b = np.split(np.arange(1, 11), 2)\n",
    "a, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 7,  9, 11, 13, 15])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-5, -5, -5, -5, -5])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a - b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 5, 5, 5, 5])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b - a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6, 14, 24, 36, 50])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5, 6, 7])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5, 6, 7])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + np.repeat(2, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0., 1., 2.],\n",
       "        [3., 4., 5.],\n",
       "        [6., 7., 8.]]), array([0., 1., 2.]))"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> x1 = np.arange(9.0).reshape((3, 3))\n",
    ">>> x2 = np.arange(3.0)\n",
    "x1, x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  2.,  4.],\n",
       "       [ 3.,  5.,  7.],\n",
       "       [ 6.,  8., 10.]])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> np.add(x1, x2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2.,  3.,  4.],\n",
       "       [ 5.,  6.,  7.],\n",
       "       [ 8.,  9., 10.]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add(x1, 2)"
   ]
  }
 ],
 "metadata": {
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}