ansible/files/materials/2-Creating and Reshaping Arrays (Solutions).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating and Reshaping Arrays\n",
    "\n",
    "The exercises in this notebook will teach you to use a variety of common functions for creating and reshaping arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `np.array`\n",
    "\n",
    "The most common way to create an array is to construct one from a python list.\n",
    "\n",
    "**Example:** Passing a list of scalars produces a 1-dimensional array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example:** Passing a list of lists produces a 2-dimensional array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [2, 3]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([[1, 2], \n",
    "          [2, 3]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Create a 1-dimensional array using `np.array` containing `[1, 2, 3, 4]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Create a 2-dimensional array using `np.array` with two rows containing  `[1, 2, 3]` and `[4, 5, 6]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([[1, 2, 3], [4, 5, 6]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `np.arange`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Construct an array containing values from 0 to 9, inclusive, in ascending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Construct an array containing all the integers between 1 and 3 inclusive, in ascending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Construct an array containing all the integers between 5 and 10 inclusive, in ascending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(5, 11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Construct an array containing all the integers between 1 and 10 inclusive, in descending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10,  9,  8,  7,  6,  5,  4,  3,  2,  1])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(10, 0, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Construct an array containing all the **even** integers between 2 and 10 inclusive, in ascending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(2, 11, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `linspace`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Construct an array containing 50 evenly-spaced values between -1 and 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.        , -0.95918367, -0.91836735, -0.87755102, -0.83673469,\n",
       "       -0.79591837, -0.75510204, -0.71428571, -0.67346939, -0.63265306,\n",
       "       -0.59183673, -0.55102041, -0.51020408, -0.46938776, -0.42857143,\n",
       "       -0.3877551 , -0.34693878, -0.30612245, -0.26530612, -0.2244898 ,\n",
       "       -0.18367347, -0.14285714, -0.10204082, -0.06122449, -0.02040816,\n",
       "        0.02040816,  0.06122449,  0.10204082,  0.14285714,  0.18367347,\n",
       "        0.2244898 ,  0.26530612,  0.30612245,  0.34693878,  0.3877551 ,\n",
       "        0.42857143,  0.46938776,  0.51020408,  0.55102041,  0.59183673,\n",
       "        0.63265306,  0.67346939,  0.71428571,  0.75510204,  0.79591837,\n",
       "        0.83673469,  0.87755102,  0.91836735,  0.95918367,  1.        ])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(-1, 1, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: `zeros`, `ones`, and `full`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Construct arrays with the following shapes and values:\n",
    "- 1-dimensional array with 10 entries, all containing the value 0.\n",
    "- 2-dimensional array with 3 rows and 5 columns, all containing the value 1.\n",
    "- 2-dimensional array with 5 rows and 3 columns, all containing the value 2.\n",
    "- 3-dimensional array of shape (2, 5, 10), all containing the value 0.\n",
    "- 5-dimensional array of shape (1, 2, 3, 4, 5), all containing the value 42."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 2, 2],\n",
       "       [2, 2, 2],\n",
       "       [2, 2, 2],\n",
       "       [2, 2, 2],\n",
       "       [2, 2, 2]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full((5, 3), 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((2, 5, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[[[42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42]],\n",
       "\n",
       "         [[42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42]],\n",
       "\n",
       "         [[42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42]]],\n",
       "\n",
       "\n",
       "        [[[42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42]],\n",
       "\n",
       "         [[42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42]],\n",
       "\n",
       "         [[42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42],\n",
       "          [42, 42, 42, 42, 42]]]]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full((1, 2, 3, 4, 5), 42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `identity`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Construct a 5 x 5 array with 1s along the diagonal and zeros everywhere else."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0., 0.],\n",
       "       [0., 1., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0.],\n",
       "       [0., 0., 0., 1., 0.],\n",
       "       [0., 0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.identity(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: `random`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "rng = np.random.RandomState(seed=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Construct an array containing 10 values drawn uniformly at random from the interval `[-1, 1]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.25091976,  0.90142861,  0.46398788,  0.19731697, -0.68796272,\n",
       "       -0.68801096, -0.88383278,  0.73235229,  0.20223002,  0.41614516])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng.uniform(-1, 1, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Construct a 3 x 3 array with values drawn from a normal distribution centered at 0 with a standard deviation of 2.5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.17368596,  1.35640011, -1.15854423],\n",
       "       [-1.16432438,  0.60490568, -4.78320061],\n",
       "       [-4.31229458, -1.40571882, -2.5320778 ]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng.normal(0, 2.5, (3, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `pandas.read_csv`\n",
    "\n",
    "Many people use the `pandas` module to read numerical data from external sources. The `.csv` (comma-separated value) format is often used for small and medium-sized datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can read a CSV into a DataFrame useing `pandas.read_csv`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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>AAPL</th>\n",
       "      <th>MSFT</th>\n",
       "      <th>TSLA</th>\n",
       "      <th>MCD</th>\n",
       "      <th>BK</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>dt</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2017-10-02 13:31:00</th>\n",
       "      <td>154.34</td>\n",
       "      <td>74.880</td>\n",
       "      <td>342.330</td>\n",
       "      <td>156.380</td>\n",
       "      <td>52.736</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-10-02 13:32:00</th>\n",
       "      <td>154.07</td>\n",
       "      <td>74.832</td>\n",
       "      <td>341.480</td>\n",
       "      <td>156.660</td>\n",
       "      <td>52.686</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-10-02 13:33:00</th>\n",
       "      <td>153.72</td>\n",
       "      <td>74.835</td>\n",
       "      <td>341.830</td>\n",
       "      <td>156.324</td>\n",
       "      <td>52.756</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-10-02 13:34:00</th>\n",
       "      <td>153.69</td>\n",
       "      <td>74.890</td>\n",
       "      <td>341.240</td>\n",
       "      <td>156.660</td>\n",
       "      <td>52.726</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-10-02 13:35:00</th>\n",
       "      <td>153.45</td>\n",
       "      <td>74.810</td>\n",
       "      <td>341.873</td>\n",
       "      <td>156.670</td>\n",
       "      <td>52.706</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                       AAPL    MSFT     TSLA      MCD      BK\n",
       "dt                                                           \n",
       "2017-10-02 13:31:00  154.34  74.880  342.330  156.380  52.736\n",
       "2017-10-02 13:32:00  154.07  74.832  341.480  156.660  52.686\n",
       "2017-10-02 13:33:00  153.72  74.835  341.830  156.324  52.756\n",
       "2017-10-02 13:34:00  153.69  74.890  341.240  156.660  52.726\n",
       "2017-10-02 13:35:00  153.45  74.810  341.873  156.670  52.706"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prices = pd.read_csv('prices.csv', index_col='dt', parse_dates=['dt'])\n",
    "prices.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DataFrames are composed of three parts:\n",
    "\n",
    "- `index`, an array of row-labels\n",
    "- `columns`, an array of column-labels\n",
    "- `values`, an array of table values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get a numpy array for each of these attributes by using the `.values` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['2017-10-02T13:31:00.000000000', '2017-10-02T13:32:00.000000000',\n",
       "       '2017-10-02T13:33:00.000000000', ...,\n",
       "       '2017-10-31T19:58:00.000000000', '2017-10-31T19:59:00.000000000',\n",
       "       '2017-10-31T20:00:00.000000000'], dtype='datetime64[ns]')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prices.index.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['AAPL', 'MSFT', 'TSLA', 'MCD', 'BK'], dtype=object)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prices.columns.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[154.34 ,  74.88 , 342.33 , 156.38 ,  52.736],\n",
       "       [154.07 ,  74.832, 341.48 , 156.66 ,  52.686],\n",
       "       [153.72 ,  74.835, 341.83 , 156.324,  52.756],\n",
       "       ...,\n",
       "       [169.1  ,  83.18 , 331.44 , 166.82 ,  51.415],\n",
       "       [169.13 ,  83.17 , 331.8  , 166.87 ,  51.42 ],\n",
       "       [169.05 ,  83.18 , 331.52 , 166.9  ,  51.45 ]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prices.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Use `pd.read_csv` to load the file \"volumes.csv\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "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>AAPL</th>\n",
       "      <th>MSFT</th>\n",
       "      <th>TSLA</th>\n",
       "      <th>MCD</th>\n",
       "      <th>BK</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>dt</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2017-10-02 13:31:00</th>\n",
       "      <td>420042.0</td>\n",
       "      <td>409211.0</td>\n",
       "      <td>49907.0</td>\n",
       "      <td>85774.0</td>\n",
       "      <td>30276.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-10-02 13:32:00</th>\n",
       "      <td>161960.0</td>\n",
       "      <td>49207.0</td>\n",
       "      <td>18480.0</td>\n",
       "      <td>6866.0</td>\n",
       "      <td>4511.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-10-02 13:33:00</th>\n",
       "      <td>118283.0</td>\n",
       "      <td>24043.0</td>\n",
       "      <td>47039.0</td>\n",
       "      <td>3000.0</td>\n",
       "      <td>3001.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-10-02 13:34:00</th>\n",
       "      <td>103544.0</td>\n",
       "      <td>62383.0</td>\n",
       "      <td>13444.0</td>\n",
       "      <td>4364.0</td>\n",
       "      <td>900.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-10-02 13:35:00</th>\n",
       "      <td>88012.0</td>\n",
       "      <td>40175.0</td>\n",
       "      <td>36556.0</td>\n",
       "      <td>820.0</td>\n",
       "      <td>1500.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                         AAPL      MSFT     TSLA      MCD       BK\n",
       "dt                                                                \n",
       "2017-10-02 13:31:00  420042.0  409211.0  49907.0  85774.0  30276.0\n",
       "2017-10-02 13:32:00  161960.0   49207.0  18480.0   6866.0   4511.0\n",
       "2017-10-02 13:33:00  118283.0   24043.0  47039.0   3000.0   3001.0\n",
       "2017-10-02 13:34:00  103544.0   62383.0  13444.0   4364.0    900.0\n",
       "2017-10-02 13:35:00   88012.0   40175.0  36556.0    820.0   1500.0"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "volumes = pd.read_csv('volumes.csv', index_col='dt', parse_dates=['dt'])\n",
    "volumes.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Get a numpy array of datetimes representing the row-labels of the DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['2017-10-02T13:31:00.000000000', '2017-10-02T13:32:00.000000000',\n",
       "       '2017-10-02T13:33:00.000000000', ...,\n",
       "       '2017-10-31T19:58:00.000000000', '2017-10-31T19:59:00.000000000',\n",
       "       '2017-10-31T20:00:00.000000000'], dtype='datetime64[ns]')"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "volumes.index.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Get a numpy array of strings representing the column-labels of the DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['AAPL', 'MSFT', 'TSLA', 'MCD', 'BK'], dtype=object)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "volumes.columns.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Get a numpy array of floats representing the table values of the DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[420042., 409211.,  49907.,  85774.,  30276.],\n",
       "       [161960.,  49207.,  18480.,   6866.,   4511.],\n",
       "       [118283.,  24043.,  47039.,   3000.,   3001.],\n",
       "       ...,\n",
       "       [308468., 191973.,  24702.,   8959.,  32288.],\n",
       "       [343843., 198143.,  35814.,  13696.,  56411.],\n",
       "       [661452., 610933.,  59772.,  58947., 177300.]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "volumes.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reshaping Arrays\n",
    "\n",
    "Once we've created or loaded an array, a common next step is to reshape the array.\n",
    "\n",
    "The most general way to reshape an array is to use the `.reshape` method of `ndarray`. `.reshape` accepts a tuple of new dimensions and "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.arange(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Reshape `data` into an array with three rows and four columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.reshape(3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Reshape `data` into an array with four rows and three columns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  4,  5],\n",
       "       [ 6,  7,  8],\n",
       "       [ 9, 10, 11]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.reshape(4, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Reshape `data` into an array of shape `(2, 2, 3)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2],\n",
       "        [ 3,  4,  5]],\n",
       "\n",
       "       [[ 6,  7,  8],\n",
       "        [ 9, 10, 11]]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.reshape(2, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transpose"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A common pattern, especially when doing linear algebra with 2D arrays, is to need to \"rotate\" an array by 90 degrees. This operation is commonly known as \"transposing\" the array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Use the `.transpose()` method to convert data from a `2 x 4` array into a `4 x 2` array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3],\n",
       "       [4, 5, 6, 7]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.arange(8).reshape(2, 4)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 4],\n",
       "       [1, 5],\n",
       "       [2, 6],\n",
       "       [3, 7]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.transpose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transposing arrays is so common in linear algebra that numpy provides a shorthand for it. The `.T` property provides a transposed view of an array.\n",
    "\n",
    "**Exercise:** Transpose `data` using the `.T` property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 4],\n",
       "       [1, 5],\n",
       "       [2, 6],\n",
       "       [3, 7]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Measuring Performance of Numpy vs. Pure Python\n",
    "\n",
    "We've seen that numpy allows us to run simple numerical computations much faster than pure Python. To show that, we used a few different functions and tools:\n",
    "\n",
    "- We used a `dot_product` method implemented in pure Python:\n",
    "\n",
    "```python\n",
    "def python_dot_product(xs, ys):\n",
    "    return sum(x * y for x, y in zip(xs, ys))\n",
    "```\n",
    "- We used two numpy implementations of `dot_product`:\n",
    "\n",
    "```python\n",
    "def manual_numpy_dot(xs, ys):\n",
    "    return (xs * ys).sum()\n",
    "\n",
    "def native_numpy_dot(xs, ys):\n",
    "    return xs.dot(ys)\n",
    "```\n",
    "\n",
    "- We used IPython's `%%timeit` magic as a simple way to measure how long a cell takes to run on average.\n",
    "\n",
    "Unfortunately, nothing in programming comes for free. Numpy allows us to speed up computations on large arrays by performing one complex dispatch **per array** instead of a cheap dispatch **per array element**. **This only gives us a speedup if we have many array elements.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise:\n",
    "Using the ``%%timeit`` builtin, figure out how many data points you need to have for a numpy dot product to be faster than a pure-python implementation.\n",
    "\n",
    "You can use the `make_list` function below to create Python lists of a given size. Use any of the functions from the exercises above to make numpy lists. Be sure not to include the list/array creation in your timings (that probably means you want to use separate cells for constructing arrays and testing timings)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_list(size):\n",
    "    return list(range(size))\n",
    "\n",
    "def python_dot_product(xs, ys):\n",
    "    return sum(x * y for x, y in zip(xs, ys))\n",
    "\n",
    "def manual_numpy_dot(xs, ys):\n",
    "    return (xs * ys).sum()\n",
    "\n",
    "def native_numpy_dot(xs, ys):\n",
    "    return xs.dot(ys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On my machine, the cutoff seems to be around 5 elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = make_list(5)\n",
    "n = np.arange(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "826 ns ± 5.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "python_dot_product(l, l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "694 ns ± 2.06 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "native_numpy_dot(n, n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}