Python for Data Analysis Workbook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python for Data Analysis - Workbook 1 (Python Basics + NumPy Basics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preliminaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 562,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basics: Built-in Data Structures, Functions, and Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Structures and sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a tup is a fixed length, immutable sequence of python obj's. They can be created like this:\n",
    "\n",
    "tup = 4,5,6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This one is nested\n",
    "nested_tup = (4,5,6),(7,8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('s', 't', 'r', 'i', 'n', 'g')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Any sequence or iterator (more on that later) can be converted to a tuple like this:\n",
    "\n",
    "tuple([4,4,2])\n",
    "tuple('string')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Just like any C, C++, or aa array, tuples can be accessed with thte [] notation\n",
    "tup[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 5, 6, (4, 5, 6), (7, 8))"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can concatenate tuples using the '+' symbol to produce longer tuples\n",
    "tup + nested_tup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# But using the '*' character ('*' means multiply) instead of the '+' character has the\n",
    "# effect of creating that many copies of the tuple\n",
    "\n",
    "tup * 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Replicate a swap function as in e.g. C\n",
    "\n",
    "tup = [4,5,6]\n",
    "a, b = 1, 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=1 b=2, c=3\n",
      "a=4 b=5, c=6\n",
      "a=7 b=8, c=9\n"
     ]
    }
   ],
   "source": [
    "# Common use for variable unpacking is iterating over sequences or lists\n",
    "\n",
    "seq = [1,2,3], [4,5,6], [7,8,9]\n",
    "\n",
    "for a,b,c in seq:\n",
    "    print('a={0} b={1}, c={2}'.format(a,b,c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Count the number of occurences of a particular value in a list\n",
    "\n",
    "a = (1,2,2,2,3,4,2)\n",
    "a.count(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# List is variable length and contents can be modified in-place\n",
    "# Defined using square brackets\n",
    "# Equivalent to Javascript Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# List function is commonly used in data processing as a way to create an iterator expression\n",
    "\n",
    "gen = range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now we have a list from 0 - 9 (10 values)\n",
    "\n",
    "list(gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex_list = ['foo', 'bar', 'baz']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Can append or insert elements\n",
    "ex_list.append('bow')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dog', 'foo', 'bar', 'baz', 'bow']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Note: inserting/popping elements in a list is computationally expensive\n",
    "ex_list.insert(0, 'dog')\n",
    "ex_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['foo', 'bar', 'baz', 'bow']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex_list.pop(0)\n",
    "ex_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['foo', 'bar', 'bow']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Or remove by value\n",
    "ex_list.remove('baz')\n",
    "ex_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check to see if a value is included in a specific list\n",
    "'foo' in ex_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'foo' not in ex_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['foo', 'bar', 'bow', 'dog', 'cat', 'mouse']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Concatenation (expensive)\n",
    "\n",
    "ex_list2 = ['dog', 'cat', 'mouse']\n",
    "ex_list + ex_list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['foo', 'bar', 'bow', 'dog', 'cat', 'mouse', 'dog', 'cat', 'mouse']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extension (cheaper)\n",
    "\n",
    "ex_list.extend(ex_list2)\n",
    "ex_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sorting lists\n",
    "\n",
    "a = [3,4,1]\n",
    "a.sort()\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['foo', 'bar', 'bow', 'dog', 'cat', 'dog', 'cat', 'mouse', 'mouse']"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can pass in different keys, or functions that produce a value to search the objects\n",
    "\n",
    "ex_list.sort(key=len)\n",
    "ex_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Binary Search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Binary search is implemented through the native \"bisect\" module\n",
    "\n",
    "import bisect\n",
    "c = [1,2,2,2,3,4,7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bisect.bisect(c,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bisect.bisect(c,7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 2, 2, 3, 4, 6, 7]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Inserting an element\n",
    "# Note...list has to be sorted first!\n",
    "\n",
    "bisect.insort(c,6)\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Slicing a List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 7, 5]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing - basic form is start:stop to the indexing operator\n",
    "\n",
    "seq = [7,2,3,7,5,6,0,1]\n",
    "seq[1:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 2, 3, 7, 8, 5, 6, 0, 1]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can also assign with a sequence\n",
    "\n",
    "seq[3:4] = [7,8]\n",
    "seq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 0, 1]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use negative indices to slice the sequence relative to the end\n",
    "\n",
    "seq[-4:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 5, 6, 0, 1]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq[4:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 7, 5, 0]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Step size can be defined after a second colon, as below\n",
    "seq[1:8:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 0, 6, 5, 8, 7, 3, 2, 7]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Here's a handy way to reverse a list\n",
    "\n",
    "seq[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Built in Sequence Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hard Way\n",
      "\n",
      "1\n",
      "2\n",
      "3\n",
      "\n",
      "Easy Way\n",
      "\n",
      "3\n",
      "3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Keep track of index of current item when enumerating over a list/dict\n",
    "\n",
    "# Hard Way:\n",
    "\n",
    "collection = [1,2,3]\n",
    "\n",
    "i = 0\n",
    "print('Hard Way\\n')\n",
    "for item in collection:\n",
    "    print(item)\n",
    "    i += 1\n",
    "\n",
    "# Easy Way\n",
    "\n",
    "print('\\nEasy Way\\n')\n",
    "for i, value in enumerate(collection):\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 'foo', 1: 'bar', 2: 'baz'}\n",
      "{0: 'foo', 1: 'bar', 2: 'baz'}\n"
     ]
    }
   ],
   "source": [
    "# Example - create some dict that is a mapping between two lists\n",
    "\n",
    "some_list = ['foo', 'bar', 'baz']\n",
    "mapping = {}\n",
    "\n",
    "for i,v in enumerate(some_list):\n",
    "    mapping[i] = v\n",
    "    \n",
    "print(mapping)\n",
    "\n",
    "# Really easy way to make a dictionary\n",
    "print(dict(mapping))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 2, 5, 12]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sorting\n",
    "\n",
    "sorted([5,2,1,12,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[' ', 'a', 'c', 'e', 'e', 'h', 'o', 'r', 'r', 's']"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted('horse race')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('foo', 'dog'), ('bar', 'cat'), ('baz', 'three')]"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Zipping\n",
    "\n",
    "seq1 = ['foo', 'bar', 'baz']\n",
    "seq2 = ['dog', 'cat', 'three']\n",
    "\n",
    "zipped = zip(seq1, seq2)\n",
    "list(zipped)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: foo, dog\n",
      "1: bar, cat\n",
      "2: baz, three\n"
     ]
    }
   ],
   "source": [
    "# Combining zip and enumerate for ultimate pythonism\n",
    "\n",
    "\n",
    "seq1 = ['foo', 'bar', 'baz']\n",
    "seq2 = ['dog', 'cat', 'three']\n",
    "\n",
    "for i, (a,b) in enumerate(zip(seq1, seq2)):\n",
    "    print('{0}: {1}, {2}'.format(i, a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Nolan', 'Roger', 'Schilling')"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Unzip in a hacky way using '*'\n",
    "\n",
    "pitchers = [('Nolan', 'Ryan'), ('Roger', 'Clemens'),('Schilling', 'Curt')]\n",
    "first_names, last_names = zip(*pitchers)\n",
    "first_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Nolan', 'Ryan')\n",
      "[('Roger', 'Clemens'), ('Schilling', 'Curt')]\n"
     ]
    }
   ],
   "source": [
    "# The above uses the '*' operator to 'unpack' the list. See below example\n",
    "\n",
    "a,*b = pitchers\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dicts (Also called key-value pairs or hashmaps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex_dict = {'a': 'some value', 'b': [1, 2, 3, 4]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'some value'"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Access dict item\n",
    "ex_dict['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 'some value', 'b': [5, 6, 7, 8]}\n"
     ]
    }
   ],
   "source": [
    "# Replace item\n",
    "ex_dict['b'] = [5, 6, 7, 8]\n",
    "print(ex_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 'some value', 'b': [5, 6, 7, 8], 'fish': 'red'}\n"
     ]
    }
   ],
   "source": [
    "# Add item\n",
    "ex_dict['fish'] = 'red'\n",
    "print(ex_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check for a key\n",
    "'b' in ex_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "some value\n"
     ]
    }
   ],
   "source": [
    "# Two ways to delete: del which deletes the k/v or pop which returns the value and deletes key\n",
    "\n",
    "del ex_dict['b']\n",
    "print(ex_dict.pop('a'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['fish']\n",
      "['red']\n"
     ]
    }
   ],
   "source": [
    "# Keys and values\n",
    "print(list(ex_dict.keys()))\n",
    "print(list(ex_dict.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Merging two dicts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'red': 1, 'blue': 2, 'green': 3, 'purple': 4}\n"
     ]
    }
   ],
   "source": [
    "d1 = {'red': 1, 'blue': 2}\n",
    "d2 = {'green': 3, 'purple': 4}\n",
    "d1.update(d2)\n",
    "print(d1)\n",
    "\n",
    "# Note: changes in place"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating dicts from sequences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'dog': 1, 'cat': 2, 'rabbit': 3}"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dict is essentially a collection of 2-tuples\n",
    "# Simple way to create a dict out of two lists\n",
    "\n",
    "key_list = ['dog', 'cat', 'rabbit']\n",
    "value_list = [1,2,3]\n",
    "\n",
    "mapping = {}\n",
    "for key, value in zip(key_list, value_list):\n",
    "    mapping[key] = value\n",
    "    \n",
    "mapping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Setting default values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hard way:\n",
    "\n",
    "if key in some_dict:\n",
    "    value = some_dict[key]\n",
    "else:\n",
    "    value = default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# can replace with get method (or pop):\n",
    "\n",
    "ex_dict = {'dog':1, 'cat':2}\n",
    "default = 3\n",
    "print(ex_dict.get('dog', default))\n",
    "print(ex_dict.get('baz', default))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A set is an unordered collection of unique elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 6}\n"
     ]
    }
   ],
   "source": [
    "s1 = set([2,3,2,4,1,4,2,1,6])\n",
    "print(s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "# another way to create sets\n",
    "s2 = {5,6,7,8}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{6}"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Supports all the mathetmatical set operations\n",
    "\n",
    "s1.intersection(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8}"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.union(s2)\n",
    "\n",
    "# or\n",
    "\n",
    "s1 | s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.difference(s2)\n",
    "\n",
    "# or\n",
    "\n",
    "s1 - s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{5, 7, 8}"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2.difference(s1)\n",
    "\n",
    "# or\n",
    "\n",
    "s2 - s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 7, 8}"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.symmetric_difference(s2)\n",
    "\n",
    "# or\n",
    "\n",
    "s1 ^ s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.issubset(s2)\n",
    "\n",
    "# or\n",
    "\n",
    "s1 <= s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.issuperset(s2)\n",
    "\n",
    "# or\n",
    "\n",
    "s1 >= s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plus many others"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List/Set/Dict Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "# List comprehension replaces this -->\n",
    "\n",
    "# result = []\n",
    "# for val in collection:\n",
    "#     if condition:\n",
    "#         result.append(expr)\n",
    "        \n",
    "# ...with this -->\n",
    "\n",
    "# [expr for val in collection if condition]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['BAT', 'CAR', 'DOVE']"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example of list comprehension:\n",
    "\n",
    "strings = ['a', 'as', 'bat', 'car', 'dove']\n",
    "[x.upper() for x in strings if len(x) > 2]\n",
    "\n",
    "# Note that the output is a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Valerie', 'Steven']\n",
      "['Valerie', 'Steven']\n"
     ]
    }
   ],
   "source": [
    "# Can also do nested list comprehensions\n",
    "\n",
    "name_list = [['John', 'Emily', 'Valerie', 'Mickels'], ['Maria', 'Juan', 'Pilar', 'Steven']]\n",
    "\n",
    "# HARD WAY\n",
    "\n",
    "names_of_interest = []\n",
    "for names in name_list:\n",
    "    double_e = [name for name in names if name.count('e') >= 2]\n",
    "    names_of_interest.extend(double_e)\n",
    "\n",
    "print(names_of_interest)\n",
    "\n",
    "# EASY WAY\n",
    "\n",
    "result = [name for names in name_list for name in names if name.count('e') >= 2]\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Set/Dict Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "# Create a set based on lengths of words\n",
    "\n",
    "strings = ['a', 'as', 'bat', 'car', 'dove']\n",
    "unique_lengths = {len(x) for x in strings}\n",
    "print(unique_lengths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 0, 'as': 1, 'bat': 2, 'car': 3, 'dove': 4}\n"
     ]
    }
   ],
   "source": [
    "# Create a location mapping a dictionary\n",
    "strings = ['a', 'as', 'bat', 'car', 'dove']\n",
    "loc_mapping = {val : index for index, val in enumerate(strings)}\n",
    "print(loc_mapping)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ALICE', 'BOB', 'CHARLIE']\n"
     ]
    }
   ],
   "source": [
    "# Note, all functions in Python are represented as objects\n",
    "# So we can pass in a list of functions to to other functions like this:\n",
    "\n",
    "def clean_strings(strings, ops):\n",
    "    result = []\n",
    "    for value in strings:\n",
    "        for function in ops:\n",
    "            value = function(value)\n",
    "        result.append(value)\n",
    "    return result\n",
    "\n",
    "strs = ['Alice', 'Bob  ', 'charlie']\n",
    "clean_ops = [str.strip, str.upper]\n",
    "\n",
    "print(clean_strings(strs, clean_ops))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ALICE\n",
      "BOB  \n",
      "CHARLIE\n"
     ]
    }
   ],
   "source": [
    "# Applies a function to a sequence of some kind\n",
    "\n",
    "strs = ['Alice', 'Bob  ', 'charlie']\n",
    "\n",
    "for string in map(str.upper, strs):\n",
    "    print(string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lambda Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lambda functions are the Python version of anonymous functions\n",
    "\n",
    "def short(x):\n",
    "    return x*2\n",
    "\n",
    "lambda_short = lambda x: x*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 0, 2, 4, 12]"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Another practical example\n",
    "\n",
    "def apply_to_list(some_list, f):\n",
    "    return [f(x) for x in some_list]\n",
    "\n",
    "ints = [4, 0, 1, 2,6]\n",
    "apply_to_list(ints, lambda x: x*2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "# Python features an iterator protocol, a generic way to make objects iterable\n",
    "# e.g. iterating over a dict yields the dict keys\n",
    "\n",
    "some_dict = {'a':1, 'b':2, 'c':3}\n",
    "for key in some_dict:\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c']\n"
     ]
    }
   ],
   "source": [
    "# This can be called directly using the 'iter' keyword\n",
    "\n",
    "some_dict = {'a':1, 'b':2, 'c':3}\n",
    "\n",
    "dict_iterator = iter(some_dict)\n",
    "\n",
    "# Can pass into methods expecting a list or list-like object\n",
    "\n",
    "print(list(dict_iterator))\n",
    "# print(max(dict_iterator))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object squares at 0x122978570>"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A generator is a concise way to construct a new iterable object\n",
    "# Generator returns multiple results lazily, pausing until next is requested\n",
    "# Use the 'yield' keyword instead of 'return' to create a generator\n",
    "\n",
    "def squares(n=10):\n",
    "    for i in range(1, n+1):\n",
    "        yield i ** 2\n",
    "\n",
    "gen = squares()\n",
    "gen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 4 9 16 25 36 49 64 81 100 "
     ]
    }
   ],
   "source": [
    "# Gets evaluated when you iterate over it\n",
    "\n",
    "for x in gen:\n",
    "    print(x, end= ' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 4 9 16 25 36 49 64 81 "
     ]
    }
   ],
   "source": [
    "# Can also use an expression to make generators more concise (similar to list comp)\n",
    "\n",
    "gen = [x ** 2 for x in range(10)]\n",
    "for x in gen:\n",
    "    print(x, end= ' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "328350"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can use generators in place of list comprehensions \n",
    "\n",
    "sum(x ** 2 for x in range(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lots of useful generators in itertools here\n",
    "# https://docs.python.org/3/library/itertools.html\n",
    "\n",
    "# A couple demonstrated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 2),\n",
       " (1, 3),\n",
       " (1, 4),\n",
       " (1, 6),\n",
       " (1, 135),\n",
       " (1, 6231),\n",
       " (2, 3),\n",
       " (2, 4),\n",
       " (2, 6),\n",
       " (2, 135),\n",
       " (2, 6231),\n",
       " (3, 4),\n",
       " (3, 6),\n",
       " (3, 135),\n",
       " (3, 6231),\n",
       " (4, 6),\n",
       " (4, 135),\n",
       " (4, 6231),\n",
       " (6, 135),\n",
       " (6, 6231),\n",
       " (135, 6231)]"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Don't forget to import itertools!\n",
    "import itertools as it\n",
    "\n",
    "# Combinations\n",
    "\n",
    "ex_set = {1, 2, 6, 3, 135,6, 6231, 6, 4}\n",
    "list(it.combinations(ex_set, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 2),\n",
       " (1, 3),\n",
       " (1, 4),\n",
       " (1, 6),\n",
       " (1, 135),\n",
       " (1, 6231),\n",
       " (2, 1),\n",
       " (2, 3),\n",
       " (2, 4),\n",
       " (2, 6),\n",
       " (2, 135),\n",
       " (2, 6231),\n",
       " (3, 1),\n",
       " (3, 2),\n",
       " (3, 4),\n",
       " (3, 6),\n",
       " (3, 135),\n",
       " (3, 6231),\n",
       " (4, 1),\n",
       " (4, 2),\n",
       " (4, 3),\n",
       " (4, 6),\n",
       " (4, 135),\n",
       " (4, 6231),\n",
       " (6, 1),\n",
       " (6, 2),\n",
       " (6, 3),\n",
       " (6, 4),\n",
       " (6, 135),\n",
       " (6, 6231),\n",
       " (135, 1),\n",
       " (135, 2),\n",
       " (135, 3),\n",
       " (135, 4),\n",
       " (135, 6),\n",
       " (135, 6231),\n",
       " (6231, 1),\n",
       " (6231, 2),\n",
       " (6231, 3),\n",
       " (6231, 4),\n",
       " (6231, 6),\n",
       " (6231, 135)]"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Permutations\n",
    "import itertools as it\n",
    "\n",
    "ex_set = {1, 2, 6, 3, 135,6, 6231, 6, 4}\n",
    "list(it.permutations(ex_set, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Files and the Operating System"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['This is an example text file\\n',\n",
       " 'I am practicing my VIM skills\\n',\n",
       " 'I am practicing my VIM skills\\n',\n",
       " 'I am practicing my VIM skillz\\n']"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path = './crushp.txt'\n",
    "\n",
    "lines = [line for line in open(path)]\n",
    "lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is an example text file\\n'"
      ]
     },
     "execution_count": 258,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can access by line as with an array\n",
    "\n",
    "lines[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Very important! Like C, must remember to close files or there will be memory leaks\n",
    "\n",
    "path = './crushp.txt'\n",
    "\n",
    "f = open(path)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['This is an example text file\\n', 'I am practicing my VIM skills\\n', 'I am practicing my VIM skills\\n', 'I am practicing my VIM skillz\\n']\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Can also use the \"with\" statement to close a file at the end of the block\n",
    "\n",
    "path = './crushp.txt'\n",
    "lines = [];\n",
    "\n",
    "with open(path) as f:\n",
    "    lines = [line for line in open(path)]\n",
    "print(lines)\n",
    "\n",
    "print(f.closed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['This is an example text file\\n', 'I am practicing my VIM skills\\n', 'I am practicing my VIM skills\\n', 'I am practicing my VIM skillz\\n']\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Alternative way to read lines into a file\n",
    "\n",
    "path = './crushp.txt'\n",
    "lines = [];\n",
    "\n",
    "with open(path) as f:\n",
    "    lines = f.readlines()\n",
    "print(lines)\n",
    "\n",
    "print(f.closed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 287,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use 'read' and 'write' methods just like you would in C\n",
    "\n",
    "path = './crushp.txt'\n",
    "\n",
    "f = open(path)\n",
    "f.read(10)\n",
    "\n",
    "# Goto a specific character in the file (by integer)\n",
    "f.seek(10)\n",
    "\n",
    "# Where are you in the file?\n",
    "f.tell()\n",
    "\n",
    "# close the file\n",
    "f.close()\n",
    "\n",
    "f.closed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction to the NumPy Array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ndarray objects are the basis of NumPy computing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.10043225,  0.69225456, -0.5355994 ],\n",
       "       [-1.17543133, -0.53292317, -0.31573878]])"
      ]
     },
     "execution_count": 294,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creates a matrix of dimensions x,y with values selected at random from a standard norm dist.\n",
    "\n",
    "np.random.randn(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 383,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0.]\n",
      " [1. 1. 1. 1.]\n",
      " [2. 2. 2. 2.]\n",
      " [3. 3. 3. 3.]\n",
      " [4. 4. 4. 4.]\n",
      " [5. 5. 5. 5.]\n",
      " [6. 6. 6. 6.]\n",
      " [7. 7. 7. 7.]]\n",
      "\n",
      "\n",
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [12 13 14 15]\n",
      " [16 17 18 19]\n",
      " [20 21 22 23]\n",
      " [24 25 26 27]\n",
      " [28 29 30 31]]\n"
     ]
    }
   ],
   "source": [
    "# A few other ways to initialize a matrix\n",
    "\n",
    "# Initialize each value in a row to the same value\n",
    "\n",
    "arr = np.empty((8,4))\n",
    "\n",
    "for i in range(8):\n",
    "    arr[i] = i\n",
    "\n",
    "print(arr)\n",
    "print('\\n')\n",
    "    \n",
    "    \n",
    "# Initialize sequentially\n",
    "\n",
    "arr2 = np.arange(32).reshape(8,4)\n",
    "print(arr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.63863108 -1.14957662 -1.68275552]\n",
      " [-0.44124116  1.74118678  0.88941171]]\n",
      "[[ -6.38631084 -11.49576625 -16.82755515]\n",
      " [ -4.41241159  17.41186784   8.89411708]]\n",
      "[[-1.27726217 -2.29915325 -3.36551103]\n",
      " [-0.88248232  3.48237357  1.77882342]]\n"
     ]
    }
   ],
   "source": [
    "# Can do scalar or vector operations\n",
    "\n",
    "data = np.random.randn(2,3)\n",
    "print(data)\n",
    "print(data * 10)\n",
    "print(data + data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "float64\n"
     ]
    }
   ],
   "source": [
    "# Note, an ndarray is a generic multi-dim container for data that is all the same type\n",
    "\n",
    "data = np.random.randn(2,3)\n",
    "\n",
    "print(data.shape)\n",
    "print(data.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])"
      ]
     },
     "execution_count": 305,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy equivalent of range function: arange\n",
    "\n",
    "np.arange(15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n",
      "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "# can initialize to zeroes or ones\n",
    "\n",
    "print(np.ones(10))\n",
    "print(np.zeros(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 310,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can also initialize empty matrices using .empty (note, could contain garbage values)\n",
    "\n",
    "np.empty(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n",
      "\n",
      "\n",
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# Can also create an identity matrix\n",
    "\n",
    "print(np.eye(3,3))\n",
    "print('\\n')\n",
    "print(np.identity(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### NumPy Operations using matrices/ndarrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "\n",
      "\n",
      "[[ 2  4  6]\n",
      " [ 8 10 12]]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1,2,3],[4,5,6]])\n",
    "\n",
    "# Basic Array\n",
    "\n",
    "print(arr)\n",
    "print(\"\\n\")\n",
    "\n",
    "# Arithmetic ops apply element-wise (b/n equal size arrays):\n",
    "\n",
    "print(arr + arr)\n",
    "print(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 329,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "\n",
      "\n",
      "[[ 3  6  9]\n",
      " [12 15 18]]\n"
     ]
    }
   ],
   "source": [
    "# Scalar ops apply to each element in the array\n",
    "\n",
    "arr = np.array([[1,2,3],[4,5,6]])\n",
    "\n",
    "print(arr)\n",
    "print(\"\\n\")\n",
    "\n",
    "print(3* arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True, False,  True],\n",
       "       [False, False,  True]])"
      ]
     },
     "execution_count": 332,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can evaluate boolean expressions too (element-wise)\n",
    "\n",
    "arr = np.array([[1,2,3],[4,5,6]])\n",
    "\n",
    "arr1 = np.array([[4,1,4],[1,1,10]])\n",
    "\n",
    "arr < arr1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### NumPy Indexing / Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[5 6 7]\n"
     ]
    }
   ],
   "source": [
    "# Can use the colon to slice an array. Note that it is includes start index value\n",
    "# But it excludes the end\n",
    "\n",
    "arr = np.arange(10)\n",
    "print(arr)\n",
    "print(arr[5:8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 341,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[    0     1     2     3     4 12345     6     7     8     9]\n",
      "[12345     6     7]\n"
     ]
    }
   ],
   "source": [
    "# Note: indexing in NumPy always returns a view on the ndarray object\n",
    "\n",
    "arr = np.arange(10)\n",
    "\n",
    "arr_slice = arr[5:8]\n",
    "arr_slice[0] = 12345\n",
    "\n",
    "# fifth index in original array should be changed\n",
    "print(arr)\n",
    "print(arr_slice)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 342,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[12345     6     7]\n"
     ]
    }
   ],
   "source": [
    "# Must use the copy() method to avoid that behavior\n",
    "\n",
    "arr = np.arange(10)\n",
    "\n",
    "arr_slice = arr[5:8].copy()\n",
    "arr_slice[0] = 12345\n",
    "\n",
    "# Original array is preserved\n",
    "print(arr)\n",
    "print(arr_slice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 345,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 345,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Accessing a 2d array (think of the first number as rows and second number as cols)\n",
    "\n",
    "arr2d = np.array([[1,2,3], [4,5,6], [7,8,9]])\n",
    "arr2d[0,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 346,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 6],\n",
       "       [8, 9]])"
      ]
     },
     "execution_count": 346,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slice a 2d array \n",
    "\n",
    "arr2d = np.array([[1,2,3], [4,5,6], [7,8,9]])\n",
    "arr2d[1:, 1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 349,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 349,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#3d arrays: if you omit a dimensional index when selecting, it returns a new ndarray\n",
    "# with all the data from higher dimensions\n",
    "\n",
    "arr3d = np.array([[[1,2,3],[4,5,6]],[[7,8,9], [10,11,12]]])\n",
    "arr3d[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 354,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[36 36 36]\n",
      "  [36 36 36]]\n",
      "\n",
      " [[ 7  8  9]\n",
      "  [10 11 12]]]\n",
      "\n",
      "\n",
      "[[[ 1  2  3]\n",
      "  [ 4  5  6]]\n",
      "\n",
      " [[ 7  8  9]\n",
      "  [10 11 12]]]\n"
     ]
    }
   ],
   "source": [
    "# Both scalars and vectors can be assigned \n",
    "\n",
    "arr3d = np.array([[[1,2,3],[4,5,6]],[[7,8,9], [10,11,12]]])\n",
    "newNum = 36\n",
    "old_values = arr3d[0].copy()\n",
    "\n",
    "arr3d[0] = newNum\n",
    "print(arr3d)\n",
    "print('\\n')\n",
    "\n",
    "arr3d[0] = old_values\n",
    "print(arr3d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 368,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False,  True, False, False, False])"
      ]
     },
     "execution_count": 368,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Important Note: selecting an array by Boolean indexing ALWAYS creates a copy of the data\n",
    "\n",
    "names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])\n",
    "names == 'Bob'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 365,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.99084072 -0.60752412 -0.796238  ]\n",
      " [ 2.72541825 -1.78651605 -0.6950912 ]\n",
      " [-1.09726259 -1.54522844 -0.57216675]\n",
      " [-0.08135472  1.89829076  0.09524627]\n",
      " [-0.2965087   0.98917649 -0.79331886]\n",
      " [-1.94335315  1.87656709 -0.51921007]\n",
      " [ 0.15295558  1.20891556  2.01263155]]\n",
      "\n",
      "\n",
      "[[ 0.99084072 -0.60752412 -0.796238  ]\n",
      " [-0.08135472  1.89829076  0.09524627]]\n"
     ]
    }
   ],
   "source": [
    "# Can pass in the result of a boolean array as a \"mask\" for indexing another array\n",
    "names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])\n",
    "\n",
    "data = np.random.randn(7,3)\n",
    "print(data)\n",
    "print('\\n')\n",
    "print(data[names == 'Bob'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 366,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.9854209   0.54912374  0.29987391]\n",
      " [-0.19152763  1.11921547 -0.53233628]\n",
      " [ 0.20190788  0.04989617  0.06173659]\n",
      " [-1.04175282 -1.32179931  0.21208548]\n",
      " [ 0.48457484 -0.73380653 -0.62347106]\n",
      " [ 0.36791838  0.07333937  1.14508697]\n",
      " [-1.01007257 -0.43941541  0.72437116]]\n",
      "\n",
      "\n",
      "[[-0.19152763  1.11921547 -0.53233628]\n",
      " [ 0.20190788  0.04989617  0.06173659]\n",
      " [ 0.48457484 -0.73380653 -0.62347106]\n",
      " [ 0.36791838  0.07333937  1.14508697]\n",
      " [-1.01007257 -0.43941541  0.72437116]]\n"
     ]
    }
   ],
   "source": [
    "# Can also select everything EXCEPT a certain value by using either != or ~\n",
    "# != for not equal, or ~ to invert the general condition\n",
    "\n",
    "names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])\n",
    "\n",
    "data = np.random.randn(7,3)\n",
    "print(data)\n",
    "print('\\n')\n",
    "print(data[~(names == 'Bob')])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 367,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.38197504  0.17667401 -0.19144414]\n",
      " [-1.20548899 -0.08147095  0.46775268]\n",
      " [ 0.88229245  2.06523931 -0.32767379]\n",
      " [-1.28403643 -0.48097696  1.39069072]\n",
      " [-1.53641005 -0.02794774  1.42355056]\n",
      " [-0.35192579  1.01652372  0.6042608 ]\n",
      " [-0.80301198 -1.44056848 -0.65622103]]\n",
      "\n",
      "\n",
      "[[-0.38197504  0.17667401 -0.19144414]\n",
      " [ 0.88229245  2.06523931 -0.32767379]\n",
      " [-1.28403643 -0.48097696  1.39069072]\n",
      " [-1.53641005 -0.02794774  1.42355056]]\n"
     ]
    }
   ],
   "source": [
    "# Can combine multiple boolean conditions \n",
    "\n",
    "mask = (names == 'Bob') | (names == 'Will')\n",
    "\n",
    "data = np.random.randn(7,3)\n",
    "print(data)\n",
    "print('\\n')\n",
    "print(data[mask])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 370,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.80358771  0.69535344 -2.75945358]\n",
      " [ 0.91022337 -0.75128288 -0.05847357]\n",
      " [-0.35086914  0.7443502   2.23612539]\n",
      " [-0.55913406 -0.06505146 -1.26442435]\n",
      " [-0.0769116  -0.06932083  1.58886348]\n",
      " [-0.8599373  -0.14004944 -0.76572048]\n",
      " [ 0.25006579  0.13833722 -0.82304148]]\n",
      "\n",
      "\n",
      "[[0.80358771 0.69535344 0.        ]\n",
      " [0.91022337 0.         0.        ]\n",
      " [0.         0.7443502  2.23612539]\n",
      " [0.         0.         0.        ]\n",
      " [0.         0.         1.58886348]\n",
      " [0.         0.         0.        ]\n",
      " [0.25006579 0.13833722 0.        ]]\n"
     ]
    }
   ],
   "source": [
    "# Boolean indexing enables setting values in a common-sense way\n",
    "\n",
    "data = np.random.randn(7,3)\n",
    "\n",
    "print(data)\n",
    "print ('\\n')\n",
    "data[data < 0] = 0\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 388,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [12 13 14 15]\n",
      " [16 17 18 19]\n",
      " [20 21 22 23]\n",
      " [24 25 26 27]\n",
      " [28 29 30 31]]\n",
      "\n",
      "\n",
      "[[ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [12 13 14 15]]\n",
      "\n",
      "\n",
      "[[28 29 30 31]\n",
      " [24 25 26 27]\n",
      " [20 21 22 23]]\n",
      "\n",
      "\n",
      "[ 5 10 15]\n"
     ]
    }
   ],
   "source": [
    "# Can also pass in an array as index to access specific rows\n",
    "\n",
    "arr = np.arange(32).reshape(8,4)\n",
    "print(arr)\n",
    "print('\\n')\n",
    "\n",
    "print(arr[[1,2,3]])\n",
    "print('\\n')\n",
    "\n",
    "# Negative indices count backwards\n",
    "\n",
    "print(arr[[-1,-2,-3]])\n",
    "print('\\n')\n",
    "\n",
    "# Can also select specific elements vector-wise by passing in two arrays\n",
    "\n",
    "print(arr[[1,2,3],[1,2,3]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 394,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [12 13 14 15]\n",
      " [16 17 18 19]\n",
      " [20 21 22 23]\n",
      " [24 25 26 27]\n",
      " [28 29 30 31]]\n",
      "\n",
      "\n",
      "[[ 0  4  8 12 16 20 24 28]\n",
      " [ 1  5  9 13 17 21 25 29]\n",
      " [ 2  6 10 14 18 22 26 30]\n",
      " [ 3  7 11 15 19 23 27 31]]\n",
      "\n",
      "\n",
      "[[ 0  4  8 12 16 20 24 28]\n",
      " [ 1  5  9 13 17 21 25 29]\n",
      " [ 2  6 10 14 18 22 26 30]\n",
      " [ 3  7 11 15 19 23 27 31]]\n"
     ]
    }
   ],
   "source": [
    "# Transposing matrices\n",
    "\n",
    "arr = np.arange(32).reshape(8,4)\n",
    "\n",
    "print(arr)\n",
    "print('\\n')\n",
    "\n",
    "# Attribute access\n",
    "print(arr.T)\n",
    "print('\\n')\n",
    "\n",
    "# Method access \n",
    "print(arr.transpose())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1  2  3]\n",
      "  [ 4  5  6  7]]\n",
      "\n",
      " [[ 8  9 10 11]\n",
      "  [12 13 14 15]]]\n",
      "\n",
      "\n",
      "[[[ 0  1  2  3]\n",
      "  [ 8  9 10 11]]\n",
      "\n",
      " [[ 4  5  6  7]\n",
      "  [12 13 14 15]]]\n"
     ]
    }
   ],
   "source": [
    "# For higher dimensional arrays, pass in a tuple of axes to transmute the axes around\n",
    "\n",
    "arr = np.arange(16).reshape(2,2,4)\n",
    "print(arr)\n",
    "print('\\n')\n",
    "\n",
    "# Swap first and second axes and leave third unchanged\n",
    "print(arr.transpose((1, 0, 2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 400,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1  2  3]\n",
      "  [ 4  5  6  7]]\n",
      "\n",
      " [[ 8  9 10 11]\n",
      "  [12 13 14 15]]]\n",
      "\n",
      "\n",
      "[[[ 0  4]\n",
      "  [ 1  5]\n",
      "  [ 2  6]\n",
      "  [ 3  7]]\n",
      "\n",
      " [[ 8 12]\n",
      "  [ 9 13]\n",
      "  [10 14]\n",
      "  [11 15]]]\n"
     ]
    }
   ],
   "source": [
    "# Can also do this by using swapaxes()\n",
    "\n",
    "arr = np.arange(16).reshape(2,2,4)\n",
    "print(arr)\n",
    "print('\\n')\n",
    "\n",
    "# Swap second and third axes and leave first unchanged\n",
    "print(arr.swapaxes(1,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Universal Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vectorized wrappers for simple functions that take scalar values and produce one or more scalar results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 416,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0, 1.0, 1.4142135623730951, 1.7320508075688772, 2.0, 2.23606797749979, 2.449489742783178, 2.6457513110645907, 2.8284271247461903, 3.0]\n",
      "\n",
      "\n",
      "[0.         1.         1.41421356 1.73205081 2.         2.23606798\n",
      " 2.44948974 2.64575131 2.82842712 3.        ]\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# Example: square roots\n",
    "\n",
    "# broke\n",
    "arr = list(range(10))\n",
    "for i in arr:\n",
    "    arr[i] = math.sqrt(i)\n",
    "print(arr)\n",
    "print('\\n')\n",
    "\n",
    "# woke\n",
    "arr2 = np.arange(10)\n",
    "print(np.sqrt(arr2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 423,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.00000000e+00 2.71828183e+00 7.38905610e+00 2.00855369e+01\n",
      " 5.45981500e+01 1.48413159e+02 4.03428793e+02 1.09663316e+03\n",
      " 2.98095799e+03 8.10308393e+03]\n",
      "\n",
      "\n",
      "[ 0.58225565  1.1257346  -0.27893688  0.77840517  0.66229671 -0.95171185\n",
      "  0.79958818  0.17165157]\n",
      "[-0.63171973 -0.76051086  0.84807148  0.62406641  0.57395124  0.33416186\n",
      "  0.83924917  0.83837584]\n",
      "\n",
      " Maximum comparing elements pair-wise\n",
      "[0.58225565 1.1257346  0.84807148 0.77840517 0.66229671 0.33416186\n",
      " 0.83924917 0.83837584]\n"
     ]
    }
   ],
   "source": [
    "# Unary univesral function takes one array:\n",
    "\n",
    "arr = np.arange(10)\n",
    "print(np.exp(arr))\n",
    "print('\\n')\n",
    "\n",
    "# Binary universal function take two arrays:\n",
    "\n",
    "x = np.random.randn(8)\n",
    "y = np.random.randn(8)\n",
    "print(x)\n",
    "print(y)\n",
    "print('\\n Maximum comparing elements pair-wise')\n",
    "print(np.maximum(x,y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 426,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.80150711  1.26671598 -0.16518253 -0.44732526  0.75077277  0.56723895\n",
      "  0.09823023  0.83160117 -0.02592507  1.5583892 ]\n",
      "\n",
      "\n",
      "[ 0.  1. -0. -0.  0.  0.  0.  0. -0.  1.]\n",
      "[ 0.80150711  0.26671598 -0.16518253 -0.44732526  0.75077277  0.56723895\n",
      "  0.09823023  0.83160117 -0.02592507  0.5583892 ]\n"
     ]
    }
   ],
   "source": [
    "# Some unary functions return multiple arrays, like modf which returns a whole number\n",
    "# and the mantissa separately\n",
    "\n",
    "arr = np.random.randn(10)\n",
    "print(arr)\n",
    "print('\\n')\n",
    "\n",
    "remainder, whole = np.modf(arr)\n",
    "print(whole)\n",
    "print(remainder)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 429,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4.55174727e-01, 3.93046376e+00, 6.48962120e-02, 3.56051667e+00,\n",
       "       3.50404068e-01, 2.53101898e-01, 1.86756487e-01, 1.68665258e+00,\n",
       "       2.61721727e-01, 4.05655023e-05])"
      ]
     },
     "execution_count": 429,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can also modify the array inplace by passing in the optional \"out\" argument as below\n",
    "\n",
    "arr = np.random.randn(10)\n",
    "np.square(arr, arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 436,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0., -1.,  1.,  0., -1., -0., -0., -1.,  1., -2.])"
      ]
     },
     "execution_count": 436,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Couple of other cool ufuncs:\n",
    "\n",
    "## Unary\n",
    "\n",
    "arr = np.random.randn(10)\n",
    "\n",
    "### Absolute Value\n",
    "np.abs(arr)\n",
    "\n",
    "### Sign\n",
    "np.sign(arr)\n",
    "\n",
    "### Ceiling/Floor\n",
    "np.ceil(arr)\n",
    "np.floor(arr)\n",
    "\n",
    "### Round to nearest integer, preserving dtype\n",
    "np.rint(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 441,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/alex/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:13: RuntimeWarning: invalid value encountered in power\n",
      "  del sys.path[0]\n",
      "/Users/alex/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:16: RuntimeWarning: invalid value encountered in power\n",
      "  app.launch_new_instance()\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([-0.61722456,  1.974543  , -0.69686473,  1.52165657, -1.59158564,\n",
       "        0.9231509 ,  1.25615265, -1.07470089, -1.13655436,  0.16628311])"
      ]
     },
     "execution_count": 441,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Binary\n",
    "\n",
    "x = np.random.randn(10)\n",
    "y = np.random.randn(10)\n",
    "\n",
    "### All normal ops\n",
    "np.add(x,y)\n",
    "\n",
    "### Floor divide truncates remainder\n",
    "np.floor_divide(x,y)\n",
    "\n",
    "### Raise elements in first array to power in second array\n",
    "np.power(x,y)\n",
    "\n",
    "### Find maximum ignoring nans\n",
    "np.fmax(np.power(x,y), x)\n",
    "\n",
    "### Copy sign from first to second array\n",
    "np.copysign(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array Oriented Programming with Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 442,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Can express many kinds of data processing tasks that would otherwise require writing loops\n",
    "# This is also known as vectorization\n",
    "# These can be 1 to 2 orders of magnitude faster than their Python loop equivalents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 453,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Image plot of $\\\\sqrt{x^2 + y^2}$ for a grid of values')"
      ]
     },
     "execution_count": 453,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Initializes points between -5 and 5 that are 0.01 unit apart\n",
    "\n",
    "points = np.arange(-5, 5, 0.01)\n",
    "\n",
    "# Meshgrid - takes two 1d Arrays and produces 2d matrices\n",
    "\n",
    "xs, ys = np.meshgrid(points,points)\n",
    "\n",
    "z = np.sqrt(xs ** 2 + ys ** 2)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.imshow(z, cmap = plt.cm.gray); plt.colorbar()\n",
    "plt.title(\"Image plot of $\\sqrt{x^2 + y^2}$ for a grid of values\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 459,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.1, 2.2, 1.3]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1.1, 2.2, 1.3])"
      ]
     },
     "execution_count": 459,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# np.where does vectorized boolean logic. It's a vectorized version of the ternary operator\n",
    "\n",
    "xarr = np.array([1.1, 1.2, 1.3])\n",
    "yarr = np.array([2.1, 2.2, 2.3])\n",
    "cond = np.array([True, False, True])\n",
    "\n",
    "# broke: regular Python way using list comprehension\n",
    "\n",
    "result = [(x if c else y) for x, y, c in zip(xarr, yarr, cond)]\n",
    "print(result)\n",
    "\n",
    "# woke: np.where\n",
    "\n",
    "np.where(cond, xarr, yarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 464,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.40987192  0.68733141  0.75501079 -1.65651347]\n",
      " [-0.46524745 -1.77793664 -1.17864626 -0.45193812]\n",
      " [-0.18595984  0.00833783 -0.05003701 -0.99620563]\n",
      " [ 1.49200878 -0.98974185 -0.62553018 -1.03226487]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 1,  1,  1, -1],\n",
       "       [-1, -1, -1, -1],\n",
       "       [-1,  1, -1, -1],\n",
       "       [ 1, -1, -1, -1]])"
      ]
     },
     "execution_count": 464,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can also set the conditionals as scalars instead of arrays as above\n",
    "# Common use is to create an array of binary values based on another integer/float array\n",
    "\n",
    "arr = np.random.randn(4, 4)\n",
    "print(arr)\n",
    "\n",
    "np.where(arr > 0, 1, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 478,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.40840714  0.72491136 -0.20374717  0.3928166 ]\n",
      " [-0.95348087  1.57643703  0.40340016  0.50173684]\n",
      " [ 1.39495501  1.65936494  0.18022209  0.52211958]\n",
      " [-0.16329449  0.63772934 -0.80258272  1.31262021]\n",
      " [ 0.3326436   0.88760157 -0.19515831  0.1206176 ]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.48686597588068825"
      ]
     },
     "execution_count": 478,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can do all the standard statistical tests\n",
    "arr = np.random.randn(5,4)\n",
    "print(arr)\n",
    "\n",
    "arr.mean()\n",
    "# np.mean(arr)\n",
    "# arr.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 480,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.26616366  0.57308777  0.74376568 -0.5056623 ]\n",
      " [-0.45532209 -0.56554769 -0.57347874 -1.25830791]\n",
      " [ 0.23610929  0.24193038  0.20073686  1.89286385]\n",
      " [-0.85044037 -1.07509992 -1.13344462 -0.18286248]\n",
      " [-0.70400752 -0.20288379  0.90647705 -1.16373408]]\n",
      "\n",
      "\n",
      "[ 0.13625687 -0.71316411  0.64291009 -0.81046185 -0.29103708]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([-2.03982434, -1.02851325,  0.14405622, -1.21770292])"
      ]
     },
     "execution_count": 480,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can also pass an axis arg into statistical functions like sum, mean\n",
    "# Axis = 0 means across rows (horizontal) and 1 means down columns (vertical)\n",
    "\n",
    "arr = np.random.randn(5,4)\n",
    "print(arr)\n",
    "print('\\n')\n",
    "\n",
    "print(arr.mean(axis=1))\n",
    "arr.sum(axis=0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 484,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.99603643 -0.46492987  0.87614097  0.83300153]\n",
      " [ 0.15518213 -1.17649808 -1.00257835 -0.01400168]\n",
      " [ 0.42504422  0.23781501 -0.85399174 -1.85706446]\n",
      " [ 1.30760394 -0.97932215 -0.75783393  0.59829109]\n",
      " [-0.64713565  1.66900022 -0.59858836  0.37071977]]\n",
      "\n",
      "\n",
      "0.9154457441523044\n",
      "\n",
      "\n",
      "0.8380409104865663\n",
      "\n",
      "\n",
      "[1 1 3 1 0]\n",
      "\n",
      "\n",
      "[[ 0.99603643 -0.46492987  0.87614097  0.83300153]\n",
      " [ 0.15456705  0.54698909 -0.87839997 -0.01166342]\n",
      " [ 0.06569783  0.13008222  0.75014632  0.02165973]\n",
      " [ 0.08590674 -0.1273924  -0.56848633  0.01295882]\n",
      " [-0.05559332 -0.21261794  0.3402893   0.00480409]]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# More fun statistical methods\n",
    "\n",
    "arr = np.random.randn(5,4)\n",
    "\n",
    "print(arr)\n",
    "print('\\n')\n",
    "\n",
    "# Standard dev\n",
    "print(arr.std())\n",
    "print('\\n')\n",
    "\n",
    "# Variance\n",
    "print(arr.var())\n",
    "print('\\n')\n",
    "\n",
    "# index of minimum element\n",
    "print(arr.argmin(axis=1))\n",
    "print('\\n')\n",
    "\n",
    "# Cumulative product elements starting from one\n",
    "print(arr.cumprod(axis=0))\n",
    "print('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 487,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 487,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Also can use any and all methods which are useful for boolean arrays\n",
    "# any: if a single element returns true then true\n",
    "# all: all elements must be true else false\n",
    "\n",
    "bools = np.array([False, False, True, False])\n",
    "bools.any()\n",
    "# bools.all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 492,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.08827332 -2.67286619 -0.87501483  0.28062443  1.1471085   0.81004806]\n",
      "\n",
      "\n",
      "[-2.67286619 -0.87501483 -0.08827332  0.28062443  0.81004806  1.1471085 ]\n"
     ]
    }
   ],
   "source": [
    "# NumPy sorts in place just like Python's built-in list type\n",
    "\n",
    "arr = np.random.randn(6)\n",
    "print(arr)\n",
    "print('\\n')\n",
    "\n",
    "arr.sort()\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 494,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.09557957  0.33172999 -0.84072901 -0.65668433]\n",
      " [-1.42985634 -0.84860113  0.160659   -0.01146729]\n",
      " [-0.15700323 -0.26076601 -0.80732796 -0.79224539]\n",
      " [-0.77440164 -0.85287871  0.11324937  0.79750901]\n",
      " [-0.26961952 -1.5493747   0.51122451 -0.75107126]\n",
      " [-0.40978908  1.19862851  1.00615331 -0.64133908]]\n",
      "\n",
      "\n",
      "[[-1.42985634 -1.5493747  -0.84072901 -0.79224539]\n",
      " [-0.77440164 -0.85287871 -0.80732796 -0.75107126]\n",
      " [-0.40978908 -0.84860113  0.11324937 -0.65668433]\n",
      " [-0.26961952 -0.26076601  0.160659   -0.64133908]\n",
      " [-0.15700323  0.33172999  0.51122451 -0.01146729]\n",
      " [ 0.09557957  1.19862851  1.00615331  0.79750901]]\n"
     ]
    }
   ],
   "source": [
    "# Can sort along a specific array axis by passing it along as an argument to the sort function\n",
    "\n",
    "arr = np.random.randn(6, 4)\n",
    "print(arr)\n",
    "print('\\n')\n",
    "\n",
    "arr.sort(0)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 497,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3.39763316, -3.09058867, -2.84376505, -2.46219289, -2.42721474,\n",
       "       -2.36265572, -2.35923449, -2.31411643, -2.29611203, -2.18261123,\n",
       "       -2.11424954, -2.07417786, -1.99890194, -1.98623193, -1.97948067,\n",
       "       -1.97512047, -1.97412196, -1.95625138, -1.94984291, -1.94355725,\n",
       "       -1.90693847, -1.90081928, -1.89655587, -1.89170619, -1.87536484,\n",
       "       -1.86271681, -1.85678312, -1.8494662 , -1.83605437, -1.83471249,\n",
       "       -1.82174134, -1.82109277, -1.80535265, -1.79478007, -1.78401711,\n",
       "       -1.77864979, -1.77223274, -1.77045927, -1.74426815, -1.73751231,\n",
       "       -1.69896243, -1.68402763, -1.67979932, -1.67599758, -1.66734957,\n",
       "       -1.65460909, -1.65177347, -1.63693305, -1.63543404, -1.61041206])"
      ]
     },
     "execution_count": 497,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using sort() method to compute quantiles \n",
    "\n",
    "arr = np.random.randn(1000)\n",
    "\n",
    "arr.sort()\n",
    "\n",
    "# Top 5% quantile\n",
    "arr[:int(0.05 * len(arr))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Set Logic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 499,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Alice', 'Bob', 'Mallory'], dtype='<U7')"
      ]
     },
     "execution_count": 499,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# NumPy also has some basic set operations for one-dimensional ndarrays\n",
    "\n",
    "names = np.array(['Alice', 'Alice', 'Bob', 'Mallory'])\n",
    "np.unique(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 500,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True, False])"
      ]
     },
     "execution_count": 500,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test set membership\n",
    "\n",
    "names = np.array(['Alice', 'Alice', 'Bob', 'Mallory'])\n",
    "np.in1d(names, ['Bob'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 503,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Bob'], dtype='<U7')"
      ]
     },
     "execution_count": 503,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set intersection\n",
    "\n",
    "names = np.array(['Alice', 'Alice', 'Bob', 'Mallory'])\n",
    "np.intersect1d(names, ['Bob', 'Charlie'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 504,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Alice', 'Bob', 'Charlie', 'Mallory'], dtype='<U7')"
      ]
     },
     "execution_count": 504,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set Union\n",
    "\n",
    "names = np.array(['Alice', 'Alice', 'Bob', 'Mallory'])\n",
    "np.union1d(names, ['Bob', 'Charlie'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 505,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Alice', 'Mallory'], dtype='<U7')"
      ]
     },
     "execution_count": 505,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set difference, what elements in x that are not in y?\n",
    "\n",
    "names = np.array(['Alice', 'Alice', 'Bob', 'Mallory'])\n",
    "np.setdiff1d(names, ['Bob', 'Charlie'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 507,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Alice', 'Charlie', 'Mallory'], dtype='<U7')"
      ]
     },
     "execution_count": 507,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exclusive Or\n",
    "\n",
    "names = np.array(['Alice', 'Alice', 'Bob', 'Mallory'])\n",
    "np.setxor1d(names, ['Bob', 'Charlie'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Linear Algebra in NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 515,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 28.,  64.],\n",
       "       [ 67., 181.]])"
      ]
     },
     "execution_count": 515,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([[1., 2., 3.], [4., 5., 6.]])\n",
    "y = np.array([[6., 23.], [-1, 7], [8,9]])\n",
    "\n",
    "# Dot product:\n",
    "\n",
    "np.dot(x,y)\n",
    "\n",
    "# OR\n",
    "\n",
    "x.dot(y)\n",
    "\n",
    "# OR\n",
    "\n",
    "x @ y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 526,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2.14510141 -0.3282713  -0.66238075 -1.53041134  0.67516006]\n",
      " [-0.53025864 -0.14769351  1.52694344  0.24126986  0.5224558 ]\n",
      " [ 0.5146995   0.83742665 -1.01865177 -2.09807168  0.7262363 ]\n",
      " [ 0.27696048 -0.01995656  0.86016086  0.83081268 -0.64818474]\n",
      " [ 0.57245795 -1.15831437  0.04902695  0.60492293  0.19691622]]\n",
      "\n",
      "\n",
      "[[ 5.55196506 -0.86344985 -2.48855196 -3.91430416  1.47824825]\n",
      " [-0.86344985  2.17294926 -0.93507966 -2.0074961   0.09421529]\n",
      " [-2.48855196 -0.93507966  4.5502363   4.26361495 -0.9371234 ]\n",
      " [-3.91430416 -2.0074961   4.26361495  7.85845625 -2.85031656]\n",
      " [ 1.47824825  0.09421529 -0.9371234  -2.85031656  1.71513979]]\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 1.00000000e+00,  2.28640477e-13,  5.84908353e-15,\n",
       "         3.07570388e-14, -7.66100880e-14],\n",
       "       [-5.08634071e-14,  1.00000000e+00, -6.06905820e-14,\n",
       "        -2.07876005e-13,  1.66914027e-13],\n",
       "       [-7.58978242e-14, -1.38110711e-13,  1.00000000e+00,\n",
       "        -1.02213182e-13,  1.33450288e-13],\n",
       "       [-2.07152338e-14, -2.80536410e-13,  3.05824464e-14,\n",
       "         1.00000000e+00, -4.30438517e-13],\n",
       "       [ 6.30450128e-14,  1.86503112e-13, -2.64121142e-14,\n",
       "         7.02921035e-14,  1.00000000e+00]])"
      ]
     },
     "execution_count": 526,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Lots of other linear algebra operations built in but need to import from linalg\n",
    "\n",
    "from numpy.linalg import inv\n",
    "\n",
    "X = np.random.randn(5,5)\n",
    "print(X)\n",
    "print('\\n')\n",
    "\n",
    "mat = X.T.dot(X)\n",
    "print(mat)\n",
    "print('\\n')\n",
    "\n",
    "mat @ inv(mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 527,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Can do a bunch of other things like compute eigenvalues/vectors and solve linear systems of equations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pseudorandom Number Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 528,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set seed for the NumPy PRG\n",
    "\n",
    "np.random.seed(122)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 529,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 3, 4, 2])"
      ]
     },
     "execution_count": 529,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return a random permutation of a sequence\n",
    "\n",
    "np.random.permutation(np.arange(5))\n",
    "\n",
    "# Can also use the shuffle() method to permute a sequence in place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 532,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 532,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Draw a random integer from a low to high range\n",
    "\n",
    "np.random.randint(0,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 536,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.75083009, 0.03643402],\n",
       "       [0.80440182, 0.98476786]])"
      ]
     },
     "execution_count": 536,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Draw from a uniform distribution\n",
    "\n",
    "np.random.rand(2, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 538,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.30535918,  0.05131981],\n",
       "       [-0.12902871, -0.43419166]])"
      ]
     },
     "execution_count": 538,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Draw from a standard normal distribution (mean of 0, stdev of 1)\n",
    "\n",
    "np.random.randn(2, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 541,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([8.47377764, 6.26367684])"
      ]
     },
     "execution_count": 541,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Draw from a Gaussian normal distribution (mean, stdev, sample size)\n",
    "\n",
    "np.random.normal(10, 2, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Fun Application: Random Walks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 543,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1218022e8>]"
      ]
     },
     "execution_count": 543,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Pure Python\n",
    "\n",
    "import random\n",
    "position = 0\n",
    "walk = [position]\n",
    "steps = 1000\n",
    "for i in range(steps):\n",
    "    step = 1 if random.randint(0,1) else -1\n",
    "    position += step\n",
    "    walk.append(position)\n",
    "    \n",
    "plt.plot(walk[:100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 551,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x10f5b1128>]"
      ]
     },
     "execution_count": 551,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# NumPy Way\n",
    "\n",
    "nsteps = 1000\n",
    "draws = np.random.randint(0,2, size = nsteps)\n",
    "steps = np.where(draws > 0, 1, -1)\n",
    "\n",
    "walk = steps.cumsum()\n",
    "plt.plot(walk[:100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 554,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-18 12\n"
     ]
    }
   ],
   "source": [
    "# Can also extract statistics \n",
    "print(walk.min(), walk.max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 561,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ -1,  -2,  -3, ...,  12,  13,  14],\n",
       "       [ -1,  -2,  -3, ..., -14, -13, -14],\n",
       "       [  1,   2,   1, ..., -12, -13, -14],\n",
       "       ...,\n",
       "       [  1,   2,   1, ...,   8,   7,   8],\n",
       "       [ -1,   0,   1, ...,   4,   3,   2],\n",
       "       [ -1,  -2,  -3, ...,  -8,  -7,  -6]])"
      ]
     },
     "execution_count": 561,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can create many random walks by making the array 2d\n",
    "\n",
    "nwalks = 100\n",
    "nsteps = 50\n",
    "\n",
    "draws = np.random.randint(0,2, size = (nwalks, nsteps))\n",
    "steps = np.where(draws > 0, 1, -1)\n",
    "walks = steps.cumsum(1)\n",
    "walks\n",
    "\n",
    "# each row corresponds to a random walk"
   ]
  },
  {
   "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}