T2 - Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "np.random.seed(22) # dore reproducibility "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.02 Data Types in Python\n",
    "## Lists \n",
    "Inside [.....], can be a mix of diff data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n",
       " ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],\n",
       " [True, '2', 3.14])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L1 = list(range(10)) \n",
    "L2 = [str(c) for c in L1]\n",
    "L3 = [True, \"2\", 3.14] \n",
    "L1, L2, L3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays \n",
    "Inside (...), created from lists or separately\n",
    "- ```np.zeros(# values or 2d shape, dtype = optional)```\n",
    "- ```np.ones(same as above)```\n",
    "- ```np.full(2d or 1d shape or #values, specific value```\n",
    "- ```np.arange(min,max,multiple)``` linear sequence of values\n",
    "- ```np.linspace(min, max, size)``` equal spaced array \n",
    "- ```np.random.randomint(min, max, size)``` random integers\n",
    "- ```np.random.random(), np.random.uniform()``` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3.], dtype=float32)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1, 2, 3]) \n",
    "np.array([1.2, 2.5, 3])   # makes all floats\n",
    "a = np.array([1, 2, 3], dtype = 'float32' ) # set float to all \n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),\n",
       " array([[1., 1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1., 1.]], dtype=float32),\n",
       " array([[3.14, 3.14],\n",
       "        [3.14, 3.14]]))"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# array of zeros\n",
    "a = np.zeros(10, dtype = int)\n",
    "\n",
    "# 2d array of 1s\n",
    "b = np.ones((3,5), dtype = 'float32')\n",
    "\n",
    "# 2d array with specific value\n",
    "c = np.full((2,2), 3.14)\n",
    "\n",
    "a,b,c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18]),\n",
       " array([0.  , 0.25, 0.5 , 0.75, 1.  ]),\n",
       " array([[0.006923  , 0.52932467, 0.85879979, 0.39514363]]),\n",
       " array([0.38921451, 0.13445913, 0.4113644 , 0.38345878, 0.54459096]),\n",
       " array([0, 1, 2, 0, 0, 4, 3, 3, 4, 4]))"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Array with linear sequence\n",
    "a = np.arange(0,20,2) \n",
    "\n",
    "# Array between 0 and 1 with 5 values\n",
    "b = np.linspace(0,1,5) \n",
    "\n",
    "# Array with uniformly distributed rand values between [0,1]\n",
    "c = np.random.random((1,4))\n",
    "\n",
    "# Normal distn --- (min, max, # values)\n",
    "d = np.random.uniform(0,1,5)\n",
    "\n",
    "# Random values (low, high, size, dtype)\n",
    "e = np.random.randint(0,5,10)\n",
    "\n",
    "# identity matrix\n",
    "np.eye(3) \n",
    "\n",
    "a,b,c,d,e\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.03 Basics of Numpy\n",
    "``` x.ndim, x.shape, x.size, x.dtype, x.itemsize, x.nbytes```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1 = np.random.randint(10, size=6)  # One-dimensional array\n",
    "x2 = np.random.randint(10, size=(3, 4))  # Two-dimensional array\n",
    "x3 = np.random.randint(10, size=(3, 4, 5))  # Three-dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x3 ndim:  3\n",
      "x3 shape: (3, 4, 5)\n",
      "x3 size:  60\n",
      "dtype: int32\n",
      "itemsize: 4 bytes\n",
      "nbytes: 240 bytes\n"
     ]
    }
   ],
   "source": [
    "# Info about the array\n",
    "\n",
    "print(\"x3 ndim: \", x3.ndim)\n",
    "print(\"x3 shape:\", x3.shape)\n",
    "print(\"x3 size: \", x3.size)\n",
    "print(\"dtype:\", x3.dtype)\n",
    "print(\"itemsize:\", x3.itemsize, \"bytes\")\n",
    "print(\"nbytes:\", x3.nbytes, \"bytes\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x1 array:  [8 3 5 1 3 3]\n",
      "std way:  8 3\n",
      "from the end: 3 3\n",
      "[[7 4 3 0]\n",
      " [6 5 0 0]\n",
      " [9 3 6 2]]\n",
      "access row 0, col 3:  7\n"
     ]
    }
   ],
   "source": [
    "print(\"x1 array: \", x1) \n",
    "print(\"std way: \", x1[0], x1[1]) \n",
    "print(\"from the end:\", x1[-1], x1[-2]) # print from the end \n",
    "print(x2) \n",
    "print(\"access row 0, col 3: \", x2[0,0])\n",
    "\n",
    "# can modify values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing arrays\n",
    "- Note that if you modify the subset array, the main array is changed as well. To avoid that make a copy with ```x.copy()```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "first 5:  [0 1 2 3 4]\n",
      "last 5:  [5 6 7 8 9]\n",
      "index 1 to 5:  [1 2 3 4]\n",
      "every other element:  [0 2 4 6 8]\n",
      "every other element from index 5:  [5 7 9]\n",
      "reverse array:  [9 8 7 6 5 4 3 2 1 0]\n",
      "reverse array from index 5:  [5 4 3 2 1 0]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(10) \n",
    "print(x) \n",
    "print(\"first 5: \", x[:5])\n",
    "print(\"last 5: \", x[5:]) \n",
    "print(\"index 1 to 5: \", x[1:5]) \n",
    "print(\"every other element: \", x[::2]) \n",
    "print(\"every other element from index 5: \", x[5::2]) \n",
    "print(\"reverse array: \", x[::-1]) \n",
    "print(\"reverse array from index 5: \", x[5::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x2 \n",
      " [[7 4 3 0]\n",
      " [6 5 0 0]\n",
      " [9 3 6 2]] \n",
      "\n",
      "all rows and col 2:  [3 0 6]\n",
      "all cols and row 2:  [9 3 6 2]\n",
      "subset x2_sub: \n",
      " [[7 4]\n",
      " [6 5]]\n",
      "copy of subset x2_sub_copy: \n",
      " [[7 4]\n",
      " [6 5]]\n",
      "copy of subset with value changed: \n",
      " [[100   4]\n",
      " [  6   5]]\n",
      "x2 not impacted: \n",
      " [[7 4 3 0]\n",
      " [6 5 0 0]\n",
      " [9 3 6 2]]\n"
     ]
    }
   ],
   "source": [
    "# similar for 2d arrays\n",
    "print(\"x2 \\n\", x2, \"\\n\")\n",
    "print(\"all rows and col 2: \",x2[:,2])\n",
    "print(\"all cols and row 2: \",x2[2,:]) \n",
    "x2_sub = x2[0:2,0:2]\n",
    "print(\"subset x2_sub: \\n\", x2_sub) \n",
    "\n",
    "# Note that if you modify the subset array, the main array is changed as well\n",
    "# To avoid that make a copy \n",
    "x2_sub_copy = x2[0:2,0:2].copy()\n",
    "print(\"copy of subset x2_sub_copy: \\n\", x2_sub_copy) \n",
    "\n",
    "# change value in copied subset and check that main x2 not impacted\n",
    "x2_sub_copy[0,0] = 100\n",
    "print(\"copy of subset with value changed: \\n\", x2_sub_copy) \n",
    "print(\"x2 not impacted: \\n\", x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshaping arrays\n",
    "Many diff options - refer to book <br>\n",
    "```x.reshape(3,4)``` shape an array into (3,4) matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3]])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid = np.arange(1, 10).reshape((3, 3))\n",
    "print(grid)\n",
    "\n",
    "x = np.array([1, 2, 3])\n",
    "\n",
    "# row vector via reshape\n",
    "x.reshape((1, 3))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array concatenation and splitting\n",
    "```np.concatenate``` takes a tuple or list of arrays as its first argument <br>\n",
    "```np.vstack``` and ```np.hstack``` are vertical and horizontal stacks used for arrays with mixed dimensions <br>\n",
    "```np.split```, ```np.hsplit```, and ```np.vsplit``` are used to split arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1, 2, 3])\n",
    "y = np.array([10, 20, 30])\n",
    "z = [99, 99, 99]\n",
    "\n",
    "# Concatenate in row\n",
    "np.concatenate([x, y, z])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid = np.array([[1, 2, 3],\n",
    "                 [4, 5, 6]])\n",
    "np.concatenate([grid, grid])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [9, 8, 7],\n",
       "       [6, 5, 4]])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1, 2, 3])\n",
    "grid = np.array([[9, 8, 7],\n",
    "                 [6, 5, 4]])\n",
    "\n",
    "# vertically stack the arrays\n",
    "np.vstack([x, grid])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 9,  8,  7, 99],\n",
       "       [ 6,  5,  4, 99]])"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# horizontally stack the arrays\n",
    "y = np.array([[99],\n",
    "              [99]])\n",
    "np.hstack([grid, y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3] [99 99] [3 2 1]\n"
     ]
    }
   ],
   "source": [
    "# Splitting at specificed indices \n",
    "x = [1, 2, 3, 99, 99, 3, 2, 1]\n",
    "x1, x2, x3 = np.split(x, [3, 5])\n",
    "print(x1, x2, x3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "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",
      "\n",
      "Upper \n",
      " [[0 1 2 3]\n",
      " [4 5 6 7]] \n",
      " Lower \n",
      " [[ 8  9 10 11]\n",
      " [12 13 14 15]] \n",
      "\n",
      "Left \n",
      " [[ 0  1]\n",
      " [ 4  5]\n",
      " [ 8  9]\n",
      " [12 13]] \n",
      " Right \n",
      " [[ 2  3]\n",
      " [ 6  7]\n",
      " [10 11]\n",
      " [14 15]]\n"
     ]
    }
   ],
   "source": [
    "grid = np.arange(16).reshape((4, 4))\n",
    "print(grid, \"\\n\" )\n",
    "\n",
    "upper, lower = np.vsplit(grid, [2])\n",
    "print(\"Upper \\n\", upper, \"\\n\",\n",
    "      \"Lower \\n\", lower, \"\\n\")\n",
    "\n",
    "left, right = np.hsplit(grid, [2])\n",
    "print(\"Left \\n\", left, \"\\n\",\n",
    "      \"Right \\n\", right)\n",
    "      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.03 Computation of Numpy arrays - Ufuncs\n",
    "- Absolute values, trigs, exp and power, logs\n",
    "- Specialized functions such as gamma, beta, etc (review book)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "absolute value:  [2 1 0 1 2]\n",
      "theta      =  [0.         1.57079633 3.14159265]\n",
      "sin(theta) =  [0.0000000e+00 1.0000000e+00 1.2246468e-16]\n",
      "cos(theta) =  [ 1.000000e+00  6.123234e-17 -1.000000e+00]\n",
      "tan(theta) =  [ 0.00000000e+00  1.63312394e+16 -1.22464680e-16]\n",
      "\n",
      "\n",
      "x         =  [-1, 0, 1]\n",
      "arcsin(x) =  [-1.57079633  0.          1.57079633]\n",
      "arccos(x) =  [3.14159265 1.57079633 0.        ]\n",
      "arctan(x) =  [-0.78539816  0.          0.78539816]\n",
      "\n",
      "\n",
      "x     = [1, 2, 3]\n",
      "e^x   = [ 2.71828183  7.3890561  20.08553692]\n",
      "2^x   = [2. 4. 8.]\n",
      "3^x   = [ 3  9 27]\n",
      "\n",
      "\n",
      "x        = [1, 2, 4, 10]\n",
      "ln(x)    = [0.         0.69314718 1.38629436 2.30258509]\n",
      "log2(x)  = [0.         1.         2.         3.32192809]\n",
      "log10(x) = [0.         0.30103    0.60205999 1.        ]\n"
     ]
    }
   ],
   "source": [
    "np.arange(4)\n",
    "x = np.array([-2, -1, 0, 1, 2])\n",
    "theta = np.linspace(0, np.pi, 3)\n",
    "\n",
    "print(\"absolute value: \", abs(x))\n",
    "print(\"theta      = \", theta)\n",
    "print(\"sin(theta) = \", np.sin(theta))\n",
    "print(\"cos(theta) = \", np.cos(theta))\n",
    "print(\"tan(theta) = \", np.tan(theta))\n",
    "print(\"\\n\")\n",
    "\n",
    "x = [-1, 0, 1]\n",
    "print(\"x         = \", x)\n",
    "print(\"arcsin(x) = \", np.arcsin(x))\n",
    "print(\"arccos(x) = \", np.arccos(x))\n",
    "print(\"arctan(x) = \", np.arctan(x))\n",
    "print(\"\\n\")\n",
    "\n",
    "x = [1, 2, 3]\n",
    "print(\"x     =\", x)\n",
    "print(\"e^x   =\", np.exp(x))\n",
    "print(\"2^x   =\", np.exp2(x))\n",
    "print(\"3^x   =\", np.power(3, x))\n",
    "print(\"\\n\")\n",
    "\n",
    "x = [1, 2, 4, 10]\n",
    "print(\"x        =\", x)\n",
    "print(\"ln(x)    =\", np.log(x))\n",
    "print(\"log2(x)  =\", np.log2(x))\n",
    "print(\"log10(x) =\", np.log10(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.04 Aggregations: Min, max, and others\n",
    "Note that python has built in sum, mean, etc functions, so make sure to use only np.functions\n",
    "- ```np.min(a), np.max(a), np.sum(a)```\n",
    "- ```a.min(), a.max(), a.sum(), a.mean, a.std``` shorter version\n",
    "- ```a.mean(0) or a.mean(1)``` mean of rows or columns\n",
    "- ```np.count(a), np.count_nonzero(a)```\n",
    "- ```a.argmax(), a.argmin()``` gives index with max/min values\n",
    "- ```a.any(), a.all()``` whether any or all are true\n",
    "- ```a.nanmin(), a.nanmax(), a.nansum(), a.nanmean, a.nanstd``` missing values version\n",
    "- https://github.com/SBalas/PythonDataScienceHandbook/blob/599aa0fe3f882c0001670e676e5a8d43b92c35fc/notebooks/02.04-Computation-on-arrays-aggregates.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  8  6]\n",
      " [ 9 11  9]\n",
      " [16  8  5]]\n",
      "Max across each col [16 11  9] \n",
      "\n",
      "Max across each row [ 8 11 16] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "M = np.random.random((3, 4))\n",
    "M = np.random.randint(0,20, (3,3))\n",
    "print(M)\n",
    "print(\"Max across each col\", M.max(axis = 0), \"\\n\")\n",
    "print(\"Max across each row\", M.max(axis = 1), \"\\n\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.05 Computation on arrays - Broadcasting\n",
    "Broadcasting is simply a set of rules for applying binary ufuncs (e.g., addition, subtraction, multiplication, etc.) on arrays of different sizes.\n",
    "- Rule 1: If the two arrays differ in their number of dimensions, the shape of the one with fewer dimensions is padded with ones on its leading (left) side.\n",
    "- Rule 2: If the shape of the two arrays does not match in any dimension, the array with shape equal to 1 in that dimension is stretched to match the other shape.\n",
    "- Rule 3: If in any dimension the sizes disagree and neither is equal to 1, an error is raised.\n",
    "\n",
    "Applications - centering means, plotting 2d heat maps\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2] [5 5 5] [5 6 7] [5 6 7] \n",
      " [[1. 2. 3.]\n",
      " [1. 2. 3.]\n",
      " [1. 2. 3.]] \n",
      "\n",
      "[0 1 2] \n",
      " [[0]\n",
      " [1]\n",
      " [2]] \n",
      " [[0 1 2]\n",
      " [1 2 3]\n",
      " [2 3 4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([0, 1, 2])\n",
    "b = np.array([5, 5, 5])\n",
    "M = np.ones((3, 3))\n",
    "print(a, b, a+5, a + b, \"\\n\", M + a, \"\\n\") # adding 1d gets added to each row of the 2d array\n",
    "\n",
    "a = np.arange(3)\n",
    "b = np.arange(3)[:, np.newaxis]\n",
    "print(a, \"\\n\", b, \"\\n\", a+b) # add single row to single col array --- both row and col values are broadcast across rows and cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-9.99200722e-17, -6.66133815e-17,  4.44089210e-17])"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Centring an array\n",
    "X = np.random.random((10,3))\n",
    "Xmean = X.mean(0)  # mean of rows\n",
    "Xmean\n",
    "X_center = X - Xmean\n",
    "X_center.mean(0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.06 Comparisons, Masks, and Boolean Logic\n",
    "``` > < != == & |``` <br><br>\n",
    "Using the Keywords and/or Versus the Operators &/| --- and/or operates on the entire object while the other two operate on the bits/entities of the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "median of rainy days 0.19488188976377951\n",
      "median of summer days 0.0\n",
      "max of summer days 0.8503937007874016\n",
      "median of rainy non summer days 0.20078740157480315\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "# use pandas to extract rainfall inches as a NumPy array\n",
    "rainfall = pd.read_csv('data/Seattle2014.csv')['PRCP'].values\n",
    "inches = rainfall / 254.0  # 1/10mm -> inches\n",
    "\n",
    "# mask of all rainy days\n",
    "rainy = (inches > 0)\n",
    "\n",
    "# construct a mask of all summer days (June 21st is the 172nd day)\n",
    "days = np.arange(365)\n",
    "summer = (days > 172) & (days < 262)\n",
    "\n",
    "print(\"median of rainy days\", np.median(inches[rainy]))\n",
    "print(\"median of summer days\", np.median(inches[summer]))\n",
    "print(\"max of summer days\", np.max(inches[summer]))\n",
    "print(\"median of rainy non summer days\", np.median(inches[rainy & ~summer]) )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A | B =  [ True  True  True False  True  True]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False,  True,  True,  True, False,\n",
       "       False])"
      ]
     },
     "execution_count": 255,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Boolean values in arrays\n",
    "A = np.array([1, 0, 1, 0, 1, 0], dtype=bool)\n",
    "B = np.array([1, 1, 1, 0, 1, 1], dtype=bool)\n",
    "\n",
    "print (\"A | B = \", A | B)\n",
    "# A and B will give an error since cannot compare the entire arrays\n",
    "\n",
    "# on arrays\n",
    "x = np.arange(10)\n",
    "(x > 4) & (x < 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.07 Fancy indexing\n",
    "Fancy indexing is like the simple indexing we've already seen, but we pass arrays of indices in place of single scalars. This allows us to very quickly access and modify complicated subsets of an array's values.\n",
    "\n",
    "- Selecting random points\n",
    "- Modify values with fancy index\n",
    "- Binning data ---- review plotting histogram with custom function\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[51 92 14 71 60 20 82 86 74 74]\n",
      "[14 20 74]\n"
     ]
    }
   ],
   "source": [
    "rand = np.random.RandomState(42)\n",
    "\n",
    "x = rand.randint(100, size=10)\n",
    "print(x)\n",
    "\n",
    "# Prints the values given by these indices\n",
    "ind = [2,5,8]\n",
    "print(x[ind])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 2,  5, 11])"
      ]
     },
     "execution_count": 268,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.arange(12).reshape((3, 4))\n",
    "print(X)\n",
    "\n",
    "row = np.array([0, 1, 2])\n",
    "col = np.array([2, 1, 3])\n",
    "X[row, col]  # take r0 c2, r1 c1, r2 c3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10  8  9] \n",
      "\n",
      "[[ 6  4  5]\n",
      " [10  8  9]] \n",
      "\n",
      "[[ 0  2]\n",
      " [ 4  6]\n",
      " [ 8 10]]\n"
     ]
    }
   ],
   "source": [
    "# Combime fancy and simple index\n",
    "print(X[2, [2, 0, 1]], \"\\n\") # row 2 col 2, row 2 col 0, row 2 col 1\n",
    "\n",
    "# Fancy indexing with slicing\n",
    "print(X[1:, [2, 0, 1]],\"\\n\") # rows 2 and 3 of X with cols 2,0,1\n",
    "\n",
    "# Fancy indexing with masking\n",
    "mask = np.array([1, 0, 1, 0], dtype=bool)\n",
    "print(X[row[:, np.newaxis], mask])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.08 Sorting Arrays\n",
    "- ``` np.sort(x) ``` sorts values but doesn't change the array\n",
    "- ```np.argsort(x)``` returns indices of the sorted array\n",
    "- ```x.sort()``` sorts and changes the array\n",
    "- Can sort each col and row by using axis = 0,1 respectively\n",
    "- Partition sort: ```np.partition(array, k)``` doesn't sort but gives the k smallest values to the left and the rest to the right. There is also ```np.argpartition( )``` which works on the indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "[1 0 3 2 4]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([2, 1, 4, 3, 5])\n",
    "print(np.sort(x))\n",
    "print(np.argsort(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[6 3 7 4]\n",
      " [6 9 2 6]\n",
      " [7 4 3 7]] \n",
      "\n",
      "[[6 3 2 4]\n",
      " [6 4 3 6]\n",
      " [7 9 7 7]] \n",
      "\n",
      "[[3 4 6 7]\n",
      " [2 6 6 9]\n",
      " [3 4 7 7]]\n"
     ]
    }
   ],
   "source": [
    "rand = np.random.RandomState(42)\n",
    "X = rand.randint(0, 10, (3, 4))\n",
    "print(X, \"\\n\")\n",
    "print(np.sort(X, axis = 0), \"\\n\") # sorts each column\n",
    "print(np.sort(X, axis = 1)) # sorts each row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 1, 3, 4, 6, 5, 7])"
      ]
     },
     "execution_count": 289,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Partition sort - moves the k smallest values to the left\n",
    "x = np.array([7, 2, 3, 1, 6, 5, 4])\n",
    "np.partition(x, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  k nearest neighbors example\n",
    "Review it later... lot of complex broadcasting functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x2715678ffa0>"
      ]
     },
     "execution_count": 296,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAD7CAYAAAB+B7/XAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAYu0lEQVR4nO3df3BU9f3v8dfuSsRVOmTCbvbayTgdOt+oYSN0JAVqoVjdlMhPoVOLwJ1BQZo6GTNzrQww4tCxpdoZ7LTNd0ynrV9v4Ran1QD/JJEywtTsbaCdGpL6o+jMNVNIdklSBZKYcPZz//DLagjkbCC75+zJ8zHjH8fzmfhyXV58+Lhn3z5jjBEAwDP8TgcAAEwsih0APIZiBwCPodgBwGModgDwGIodADyGYgcAj7nB6QCS1Nd3QalUZh+nLyq6RT0957OcKDvI7gyyO4Ps2eP3+1RYePNV77ui2FMpk3GxX1qfr8juDLI7g+zO4CgGADyGYgcAj3HFUQyAq0v09auptVPxji4NDlmaWhDQ/LKIKitKFC4MOh0PLkSxAy524u1u/fi/WmVZRtZ/n/kODlk69tZpvdl+RtUroyqfWeRwSrgNRzGASyX6+rX7v45raDiVLvVLrJTR0HBKdQ0nlejrdygh3IpiB1yqqbVTF63UmGssy6j5eGeOEiFfUOyAS8U7ukbt1C9npYzi7V05SoR8QbEDLjU4ZE3oOkweFDvgUlMLAhO6DpMHxQ641PyyiAJ+35hrAn6f5s+K5CgR8gXFDrhUZUWJbgiM/Us0EPApNrckR4mQLyh2wKXChUFt/Z9zVTDFP2rnHvD7VDDFr+qVUR5Swig8oAS42N13FGvXxgo1H+9UvP1zT57Oiig2lydPcWUUO+By4cKg1sVKtS5W6nQU5AmOYgDAYyh2APAYih0APIZiBwCPodgBwGModgDwGIodADyGYgcAj6HYAcBjKHYA8BiKHQA8hmIHAI+h2AHAYzIq9kOHDqmqqkqxWEx79+4ddb+jo0OrV6/W8uXL9dhjj+njjz+e8KAAgMzYFnt3d7f27Nmjffv2qaGhQfv379epU6dGrHn22WdVU1OjgwcP6ktf+pJ+/etfZy0wAGBstsXe0tKiefPmafr06QoGg6qsrFRjY+OINalUShcuXJAkDQwMaOrUqdlJCwCwZVvsiURCoVAofR0Oh9Xd3T1izdatW7Vjxw7dc889amlp0UMPPTTxSQEAGbGdoJRKpeTzfTZv0Rgz4npwcFDbt2/XSy+9pPLycv32t7/VU089pfr6+oxDFBXdMq7QodC0ca13E7I7g+zOILszbIs9EonoxIkT6etkMqlwOJy+fu+993TjjTeqvLxckvSd73xHP/vZz8YVoqfnvFIpk9HaUGiakslz4/r5bkF2Z5B9bIm+fjW1dire8bmZqmURVVZc30xVXvfs8ft9Y26IbY9iFixYoHg8rt7eXg0MDKi5uVkLFy5M37/tttvU1dWlDz74QJL0pz/9SdFodAKiA8i2tvd79PRvWnXsrdMaHLIkSYNDlo69dVpP/6ZVbe/3OJwQ18J2x15cXKza2lpt2LBBw8PDWrNmjcrLy7Vp0ybV1NQoGo3qxz/+sZ544gkZY1RUVKQf/ehHucgO4Dok+vpV13BSQ8OpUfeslJGVMqprOKldGyuua+eO3PMZYzI7A8kijmLcj+zOyGb2/930ro69dVrWGL/2An6fFs2+VetipeP++V553bN1VHU9rvsoBoA3xTu6xix16dOde7y9K0eJ3Cdfj6oodmCSulRUE7XOaz5/VHX5b4BWymhoOKW6hpNK9PU7lPDqKHZgkppaEJjQdV7T1Nopy7L5E41l1Hy8M0eJMkexA5PU/LKIAn7fmGsCfp/mz4rkKJG75PNRFcUOTFKVFSUKBGyKPeBTbG5JjhK5Sz4fVVHswCQVLgyqemVUBVP8o3buAb9PBVP8ql4ZnbQfdcznoyqKHZjEymcWadfGCi2afatuKgjIJ+mmgoAWzb5VuzZWqHxmkdMRHZPPR1W2DygB8LZwYVDrYqXX9Fl1L6usKNGb7WfG/py/S4+q2LEDwBXk81EVO3YAuIpLR1XNxzsVb//ck6ezIorNde7JUzsUOwCMIR+PqjiKAQCPodgBwGModgDwGIodADyGYgcAj6HYAcBjKHYA8BiKHQA8hmIHAI+h2AHAYyh2APAYih0APIZiBwCPodgBwGModgDwGIodADyGYgcAj6HYAcBjKHYA8BiKHQA8hmIHAI+h2AHAYyh2APAYih0APIZiBwCPyajYDx06pKqqKsViMe3du3fU/Q8++EDr16/X8uXL9cgjj+ijjz6a8KAAgMzYFnt3d7f27Nmjffv2qaGhQfv379epU6fS940x+t73vqdNmzbp4MGDuuOOO1RfX5/V0ACAq7Mt9paWFs2bN0/Tp09XMBhUZWWlGhsb0/c7OjoUDAa1cOFCSdKWLVv08MMPZy8xAGBMtsWeSCQUCoXS1+FwWN3d3enrDz/8UDNmzNC2bdu0atUq7dy5U8FgMDtpAQC2brBbkEql5PP50tfGmBHXFy9eVGtrq373u98pGo3qhRde0O7du7V79+6MQxQV3TKu0KHQtHGtdxOyO4PsziC7M2yLPRKJ6MSJE+nrZDKpcDicvg6FQrrtttsUjUYlSUuXLlVNTc24QvT0nFcqZTJaGwpNUzJ5blw/3y3I7gyyO4Ps2eP3+8bcENsexSxYsEDxeFy9vb0aGBhQc3Nz+jxdkubMmaPe3l698847kqQjR46orKxsAqIDAK6F7Y69uLhYtbW12rBhg4aHh7VmzRqVl5dr06ZNqqmpUTQa1S9/+Uvt2LFDAwMDikQieu6553KRHQBwBT5jTGZnIFnEUYz7kd0ZZHeG27Nf91EMACC/UOwA4DEUOwB4DMUOAB5DsQOAx1DsAOAxFDsAeIztA0oAsi/R16+m1k7FO7o0OGRpakFA88si+u637uAXKcaN9wzgsLb3e1TXcFKWZWT994N6g0OWjr11Wi3tXfreylkqn1nkcErkE45iAAcl+vpV13BSQ8OpdKlfYqWMPhm2VNdwUom+focSIh9R7ICDmlo7ZVljf52GZRk1H+/MUSJ4AcUOOCje0TVqp345K2UUb+/KUSJ4AcUOOGhwyJrQdYBEsQOOmloQmNB1gESxA46aXxZRwO8bc03A79P8WZEcJYIXUOyAgyorShQI2BR7wKfY3JIcJYIXUOyAg8KFQVWvjKpgin/Uzj3g9+nGKQFVr4wqXBh0KCHyEQ8oAQ4rn1mkXRsr1Hy8U/H2zz15Oiuihyrv0A0m5XRE5BmKHXCBcGFQ62KlWhcrHfH3QzNudvWINrgTRzEA4DEUOwB4DMUOAB5DsQOAx1DsAOAxFDsAeAzFDgAeQ7EDgMdQ7ADgMRQ7AHgMxQ4AHkOxA4DHUOwA4DF8u2MeS/T1q6m1U/GOz33Va1lElRUlfH83MIlR7Hmq7f0e1TWclGWZ9JT7wSFLx946rTfbz6h6ZVTlM4scTgnACRzF5KFEX7/qGk5qaDiVLvVLrJTR0HBKdQ0nlejrdyghACdR7HmoqbVTlmXGXGNZRs3HO3OUCICbZFTshw4dUlVVlWKxmPbu3XvVdW+88YbuvffeCQuHK4t3dI3aqV/OShnF27tylAiAm9iesXd3d2vPnj169dVXVVBQoIceekhf/epX9eUvf3nEurNnz+onP/lJ1oLiM4ND1oSuA+Attjv2lpYWzZs3T9OnT1cwGFRlZaUaGxtHrduxY4cef/zxrITESFMLAhO6DoC32O7YE4mEQqFQ+jocDqutrW3Empdffll33nmn7rrrrmsKUVR0y7jWh0LTrumf4wYTkX3x3SVq/r//b8zjmIDfp3vnlkzoazXZX3enkN0Z+ZzdtthTqZR8Pl/62hgz4vq9995Tc3OzXnrpJXV1XduZbk/PeaVszowvCYWm5e3U9onKviga0Z+Ofzh2sQd8+vqsyIS9VrzuziC7M9ye3e/3jbkhtj2KiUQiSiaT6etkMqlwOJy+bmxsVDKZ1OrVq7V582YlEgmtXbv2OmNjLOHCoKpXRlUwxa+A3zfiXsDvU8EUv6pXRnlICZikbIt9wYIFisfj6u3t1cDAgJqbm7Vw4cL0/ZqaGjU1NenAgQOqr69XOBzWvn37shoaUvnMIu3aWKFFs2/VTQUB+STdVBDQotm3atfGCh5OAiYx26OY4uJi1dbWasOGDRoeHtaaNWtUXl6uTZs2qaamRtFoNBc5cQXhwqDWxUq1LlbqdBQALuIzxmR2uJ1FnLG7H9mdQXZnuD37dZ+xAwDyC8UOAB5DsQOAx1DsAOAxFDsAeAzFDgAeQ7EDgMdQ7ADgMRQ7AHgMw6wBuEqir19NrZ2Kd3RpcMjS1IKA5pdFVFlRwhfbZYhiB+Aabe/3qK7hpCzLpL+WenDI0rG3TuvN9jOqXhnlC+4ywFEMAFdI9PWrruGkhoZTo2YNWCmjoeGU6hpOKtHX71DC/EGxA3CFptZOWZbNkHbLqPl4Z44S5S+KHYArxDu6xpwKJn26c4+3X9uktsmEYgfgCoND1oSum8wodgCuMLUgMKHrJjOKHYArzC+LjJrhe7mA36f5syI5SpS/KHYArlBZUaJAwKbYAz7F5pbkKFH+otgBuEK4MKjqlVEVTPGP2rkH/D4VTPGremWUh5QywANKAFyjfGaRdm2sUPPxTsXbP/fk6ayIYnN58jRTFDsAVwkXBrUuVqp1sVKno+QtjmIAwGModgDwGIodADyGYgcAj6HYAcBjKHYA8BiKHQA8hs+xA0AO5WL0H8UOADmSq9F/HMUAQA7kcvQfxQ4AOZDL0X8UOwDkQC5H/1HsAJADuRz9R7EDQA7kcvQfxQ4AOZDL0X8ZFfuhQ4dUVVWlWCymvXv3jrp/+PBhrVixQsuXL1d1dbU++uij6w4GAF6Sy9F/tsXe3d2tPXv2aN++fWpoaND+/ft16tSp9P3z58/rmWeeUX19vQ4ePKjS0lL9/Oc/v+5gAOAluRz9Z1vsLS0tmjdvnqZPn65gMKjKyko1Njam7w8PD2vnzp0qLi6WJJWWlurMmTPXHQwAvObS6L9Fs2/VTQUB+STdVBDQotm3atfGigl5OEnK4MnTRCKhUCiUvg6Hw2pra0tfFxYW6v7775ckDQ4Oqr6+XuvXrx9XiKKiW8a1PhSaNq71bkJ2Z5DdGWS/8s8t+49i1Wblp3/KtthTqZR8vs/+2GCMGXF9yblz5/T9739ft99+u1atWjWuED0955Wy+XznJaHQNCWT58b1892C7M4guzPInj1+v2/MDbHtUUwkElEymUxfJ5NJhcPhEWsSiYTWrl2r0tJSPfvss9cRFwBwvWyLfcGCBYrH4+rt7dXAwICam5u1cOHC9H3LsrRlyxYtWbJE27dvv+JuHgCQO7ZHMcXFxaqtrdWGDRs0PDysNWvWqLy8XJs2bVJNTY26urr0j3/8Q5ZlqampSZI0a9Ysdu4A4BCfMSazw+0s4ozd/cjuDLI7w+3Zr/uMHQCQXyh2APAYih0APIZiBwCPodgBwGModgDwGIodADzG9gElANcu0devptZOxTu6NDhkaWpBQPPLIqqsKJmQr2cFroRiB7Kk7f0e1TWclGWZ9BDjwSFLx946rTfbz6h6ZXTCvqYV+DyOYoAsSPT1q67hpIaGU6Mm01spo6HhlOoaTirR1+9QQngZxQ5kQVNrpyxr7K/JsCyj5uOdOUqEyYRiB7Ig3tE1aqd+OStlFG/vylEiTCYUO5AFg0PWhK4DxoNiB7JgakFgQtcB40GxA1kwvywyahL95QJ+n+bPiuQoESYTih3IgsqKEgUCNsUe8Ck2tyRHiTCZUOxAFoQLg6peGVXBFP+onXvA71PBFL+qV0Z5SAlZwQNKQJaUzyzSro0Vaj7eqXj75548nRVRbC5PniJ7KHYgi8KFQa2LlWpdrNTpKJhEOIoBAI+h2AHAYyh2APAYih0APIZiBwCPodgBwGModgDwGIodADwm7x5QOnP2gv5P07vMkASAq8irYm97v0f/2dCui1aKGZKYcAyehlfkzVHMpRmSnwxbzJDEhGt7v0dP/6ZVx946nR5+cWnT8PRvWtX2fo/DCYHM5U2xM0MS2cLgaXhN3hQ7MySRLWwa4DV5U+zMkES2sGmA1+RNsTNDEtnCpgFekzfFzgxJZAubBnhNRsV+6NAhVVVVKRaLae/evaPuv/3223rwwQdVWVmp7du36+LFixMelBmSyBY2DfAa22Lv7u7Wnj17tG/fPjU0NGj//v06derUiDVPPvmknn76aTU1NckYo1deeWXCg16aIXnjlAAzJDGh2DTAa2yLvaWlRfPmzdP06dMVDAZVWVmpxsbG9P1//etfGhwc1OzZsyVJDz744Ij7E6l8ZpF+/r8Wa9HsW3VTQUA+STcVBLRo9q3atbGCh5NwTRg8Da+xffI0kUgoFAqlr8PhsNra2q56PxQKqbu7e4JjfuZ/zLiZGZKYcAyehpfYFnsqlZLP99kuxhgz4trufiaKim4Z1/pQaNq41rsJ2Z2RSfZQaJrK/qNYtTnIMx5ef93dKp+z2xZ7JBLRiRMn0tfJZFLhcHjE/WQymb4+e/bsiPuZ6Ok5r5TN54gvCYWmKZk8N66f7xZkdwbZnUH27PH7fWNuiG3P2BcsWKB4PK7e3l4NDAyoublZCxcuTN//4he/qBtvvFF//etfJUkHDhwYcR8AkFu2O/bi4mLV1tZqw4YNGh4e1po1a1ReXq5NmzappqZG0WhUP/3pT7Vjxw6dP39eZWVl2rBhw7hC+G0+ana9692E7M4guzPInh122XzGmMzOQAAAeSFvnjwFAGSGYgcAj6HYAcBjKHYA8BiKHQA8hmIHAI+h2AHAYyh2APAYih0APMaVxW43semSH/zgB3r11VdzmMyeXfbDhw9rxYoVWr58uaqrq/XRRx85kPLK7LK//vrrWrZsmR544AFt3bpVQ0NDDqS8skzfM2+88YbuvffeHCazZ5f9F7/4hRYvXqwVK1ZoxYoVY/775Zpd9g8++EDr16/X8uXL9cgjj+TN+/3tt99Ov94rVqzQ17/+dS1dutShpNfAuExXV5dZvHix6evrMxcuXDDLli0z//znP0eteeyxx0x5ebn54x//6FDS0eyynzt3znzta18zXV1dxhhjXnjhBfPDH/7Qqbgj2GW/cOGCueeee0wymTTGGPPEE0+Y3//+907FHSGT94wxxiSTSfOtb33LLF682IGUV5ZJ9scee8z87W9/cyjh1dllT6VSJhaLmaNHjxpjjHn++efNc88951TcETJ9zxhjTH9/v3nggQfM8ePHc5zy2rlux243sUn69Hfab37zm1qyZIlDKa/MLvvw8LB27typ4uJiSVJpaanOnDnjVNwR7LIHg0EdOXJEM2bM0MDAgHp6evSFL3zBwcSfyeQ9I0k7duzQ448/7kDCq8ske3t7u1588UUtW7ZMu3bt0ieffOJQ2pHssnd0dCgYDKa/7XXLli16+OGHnYo7QqbvGUl68cUXNXfuXN199905TnntXFfsV5rYdPlEpkcffVTf/va3cx3Nll32wsJC3X///ZKkwcFB1dfX67777st5zivJ5HWfMmWKjh49qm984xvq6+vTPffck+uYV5RJ9pdffll33nmn7rrrrlzHG5Nd9gsXLuiOO+7Qk08+qddee00ff/yx6urqnIg6il32Dz/8UDNmzNC2bdu0atUq7dy5U8GgOyZRZfKekaRz587plVdecd2GwI7rin0iJjI5JdPs586d0+bNm3X77bdr1apVuYx4VZlmX7Rokf7yl79o8eLFeuaZZ3KY8Orssr/33ntqbm5WdXW1E/HGZJf95ptv1q9+9SvNnDlTN9xwgzZu3KijR486EXUUu+wXL15Ua2urvvvd7+q1115TSUmJdu/e7UTUUTJ9vx88eFD33Xefiorya56y64r98olMl09scrNMsicSCa1du1alpaV69tlncx3xquyy//vf/9af//zn9PWyZcv07rvv5jTj1dhlb2xsVDKZ1OrVq7V58+b0fwM3sMt++vRp/eEPf0hfG2N0ww22YxRywi57KBTSbbfdpmg0KklaunTpiHnJTsq0Zw4fPqyqqqpcRpsQrit2u4lNbmaX3bIsbdmyRUuWLNH27dtd9ScRu+zGGD355JM6ffq0pE/L8itf+YpTcUewy15TU6OmpiYdOHBA9fX1CofD2rdvn4OJP2OXferUqXr++efV2dkpY4z27t2bPs5zml32OXPmqLe3V++8844k6ciRIyorK3Mq7giZ9IwxRh0dHZozZ45DKa+DQ//TdkwHDx40DzzwgInFYqa+vt4YY8yjjz5q2traRqx76qmnXPWpGGPGzt7c3GxKS0vN8uXL039t27bN4cSfsXvdX3/9dbN06VKzbNkyU1tbaz7++GMn446Q6Xums7PTVZ+KMcY+e2NjY/r+1q1bzSeffOJk3BHssv/97383q1evNlVVVWbjxo3m7NmzTsYdwS772bNnzYIFC5yMeM2YoAQAHuO6oxgAwPWh2AHAYyh2APAYih0APIZiBwCPodgBwGModgDwGIodADzm/wMAFZ8rL4h7ygAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn; seaborn.set() # Plot styling\n",
    "\n",
    "X = rand.rand(10, 2) # rand values with 10 rows and 2 cols\n",
    "plt.scatter(X[:, 0], X[:, 1], s=100)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  2.09 Structured Data: NumPy's Structured Arrays\n",
    "Creating and working on data frame type objects in numpy. Pandas are better for such data... on to Pandas!"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}