Recitation 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 24787 Recitation1 : Installation and basics of Numpy\n",
    "\n",
    "$\\hspace{4mm}$Rishikesh Magar - rmagar@andrew.cmu.edu\n",
    "$\\hspace{4mm}$ Julie Lin - "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will be using Jupyter notebooks for this course. Before diving into numpy, vectorization and python basics please make sure that you have python3 installed in your computer. For python installation we would prefer the anaconda distribution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "visit the webpage: https://www.anaconda.com/distribution and follow the instructions. Make sure you install python3 since python 2 will no longer be supported starting Jan 2020 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NUMPY basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What is NumPy?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download and Installation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have installed python correctly. Numpy should perhaps come with it. If numpy is not installed please follow instructions at https://scipy.org/install.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n",
      "['AI and ML for Engineers', 24787, 'CIT @ CMU', True]\n",
      "['AI and ML for Engineers', 24787, 'CIT @ CMU', True, 'More objects', ['List inside a list!']]\n",
      "\n",
      "Length before adding another_list 4 \n",
      "\n",
      "Length after adding another_list 6 \n",
      "\n",
      "['AI and ML for Engineers', 24787, 'CIT @ CMU', True, 'More objects', ['List inside a list!'], 'More objects', ['List inside a list!']]\n"
     ]
    }
   ],
   "source": [
    "# Lists - can store anything\n",
    "\n",
    "list_of_things = ['AI and ML for Engineers'] # initalise\n",
    "list_of_things.append(24787)\n",
    "list_of_things.append('CIT @ CMU')\n",
    "list_of_things.append(True)\n",
    "\n",
    "# Accessing objects\n",
    "print(type(list_of_things[3]))\n",
    "\n",
    "# Print the list\n",
    "print(list_of_things)\n",
    "\n",
    "# Create another list\n",
    "another_list = ['More objects', ['List inside a list!']]\n",
    "\n",
    "# Merge the lists\n",
    "third_lists = list_of_things + another_list\n",
    "print(third_lists)\n",
    "\n",
    "# Extend list_of_things\n",
    "print('\\nLength before adding another_list',len(list_of_things),'\\n')\n",
    "list_of_things.extend(another_list)\n",
    "print('Length after adding another_list',len(list_of_things),'\\n')\n",
    "\n",
    "list_of_things+=another_list\n",
    "print(list_of_things)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introductory Example: Implementing with Lists "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To know the difference between an array and a list please Google ;)\n",
    "\n",
    "This blog also provides a good explanation : https://medium.com/backticks-tildes/list-vs-array-python-data-type-40ac4f294551"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[40, 41, 42]\n"
     ]
    }
   ],
   "source": [
    "# Inputs\n",
    "# Now that we know what a list is lets use it to do a simple calculation\n",
    "theta_1 = [[2, 1, 3],\n",
    "     [1, 2, 3],\n",
    "     [3, 1, 2]]\n",
    "\n",
    "x = [7, 8, 5]\n",
    "theta_0 = [1, 1, 1]\n",
    "\n",
    "# Output\n",
    "y = [0, 0, 0]\n",
    "\n",
    "# Computation of y = theta_1*x + theta_0\n",
    "for i in range(len(theta_1)):\n",
    "    for j in range(len(x)):\n",
    "        y[i] = y[i]+theta_1[i][j] * x[j]+ (theta_0[i])\n",
    "\n",
    "# for i in range(len(y)):\n",
    "#     y[i] += b[i]\n",
    "print(y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 3)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta_1 = [[1, 1, 1],\n",
    "     [2, 2, 2],\n",
    "     [3, 3, 3],\n",
    "     [4,4,4]]\n",
    "import numpy as np\n",
    "theta_2 = np.asarray(theta_1) \n",
    "theta_2.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy-based Vectorized Implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta_1 = np.array([[1, 7, 1],\n",
    "              [2, 6, 2],\n",
    "              [6, 3, 4]])\n",
    "theta_1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([7, 8, 5])\n",
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1.])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta_0 = np.ones(3)\n",
    "theta_0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([68, 72, 86])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta_1.dot(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([69., 73., 87.])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta_1.dot(x) + theta_0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi-Dimensional Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0.08857476, 0.28543566, 0.25694445, 0.39357873],\n",
       "        [0.46337671, 0.60379345, 0.99766136, 0.36934657]],\n",
       "\n",
       "       [[0.66783853, 0.98517035, 0.18155403, 0.47474615],\n",
       "        [0.1466535 , 0.61773144, 0.90007055, 0.33852965]],\n",
       "\n",
       "       [[0.96637684, 0.70601785, 0.50808582, 0.57852664],\n",
       "        [0.30050708, 0.20315041, 0.32504522, 0.09350909]],\n",
       "\n",
       "       [[0.03752604, 0.56797242, 0.04657042, 0.9235302 ],\n",
       "        [0.91108425, 0.98621553, 0.83885333, 0.70316513]]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T = np.random.random((4,2,4))\n",
    "T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2, 4), dtype('float64'))"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "W = T[1]\n",
    "W.shape, W.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((4, 3), dtype('int32'), array([[24787, 24787, 24787],\n",
       "        [24787, 24787, 24787],\n",
       "        [24787, 24787, 24787],\n",
       "        [24787, 24787, 24787]]))"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.full((4,3), 24787, dtype=np.int32) # prints out the same in all dimension # remember it is a matrix multiplication for 2D \n",
    "X.shape, X.dtype,X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[57240.84385668, 57240.84385668, 57240.84385668],\n",
       "       [49647.99285848, 49647.99285848, 49647.99285848]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "W.dot(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Element-wise Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4] [0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "y = np.arange(5)\n",
    "print(y, np.array(range(5)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True,  True])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y == np.array(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 10, 20, 30, 40])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y * 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  4,  9, 16, 25], dtype=int32)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(y + 1)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.5       , 0.66666667, 0.75      , 0.8       ])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y / (y + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4.])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(y**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 4, 1.4142135623730951, 10)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.min(), y.max(), y.std(), y.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing NumPy Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('AIML.npy', np.arange(2 *2* 4).reshape(4,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[ 0,  1,  2,  3],\n",
       "        [ 4,  5,  6,  7],\n",
       "        [ 8,  9, 10, 11],\n",
       "        [12, 13, 14, 15]]), (4, 4))"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T = np.load('AIML.npy')\n",
    "T,  T.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T[1,0]  # more efficient version of T[1][0]# a similar approach can be used for N-d arrays "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T[0,0:3] # selecting the specific elements for operations "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True, False, False, False],\n",
       "       [False, False, False, False],\n",
       "       [False, False,  True, False],\n",
       "       [False, False, False, False]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(T % 10) == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 10])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T[(T % 10) == 0] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3],\n",
       "       [4, 5, 5, 5],\n",
       "       [5, 5, 5, 5],\n",
       "       [5, 5, 5, 5]])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.minimum(T, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(T)# please try np.maximum and by following the upper example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computation Along Axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.60936464, 0.81248973],\n",
       "       [0.49657416, 0.89232683]])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.random.random((2,2))\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.810755364171568"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.sum()# all "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.10593881, 1.70481656])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.sum(axis=0) # column wise # col1 # col2 #col3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.42185437, 1.388901  ])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.sum(axis=1) # row 1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.60936464, 0.89232683]), array([0, 1], dtype=int64))"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.max(axis=0), A.argmax(axis=0)# column# the argmax returns the index where max occurs "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Combining Arrays: Stacking & Concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 2 2] [4 4 4] [6 6 6]\n"
     ]
    }
   ],
   "source": [
    "a = np.full(3, 2)\n",
    "b = np.full(3, 4)\n",
    "c = np.full(3, 6)\n",
    "print(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stacking creates a new axis. It joins the supplied arrays, which must have the same shape, along that axis.\n",
    "Indexing a single element from that axis returns the appropriate input array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[2, 4, 6],\n",
       "        [2, 4, 6],\n",
       "        [2, 4, 6]]), (3, 3))"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = np.stack([a, b, c], axis=1) # do check out np.hstack and np.vstack \n",
    "B, B.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 4, 4])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[:,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Concatenating arrays joins them along an *existing* aixs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[12, 14, 16, 52, 54, 56],\n",
       "       [12, 14, 16, 52, 54, 56],\n",
       "       [12, 14, 16, 52, 54, 56]])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = np.concatenate([B+10, B+50], axis=1 )\n",
    "C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transposing and Reshaping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[12, 14, 16, 52, 54, 56],\n",
       "        [12, 14, 16, 52, 54, 56],\n",
       "        [12, 14, 16, 52, 54, 56]]), (3, 6))"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C, C.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[12, 12, 12],\n",
       "        [14, 14, 14],\n",
       "        [16, 16, 16],\n",
       "        [52, 52, 52],\n",
       "        [54, 54, 54],\n",
       "        [56, 56, 56]]), (6, 3))"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CT = C.T\n",
    "CT, CT.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[12, 14, 16, 52, 54, 56],\n",
       "        [12, 14, 16, 52, 54, 56],\n",
       "        [12, 14, 16, 52, 54, 56]]), (3, 6))"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CR = C.reshape(3, 6)\n",
    "CR, CR.shape # it goes row wise "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving and Loading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving and loading a single NumPy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.36004659 0.88070426 0.51661761 0.40552024 0.69495806]\n"
     ]
    }
   ],
   "source": [
    "# Save single array\n",
    "x = np.random.random((5,))\n",
    "print(x)\n",
    "\n",
    "np.save('tmp.npy', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.36004659 0.88070426 0.51661761 0.40552024 0.69495806]\n"
     ]
    }
   ],
   "source": [
    "# Load the array\n",
    "y = np.load('tmp.npy')\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving and loading a dictionary of NumPy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.37224102 0.92654621] [0.07779269 0.27507876 0.80229034]\n"
     ]
    }
   ],
   "source": [
    "# Save dictionary of arrays\n",
    "x1 = np.random.random((2,))\n",
    "y1 = np.random.random((3,))\n",
    "print(x1, y1)\n",
    "\n",
    "np.savez('tmp.npz', x=x1, y=y1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.37224102 0.92654621]\n",
      "[0.07779269 0.27507876 0.80229034]\n"
     ]
    }
   ],
   "source": [
    "# Load the dictionary of arrays\n",
    "data = np.load('tmp.npz')\n",
    "\n",
    "print(data['x'])\n",
    "print(data['y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load csv file\n",
    "import csv\n",
    "with open('imp.csv', 'r') as csv_file: \n",
    "    csv_reader = csv.reader(csv_file)\n",
    "#This is a good starting point \n",
    "# you may like to use this when coding up your homework"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'_csv.reader' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-148-7a85e59af93d>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;33m(\u001b[0m\u001b[0mcsv_reader\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: '_csv.reader' object is not subscriptable"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numbers operators and comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# This is how you comment things out \n",
    "print(type(9))\n",
    "print(type(9.0))\n",
    "print(type(1+3.33))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "1.6666666666666665\n"
     ]
    }
   ],
   "source": [
    "print(2 ** 3)\n",
    "print(1+2/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "decimal = 12.456435\n",
    "\n",
    "# type casting: convert a data type\n",
    "decimal = int(decimal)\n",
    "print(decimal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables and strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Varialbes are assigned with the variable name on the left and the value on the right of the equals sign. \n",
    "#### Variables must be assigned before they can be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "days_hw_due = 5\n",
    "days_hw_due = days_hw_due -1\n",
    "print(days_hw_due)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean and condition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "whats your favorite colorpurple\n",
      "great choice\n"
     ]
    }
   ],
   "source": [
    "color = input (\"whats your favorite color\")\n",
    "if color == \"purple\":\n",
    "    print(\"great choice\")\n",
    "elif color == \"pure darkness\":\n",
    "    print(\"I like how you think\")\n",
    "elif color == \"pink\":\n",
    "    print(\"not bad\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are a child or senior\n"
     ]
    }
   ],
   "source": [
    "# 2-8: 2 dollar ticket\n",
    "# 65: 5 dollar ticket\n",
    "# 10 dollar for everyone else\n",
    "\n",
    "age = 8\n",
    "if not ((age >=2 and age<=8) or age >=65):\n",
    "    print(\"You pay 10 dollars and are not a child or senior\")\n",
    "else:\n",
    "    print(\"You are a child or senior\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# General Form \n",
    "\n",
    "#for item in iterabl_object:\n",
    "    # do something with item\n",
    "    \n",
    "# item is a new variable that you can call it whatever\n",
    "# item references the current position of out iterator wihtin the iterable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ranges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A range is just a slice of number line.\n",
    "Ex: range (1,8) will give you integers from 1 to 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rg = range(1,10,2)\n",
    "print(rg) # 2 is the step, numbers to skip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(rg))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use a for loop for add up every odd number from 10 to 20 (inclusive) and store the result in the variable x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "for n in range(10, 21):  #remember range is exclusive, so we have to go up to 21\n",
    "    if n % 2 != 0: # % means mod\n",
    "        x += n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Given the string \"amazing\", create a variable ans, which is a list containing all the letters from \"amazing\" but not the vowels (a,e,i,o,u) The ans shall look like [\"m\",'z','n','g']. Use list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['m', 'z', 'n', 'g']\n"
     ]
    }
   ],
   "source": [
    "ans = [char for char in \"amazing\" if char not in \"aeiou\"]\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While Loop and using \"len\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,2,3,4]\n",
    "i=0\n",
    "while i < len(numbers):\n",
    "    print(numbers[i])\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List slicing and join"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# some_list[start:end:step] like range but separated with colons\n",
    "\n",
    "colors = ['red','blue','green','yellow','purple','indigo']\n",
    "print(colors[:5])\n",
    "print(colors[0:5])\n",
    "print(colors[2:-1])\n",
    "print(colors[2:])\n",
    "print(colors[::2])\n",
    "print(colors[::-1])\n",
    "print(colors[5][::-1])\n",
    "\n",
    "# Join (a string method)\n",
    "words = [\"Python\",\"Is\",\"Great\"]\n",
    "words =\".\".join(words)\n",
    "print(words)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'founder': 'Andrew Carnegie', 'private school?': True, 'acceptance rate': 0.2, 4: 'number of other campuses'}\n",
      "Andrew Carnegie\n"
     ]
    }
   ],
   "source": [
    "# A data structure that contains key-value pairs\n",
    "# keys and values are separated by colons\n",
    "# keys are almost always numnbers or strings\n",
    "# note: dictionary doesnt have a specific order, unlike a list\n",
    "cmu = {\n",
    "    'founder': \"Andrew Carnegie\",\n",
    "    'private school?': True,\n",
    "    'acceptance rate':0.2,\n",
    "     4:\"number of other campuses\"\n",
    "}\n",
    "print(cmu)\n",
    "print(cmu[\"founder\"])\n",
    "# print(cmu[\"mascot\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Accessing all values in a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Andrew Carnegie\n",
      "True\n",
      "0.2\n",
      "number of other campuses\n"
     ]
    }
   ],
   "source": [
    "# Access value: Use .values()\n",
    "for value in cmu.values():\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "founder\n",
      "private school?\n",
      "acceptance rate\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Access key: Use .keys()\n",
    "for key in cmu.keys():\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "founder : Andrew Carnegie\n",
      "private school? : True\n",
      "acceptance rate : 0.2\n",
      "4 : number of other campuses\n"
     ]
    }
   ],
   "source": [
    "# Access both: .items()\n",
    "for key,value in cmu.items():\n",
    "    print(key, \":\", value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Test if a key exists: Use \"in\"\n",
    "print(\"founder\" in cmu)\n",
    "print(\"good food\" in cmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "None\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "'no_key'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-15-9c2268ec4c15>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"a\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"no_key\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"no_key\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'no_key'"
     ]
    }
   ],
   "source": [
    "# get: Retrieves a key in a object, and return None instead of KeyError\n",
    "d = dict(a=1,b=2,c=3)\n",
    "print(d.get(\"a\"))\n",
    "print(d.get(\"no_key\"))\n",
    "print(d[\"no_key\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 2, 'c': 3}\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "d = dict(a=1,b=2,c=3)\n",
    "clone = d.copy()\n",
    "print(clone)\n",
    "print(clone == d)\n",
    "print(clone is d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "return: \n",
    "\n",
    "1.Exits the function \n",
    "\n",
    "2.Outputs whatever value is places after the return keyword\n",
    "\n",
    "3.Need to add parenthesis after the function name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Heads'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from random import random\n",
    "def flip_coin():\n",
    "    #generates random number 0-1\n",
    "    r = random()\n",
    "    if r > 0.5:\n",
    "        return \"Heads\"\n",
    "    else: \n",
    "        return \"Tails\"\n",
    "\n",
    "flip_coin()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Function that accepts inputs (parameters vs arguments)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def min_max_key_in_dictionary(d):\n",
    "    keys = d.keys()\n",
    "    return [min(keys), max(keys)]\n",
    "\n",
    "min_max_key_in_dictionary({1:\"eat\",2:\"sleep\",3:\"drink\",4:\"play\"})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Keyworded Arguments \n",
    "# Will cover this if time permitted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find a more complete introduction at https://docs.scipy.org/doc/numpy/user/quickstart.html"
   ]
  }
 ],
 "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}