CH2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02.01 Understand data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python variables are more than just their value; they also contain extra information about the type of the value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A python integer is more than just an integer\n",
    "A signle integer in python contains:\n",
    "1. ob_refcnt: a reference count that help python silently handle memory allcoation and deallocation\n",
    "2. ob_type: encodes the type of the variable\n",
    "3. ob_size: specifies the size of the data member\n",
    "4. ob_digit: contains the actual integer value the variable shoudl represent\n",
    "\n",
    "\n",
    "A python integer is a pointer to a position in memory containing all python object information, including the bytes that contain the integer value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A python list is more than just a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[bool, str, int, float]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# regular list \n",
    "L = list(range(10))\n",
    "type(L[0])\n",
    "\n",
    "L2 = [str(c) for c in L]\n",
    "type(L2[0])\n",
    "\n",
    "# Because of python's dynamic typing, we can create heterogeneous list\n",
    "L3 = [True, '2', 3, 4.0]\n",
    "[type(item) for item in L3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This flexibility comes at a cost: each item in the list must contain its own type info, reference count, and other info\n",
    "If all variables are of the same type, much of this information is redundant: it can be much more efficient to store data in a fixed type array(Numpy Array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 4., 2., 5., 3.], dtype=float32)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.array([1, 4, 2, 5, 3])\n",
    "np.array([1, 4, 2, 5, 3.14])\n",
    "np.array([1, 4, 2, 5, 3], dtype='float32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3, 4],\n",
       "       [4, 5, 6],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy array can be multi-dimensional\n",
    "np.array([range(i, i+3) for i in [2,4,6]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02.02 The basics of NumPy arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy array attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x3 ndim:  3\n",
      "x3 shape: (3, 4, 5)\n",
      "x3 size:  60\n",
      "int32\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.random.seed(0)\n",
    "\n",
    "x1 = np.random.randint(10, size=6)\n",
    "x2 = np.random.randint(10, size = (3,4))\n",
    "x3 = np.random.randint(10, size = (3,4,5))\n",
    "\n",
    "print(\"x3 ndim: \", x3.ndim) #number of dimension\n",
    "print(\"x3 shape:\", x3.shape) #size of each dimension\n",
    "print(\"x3 size: \", x3.size) #size of the array\n",
    "\n",
    "print(x3.dtype) #data type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array Indiexing: accessing single elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "9\n",
      "1\n",
      "[1 6 7 7]\n",
      "int32\n",
      "[5 0 3 3 7 9]\n",
      "[3 0 3 3 7 9]\n"
     ]
    }
   ],
   "source": [
    "print(x1[0])\n",
    "print(x1[-1])\n",
    "\n",
    "print(x2[2,0])\n",
    "print(x2[2,])\n",
    "print(x1.dtype)\n",
    "\n",
    "print(x1)\n",
    "x1[0]=3.1415\n",
    "print(x1) #3.1415 is truncated to 3 because data type is integer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array Slicing: accessing subarrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "5\n",
      "[0 2 4 6 8]\n",
      "[1 3 5 7 9]\n",
      "[9 8 7 6 5 4 3 2 1 0]\n",
      "[5 3 1]\n"
     ]
    }
   ],
   "source": [
    "x= np.arange(10)\n",
    "print(x)\n",
    "print(x[5])\n",
    "x[:5] #first 5 elements\n",
    "x[5:] #after index 5\n",
    "x[4:7] #after index 4\n",
    "print(x[::2]) # every other element\n",
    "print(x[1::2]) #every other element starting index 1\n",
    "print(x[::-1]) #reverse all elements\n",
    "print(x[5::-2]) # reversed every other from index 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 5 2 4]\n",
      " [7 6 8 8]\n",
      " [1 6 7 7]] \n",
      "\n",
      "[3 7 1] \n",
      "\n",
      "[3 5 2 4] \n",
      "\n",
      "[[3 5]\n",
      " [7 6]]\n"
     ]
    }
   ],
   "source": [
    "print(x2,'\\n')\n",
    "\n",
    "print(x2[:,0],'\\n')\n",
    "\n",
    "print(x2[0,:],'\\n')\n",
    "\n",
    "print(x2[:2, :2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reshaping of array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 1  2  3]\n",
      "  [ 4  5  6]\n",
      "  [ 7  8  9]]\n",
      "\n",
      " [[10 11 12]\n",
      "  [13 14 15]\n",
      "  [16 17 18]]\n",
      "\n",
      " [[19 20 21]\n",
      "  [22 23 24]\n",
      "  [25 26 27]]]\n"
     ]
    }
   ],
   "source": [
    "grid = np.arange(1,28).reshape((3,3,3))\n",
    "print(grid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array concatenation and splitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6] \n",
      "\n",
      "[[9 9 9]\n",
      " [0 0 0]\n",
      " [9 9 9]\n",
      " [0 0 0]] \n",
      "\n",
      "[[9 9 9 9 9 9]\n",
      " [0 0 0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "x= np.array([1,2,3])\n",
    "y= np.array([4,5,6])\n",
    "\n",
    "grid=np.array([[9,9,9],\n",
    "              [0,0,0]])\n",
    "\n",
    "print(np.concatenate([x,y]),'\\n')\n",
    "print(np.concatenate([grid, grid]),'\\n')\n",
    "print(np.concatenate([grid, grid], axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "all the input arrays must have same number of dimensions",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-36-b52617504989>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrid\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: all the input arrays must have same number of dimensions"
     ]
    }
   ],
   "source": [
    "np.concatenate([x, grid]) \n",
    "# does not work because it must have same number of dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [9, 9, 9],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack([x, grid]) #works as expected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack([x,y]) # work as expected"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## spliting arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3] [99 99] [3] [2 1]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3, 99, 99, 3, 2, 1]\n",
    "x1, x2, x3, x4 = np.split(x, [3,5,6])\n",
    "print(x1, x2, x3, x4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02.03 Computation on NumPy Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introducing UFuncs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loop\n",
    "import numpy as np\n",
    "np.random.seed(0)\n",
    "\n",
    "def compute_reciprocals(values):\n",
    "    output = np.empty(len(values))\n",
    "    for i in range(len(values)):\n",
    "        output[i] = 1.0/values[i]\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "298 ms ± 38.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "big_array = np.random.randint(1,100, size=100000)\n",
    "%timeit compute_reciprocals(big_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "161 µs ± 8.17 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit 1/big_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arithmetric opteration\n",
    "np.add\n",
    "np.subtract\n",
    "np.negative\n",
    "np.multiply\n",
    "np.divide\n",
    "np.floor_divide\n",
    "np.power\n",
    "np.mod\n",
    "np.absolute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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"
     ]
    }
   ],
   "source": [
    "#exponential\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))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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": [
    "#natural log\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": [
    "## Advabced Ufunc features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0. 10. 20. 30. 40.]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(5)\n",
    "y = np.empty(5)\n",
    "np.multiply(x, 10, out=y)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(1,6)\n",
    "print(x)\n",
    "np.add.reduce(x) \n",
    "# a reduce repeatedly applies a given operation to the elements of an \n",
    "# array until only a single result remains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid number of arguments",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-57-c682dbeac0d2>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: invalid number of arguments"
     ]
    }
   ],
   "source": [
    "np.add(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  3,  6, 10, 15], dtype=int32)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add.accumulate(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5],\n",
       "       [ 2,  4,  6,  8, 10],\n",
       "       [ 3,  6,  9, 12, 15],\n",
       "       [ 4,  8, 12, 16, 20],\n",
       "       [ 5, 10, 15, 20, 25]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# outer products\n",
    "np.multiply.outer(x,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3,  4,  5,  6],\n",
       "       [ 3,  4,  5,  6,  7],\n",
       "       [ 4,  5,  6,  7,  8],\n",
       "       [ 5,  6,  7,  8,  9],\n",
       "       [ 6,  7,  8,  9, 10]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add.outer(x,x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02.04 Computation on arrays aggregates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.003506554960814978, 0.9978597802315324)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "big_array= np.random.rand(1000)\n",
    "min(big_array), max(big_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.18 µs ± 201 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit np.min(big_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "90.5 µs ± 9.09 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit min(big_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0.94957559, 0.9268718 , 0.18592265, 0.79498937],\n",
       "        [0.2452559 , 0.84578305, 0.59134472, 0.98479377],\n",
       "        [0.6362122 , 0.39900497, 0.60756634, 0.85186063]],\n",
       "\n",
       "       [[0.29683042, 0.28208917, 0.64655872, 0.64300015],\n",
       "        [0.92251093, 0.5258133 , 0.92131468, 0.12421592],\n",
       "        [0.17428986, 0.07853349, 0.37474137, 0.80815157]]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.random.random((2,3,4))\n",
    "type(M)\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.64655872, 0.92251093, 0.80815157])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[0].min(axis=0) #0 is across column\n",
    "M[1].max(axis=1) #1 is across row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=[1,3, 5.0, np.nan]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  3.,  5., nan], dtype=float32)"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_n = np.array(n, dtype='float32')\n",
    "n_n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "data_path= 'C:/Users/miaoxi/Documents/LearnPython/PythonDataScienceHandbook-master/PythonDataScienceHandbook-master/notebooks/data'\n",
    "president_heights_path= os.path.join(data_path,'president_heights.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "president_heights= pd.read_csv(president_heights_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "heights = np.array(president_heights['height(cm)'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean height:    179.73809523809524\n",
      "Standard deviation: 6.931843442745892\n",
      "Minimum height:  163\n",
      "Maximum height:  193\n",
      "25th percentile: 174.25\n"
     ]
    }
   ],
   "source": [
    "print(\"Mean height:   \", heights.mean())\n",
    "print(\"Standard deviation:\", heights.std())\n",
    "print(\"Minimum height: \", heights.min())\n",
    "print(\"Maximum height: \", heights.max())\n",
    "print(\"25th percentile:\", np.percentile(heights,25))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn; seaborn.set() #set plot style"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'number')"
      ]
     },
     "execution_count": 109,
     "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": [
    "plt.hist(heights)\n",
    "plt.title('Height Distribution of US presidents')\n",
    "plt.xlabel('height (cm)')\n",
    "plt.ylabel('number')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02.05 Computation on arrays broadcasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a= np.array([0,1,2])\n",
    "a+5 # add scalar to an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = np.ones((3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2., 3.],\n",
       "       [1., 2., 3.],\n",
       "       [1., 2., 3.]])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M +a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2., 3.],\n",
       "       [1., 2., 3.],\n",
       "       [1., 2., 3.],\n",
       "       [1., 2., 3.]])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#rules of broadcasting\n",
    "\n",
    "M = np.ones((4,3))\n",
    "\n",
    "N = np.arange(3)\n",
    "\n",
    "M+N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(3).reshape((3, 1))\n",
    "b = np.arange(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [1, 2, 3],\n",
       "       [2, 3, 4]])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = np.ones((3, 2))\n",
    "a = np.arange(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2]])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.reshape(3,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2]])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:,np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-6.66133815e-17,  8.88178420e-17, -1.11022302e-17])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.random.random((10,3))\n",
    "Xmean = X.mean(0)\n",
    "\n",
    "X_centered = X- Xmean\n",
    "\n",
    "X_centered.mean(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02.06 Boolean arrays and masks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "rainfall = pd.read_csv(os.path.join(data_path,'Seattle2014.csv'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "rainfall_val= rainfall['PRCP'].values\n",
    "rainfall_val\n",
    "\n",
    "inches = rainfall_val/254"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([245.,  14.,  13.,  17.,   8.,   6.,   5.,   6.,   4.,   3.,   7.,\n",
       "          6.,   3.,   3.,   3.,   4.,   4.,   2.,   4.,   0.,   0.,   1.,\n",
       "          1.,   1.,   0.,   0.,   0.,   2.,   1.,   1.,   0.,   0.,   0.,\n",
       "          0.,   0.,   0.,   0.,   0.,   0.,   1.]),\n",
       " array([0.        , 0.04596457, 0.09192913, 0.1378937 , 0.18385827,\n",
       "        0.22982283, 0.2757874 , 0.32175197, 0.36771654, 0.4136811 ,\n",
       "        0.45964567, 0.50561024, 0.5515748 , 0.59753937, 0.64350394,\n",
       "        0.6894685 , 0.73543307, 0.78139764, 0.8273622 , 0.87332677,\n",
       "        0.91929134, 0.96525591, 1.01122047, 1.05718504, 1.10314961,\n",
       "        1.14911417, 1.19507874, 1.24104331, 1.28700787, 1.33297244,\n",
       "        1.37893701, 1.42490157, 1.47086614, 1.51683071, 1.56279528,\n",
       "        1.60875984, 1.65472441, 1.70068898, 1.74665354, 1.79261811,\n",
       "        1.83858268]),\n",
       " <a list of 40 Patch objects>)"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn; seaborn.set()  # set plot styles\n",
    "plt.hist(inches,40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "39"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(inches>=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 0, 3, 3],\n",
       "       [7, 9, 3, 5],\n",
       "       [2, 4, 7, 6]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng = np.random.RandomState(0)\n",
    "x = rng.randint(10, size=(3,4))\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.count_nonzero(x<6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 2, 2])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(x<6, axis=1) #in each row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.any(x<8)\n",
    "np.all(x<10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum((inches>0.5)&(inches<1))\n",
    "\n",
    "#same result as\n",
    "np.sum(~((inches<=0.5)|(inches>=1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boolean arrays as masks\n",
    "\n",
    "A more powerful pattern is to use boolean arrays as masks, to select particular subsets of the data themselves.  To select the values from the array, we can simply index on this boolean array, this is known as a masking operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.83858268, 0.8503937 , 1.03937008, 0.7519685 , 1.83858268,\n",
       "       1.27165354, 1.09055118, 0.87007874, 1.31102362, 0.75984252,\n",
       "       0.8503937 , 0.7992126 , 1.25984252, 1.        , 1.3503937 ,\n",
       "       0.77165354, 0.81102362])"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inches[inches>0.75]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [],
   "source": [
    "rainy= (inches>0)\n",
    "\n",
    "days= np.arange(365)\n",
    "summer = (days>172) &(days<262)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Median precip on rainy days: 0.19488188976377951\n",
      "Median precip on summer days: 0.0\n",
      "Median precip on non-summer rainy days 0.20078740157480315\n"
     ]
    }
   ],
   "source": [
    "print(\"Median precip on rainy days:\", np.median(inches[rainy]))\n",
    "print(\"Median precip on summer days:\", np.median(inches[summer]))\n",
    "print(\"Median precip on non-summer rainy days\", np.median(inches[(~summer) & rainy]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True, False,  True,  True])"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([1, 0, 1, 0, 1, 0], dtype=bool)\n",
    "B = np.array([1, 1, 1, 0, 1, 1], dtype=bool)\n",
    "A | B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-167-ea2c97d9d9ee>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mA\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0mB\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "A or B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and and or perform a signle boolean evaluation on an entire object, while & and | perform multiple boolean evaluation on the content of an object; later one is nearly always the desired operation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02.07 Fancy indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fancy indexing is like the simple indexing we've already seen, but we pass arrays of indices in place of single scalars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[51 92 14 71 60 20 82 86 74 74]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "rand = np.random.RandomState(42)\n",
    "\n",
    "x = rand.randint(100, size=10)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([71, 86, 60])"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ind = [3,7,4]\n",
    "x[ind]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using fancy indexing, the shape of the result reflects the shape of the index defined by the array rather than the shape of array being indexed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.arange(12).reshape((3,4))\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  5, 11])"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row = np.array([0,1,2])\n",
    "col = np.array([2,1,3])\n",
    "\n",
    "X[row, col]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2]])"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modifying values with fancy indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0, 109, 109,   3, 109,   5,   6,   7, 109,   9])"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(10)\n",
    "i = np.array([2,1,8,4])\n",
    "\n",
    "x[i]=99\n",
    "x\n",
    "\n",
    "x[i]+=10\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sorting arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "[2 1 4 3 5]\n",
      "[1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([2, 1, 4, 3, 5])\n",
    "#return a sorted version without modifyig the input\n",
    "print(np.sort(x))\n",
    "print(x)\n",
    "\n",
    "x.sort()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "[2 1 4 3 5]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([2, 1, 4, 3, 5])\n",
    "i = np.argsort(x)\n",
    "print(x[i])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[6 3 7 4 6 9]\n",
      " [2 6 7 4 3 7]\n",
      " [7 2 5 4 1 7]\n",
      " [5 1 4 0 9 5]]\n"
     ]
    }
   ],
   "source": [
    "rand = np.random.RandomState(42)\n",
    "X = rand.randint(0, 10, (4, 6))\n",
    "print(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 1, 4, 0, 1, 5],\n",
       "       [5, 2, 5, 4, 3, 7],\n",
       "       [6, 3, 7, 4, 6, 7],\n",
       "       [7, 6, 7, 4, 9, 9]])"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#sort along column\n",
    "np.sort(X, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 4, 6, 6, 7, 9],\n",
       "       [2, 3, 4, 6, 7, 7],\n",
       "       [1, 2, 4, 5, 7, 7],\n",
       "       [0, 1, 4, 5, 5, 9]])"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sort(X, axis =1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keep in mind that this treats each row or column as an independent array, and any relationships between the row or column values will be lost!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: k-NN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = rand.rand(10,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\miaoxi\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:1: DeprecationWarning: This function is deprecated. Please call randint(5, 7 + 1) instead\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a= rand.random_integers(5,7)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0.        ,  0.        ],\n",
       "        [-0.51770836, -0.37679855],\n",
       "        [-0.03959936, -0.95069309],\n",
       "        [-0.22570504, -0.06754401],\n",
       "        [-0.6113197 , -0.35939957],\n",
       "        [-0.97616458, -0.44370047],\n",
       "        [-0.8528741 , -0.65724511],\n",
       "        [-0.44343295,  0.00979746],\n",
       "        [-0.93513545, -0.54022579],\n",
       "        [-0.3783502 ,  0.00709617]],\n",
       "\n",
       "       [[ 0.51770836,  0.37679855],\n",
       "        [ 0.        ,  0.        ],\n",
       "        [ 0.478109  , -0.57389455],\n",
       "        [ 0.29200332,  0.30925454],\n",
       "        [-0.09361135,  0.01739898],\n",
       "        [-0.45845623, -0.06690192],\n",
       "        [-0.33516575, -0.28044657],\n",
       "        [ 0.07427541,  0.38659601],\n",
       "        [-0.4174271 , -0.16342725],\n",
       "        [ 0.13935816,  0.38389472]],\n",
       "\n",
       "       [[ 0.03959936,  0.95069309],\n",
       "        [-0.478109  ,  0.57389455],\n",
       "        [ 0.        ,  0.        ],\n",
       "        [-0.18610568,  0.88314908],\n",
       "        [-0.57172035,  0.59129353],\n",
       "        [-0.93656522,  0.50699263],\n",
       "        [-0.81327474,  0.29344798],\n",
       "        [-0.40383359,  0.96049056],\n",
       "        [-0.89553609,  0.4104673 ],\n",
       "        [-0.33875084,  0.95778927]],\n",
       "\n",
       "       [[ 0.22570504,  0.06754401],\n",
       "        [-0.29200332, -0.30925454],\n",
       "        [ 0.18610568, -0.88314908],\n",
       "        [ 0.        ,  0.        ],\n",
       "        [-0.38561467, -0.29185556],\n",
       "        [-0.75045955, -0.37615646],\n",
       "        [-0.62716907, -0.5897011 ],\n",
       "        [-0.21772791,  0.07734147],\n",
       "        [-0.70943042, -0.47268178],\n",
       "        [-0.15264516,  0.07464018]],\n",
       "\n",
       "       [[ 0.6113197 ,  0.35939957],\n",
       "        [ 0.09361135, -0.01739898],\n",
       "        [ 0.57172035, -0.59129353],\n",
       "        [ 0.38561467,  0.29185556],\n",
       "        [ 0.        ,  0.        ],\n",
       "        [-0.36484488, -0.0843009 ],\n",
       "        [-0.2415544 , -0.29784555],\n",
       "        [ 0.16788676,  0.36919703],\n",
       "        [-0.32381575, -0.18082623],\n",
       "        [ 0.23296951,  0.36649574]],\n",
       "\n",
       "       [[ 0.97616458,  0.44370047],\n",
       "        [ 0.45845623,  0.06690192],\n",
       "        [ 0.93656522, -0.50699263],\n",
       "        [ 0.75045955,  0.37615646],\n",
       "        [ 0.36484488,  0.0843009 ],\n",
       "        [ 0.        ,  0.        ],\n",
       "        [ 0.12329048, -0.21354465],\n",
       "        [ 0.53273163,  0.45349793],\n",
       "        [ 0.04102913, -0.09652532],\n",
       "        [ 0.59781438,  0.45079664]],\n",
       "\n",
       "       [[ 0.8528741 ,  0.65724511],\n",
       "        [ 0.33516575,  0.28044657],\n",
       "        [ 0.81327474, -0.29344798],\n",
       "        [ 0.62716907,  0.5897011 ],\n",
       "        [ 0.2415544 ,  0.29784555],\n",
       "        [-0.12329048,  0.21354465],\n",
       "        [ 0.        ,  0.        ],\n",
       "        [ 0.40944115,  0.66704258],\n",
       "        [-0.08226135,  0.11701932],\n",
       "        [ 0.4745239 ,  0.66434129]],\n",
       "\n",
       "       [[ 0.44343295, -0.00979746],\n",
       "        [-0.07427541, -0.38659601],\n",
       "        [ 0.40383359, -0.96049056],\n",
       "        [ 0.21772791, -0.07734147],\n",
       "        [-0.16788676, -0.36919703],\n",
       "        [-0.53273163, -0.45349793],\n",
       "        [-0.40944115, -0.66704258],\n",
       "        [ 0.        ,  0.        ],\n",
       "        [-0.4917025 , -0.55002326],\n",
       "        [ 0.06508275, -0.00270129]],\n",
       "\n",
       "       [[ 0.93513545,  0.54022579],\n",
       "        [ 0.4174271 ,  0.16342725],\n",
       "        [ 0.89553609, -0.4104673 ],\n",
       "        [ 0.70943042,  0.47268178],\n",
       "        [ 0.32381575,  0.18082623],\n",
       "        [-0.04102913,  0.09652532],\n",
       "        [ 0.08226135, -0.11701932],\n",
       "        [ 0.4917025 ,  0.55002326],\n",
       "        [ 0.        ,  0.        ],\n",
       "        [ 0.55678525,  0.54732197]],\n",
       "\n",
       "       [[ 0.3783502 , -0.00709617],\n",
       "        [-0.13935816, -0.38389472],\n",
       "        [ 0.33875084, -0.95778927],\n",
       "        [ 0.15264516, -0.07464018],\n",
       "        [-0.23296951, -0.36649574],\n",
       "        [-0.59781438, -0.45079664],\n",
       "        [-0.4745239 , -0.66434129],\n",
       "        [-0.06508275,  0.00270129],\n",
       "        [-0.55678525, -0.54732197],\n",
       "        [ 0.        ,  0.        ]]])"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for each pair of points, compute differences in their coordinates\n",
    "differences = X[:, np.newaxis, :] - X[np.newaxis, :, :]\n",
    "differences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0.00000000e+00, 0.00000000e+00],\n",
       "        [2.68021941e-01, 1.41977145e-01],\n",
       "        [1.56810915e-03, 9.03817359e-01],\n",
       "        [5.09427629e-02, 4.56219322e-03],\n",
       "        [3.73711781e-01, 1.29168048e-01],\n",
       "        [9.52897288e-01, 1.96870105e-01],\n",
       "        [7.27394233e-01, 4.31971139e-01],\n",
       "        [1.96632778e-01, 9.59902985e-05],\n",
       "        [8.74478311e-01, 2.91843907e-01],\n",
       "        [1.43148872e-01, 5.03556687e-05]],\n",
       "\n",
       "       [[2.68021941e-01, 1.41977145e-01],\n",
       "        [0.00000000e+00, 0.00000000e+00],\n",
       "        [2.28588213e-01, 3.29354951e-01],\n",
       "        [8.52659388e-02, 9.56383688e-02],\n",
       "        [8.76308468e-03, 3.02724521e-04],\n",
       "        [2.10182111e-01, 4.47586710e-03],\n",
       "        [1.12336078e-01, 7.86502769e-02],\n",
       "        [5.51683628e-03, 1.49456475e-01],\n",
       "        [1.74245380e-01, 2.67084648e-02],\n",
       "        [1.94206961e-02, 1.47375156e-01]],\n",
       "\n",
       "       [[1.56810915e-03, 9.03817359e-01],\n",
       "        [2.28588213e-01, 3.29354951e-01],\n",
       "        [0.00000000e+00, 0.00000000e+00],\n",
       "        [3.46353231e-02, 7.79952305e-01],\n",
       "        [3.26864154e-01, 3.49628036e-01],\n",
       "        [8.77154416e-01, 2.57041522e-01],\n",
       "        [6.61415808e-01, 8.61117171e-02],\n",
       "        [1.63081567e-01, 9.22542111e-01],\n",
       "        [8.01984893e-01, 1.68483405e-01],\n",
       "        [1.14752131e-01, 9.17360279e-01]],\n",
       "\n",
       "       [[5.09427629e-02, 4.56219322e-03],\n",
       "        [8.52659388e-02, 9.56383688e-02],\n",
       "        [3.46353231e-02, 7.79952305e-01],\n",
       "        [0.00000000e+00, 0.00000000e+00],\n",
       "        [1.48698673e-01, 8.51796660e-02],\n",
       "        [5.63189529e-01, 1.41493681e-01],\n",
       "        [3.93341038e-01, 3.47747392e-01],\n",
       "        [4.74054435e-02, 5.98170350e-03],\n",
       "        [5.03291514e-01, 2.23428068e-01],\n",
       "        [2.33005455e-02, 5.57115682e-03]],\n",
       "\n",
       "       [[3.73711781e-01, 1.29168048e-01],\n",
       "        [8.76308468e-03, 3.02724521e-04],\n",
       "        [3.26864154e-01, 3.49628036e-01],\n",
       "        [1.48698673e-01, 8.51796660e-02],\n",
       "        [0.00000000e+00, 0.00000000e+00],\n",
       "        [1.33111784e-01, 7.10664207e-03],\n",
       "        [5.83485269e-02, 8.87119701e-02],\n",
       "        [2.81859633e-02, 1.36306447e-01],\n",
       "        [1.04856638e-01, 3.26981242e-02],\n",
       "        [5.42747911e-02, 1.34319127e-01]],\n",
       "\n",
       "       [[9.52897288e-01, 1.96870105e-01],\n",
       "        [2.10182111e-01, 4.47586710e-03],\n",
       "        [8.77154416e-01, 2.57041522e-01],\n",
       "        [5.63189529e-01, 1.41493681e-01],\n",
       "        [1.33111784e-01, 7.10664207e-03],\n",
       "        [0.00000000e+00, 0.00000000e+00],\n",
       "        [1.52005422e-02, 4.56013156e-02],\n",
       "        [2.83802994e-01, 2.05660374e-01],\n",
       "        [1.68338952e-03, 9.31713829e-03],\n",
       "        [3.57382037e-01, 2.03217612e-01]],\n",
       "\n",
       "       [[7.27394233e-01, 4.31971139e-01],\n",
       "        [1.12336078e-01, 7.86502769e-02],\n",
       "        [6.61415808e-01, 8.61117171e-02],\n",
       "        [3.93341038e-01, 3.47747392e-01],\n",
       "        [5.83485269e-02, 8.87119701e-02],\n",
       "        [1.52005422e-02, 4.56013156e-02],\n",
       "        [0.00000000e+00, 0.00000000e+00],\n",
       "        [1.67642059e-01, 4.44945800e-01],\n",
       "        [6.76692953e-03, 1.36935214e-02],\n",
       "        [2.25172936e-01, 4.41349345e-01]],\n",
       "\n",
       "       [[1.96632778e-01, 9.59902985e-05],\n",
       "        [5.51683628e-03, 1.49456475e-01],\n",
       "        [1.63081567e-01, 9.22542111e-01],\n",
       "        [4.74054435e-02, 5.98170350e-03],\n",
       "        [2.81859633e-02, 1.36306447e-01],\n",
       "        [2.83802994e-01, 2.05660374e-01],\n",
       "        [1.67642059e-01, 4.44945800e-01],\n",
       "        [0.00000000e+00, 0.00000000e+00],\n",
       "        [2.41771352e-01, 3.02525583e-01],\n",
       "        [4.23576427e-03, 7.29697339e-06]],\n",
       "\n",
       "       [[8.74478311e-01, 2.91843907e-01],\n",
       "        [1.74245380e-01, 2.67084648e-02],\n",
       "        [8.01984893e-01, 1.68483405e-01],\n",
       "        [5.03291514e-01, 2.23428068e-01],\n",
       "        [1.04856638e-01, 3.26981242e-02],\n",
       "        [1.68338952e-03, 9.31713829e-03],\n",
       "        [6.76692953e-03, 1.36935214e-02],\n",
       "        [2.41771352e-01, 3.02525583e-01],\n",
       "        [0.00000000e+00, 0.00000000e+00],\n",
       "        [3.10009818e-01, 2.99561334e-01]],\n",
       "\n",
       "       [[1.43148872e-01, 5.03556687e-05],\n",
       "        [1.94206961e-02, 1.47375156e-01],\n",
       "        [1.14752131e-01, 9.17360279e-01],\n",
       "        [2.33005455e-02, 5.57115682e-03],\n",
       "        [5.42747911e-02, 1.34319127e-01],\n",
       "        [3.57382037e-01, 2.03217612e-01],\n",
       "        [2.25172936e-01, 4.41349345e-01],\n",
       "        [4.23576427e-03, 7.29697339e-06],\n",
       "        [3.10009818e-01, 2.99561334e-01],\n",
       "        [0.00000000e+00, 0.00000000e+00]]])"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# square the coordinate differences\n",
    "sq_differences = differences ** 2\n",
    "sq_differences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 0.40999909, 0.90538547, 0.05550496, 0.50287983,\n",
       "        1.14976739, 1.15936537, 0.19672877, 1.16632222, 0.14319923],\n",
       "       [0.40999909, 0.        , 0.55794316, 0.18090431, 0.00906581,\n",
       "        0.21465798, 0.19098635, 0.15497331, 0.20095384, 0.16679585],\n",
       "       [0.90538547, 0.55794316, 0.        , 0.81458763, 0.67649219,\n",
       "        1.13419594, 0.74752753, 1.08562368, 0.9704683 , 1.03211241],\n",
       "       [0.05550496, 0.18090431, 0.81458763, 0.        , 0.23387834,\n",
       "        0.70468321, 0.74108843, 0.05338715, 0.72671958, 0.0288717 ],\n",
       "       [0.50287983, 0.00906581, 0.67649219, 0.23387834, 0.        ,\n",
       "        0.14021843, 0.1470605 , 0.16449241, 0.13755476, 0.18859392],\n",
       "       [1.14976739, 0.21465798, 1.13419594, 0.70468321, 0.14021843,\n",
       "        0.        , 0.06080186, 0.48946337, 0.01100053, 0.56059965],\n",
       "       [1.15936537, 0.19098635, 0.74752753, 0.74108843, 0.1470605 ,\n",
       "        0.06080186, 0.        , 0.61258786, 0.02046045, 0.66652228],\n",
       "       [0.19672877, 0.15497331, 1.08562368, 0.05338715, 0.16449241,\n",
       "        0.48946337, 0.61258786, 0.        , 0.54429694, 0.00424306],\n",
       "       [1.16632222, 0.20095384, 0.9704683 , 0.72671958, 0.13755476,\n",
       "        0.01100053, 0.02046045, 0.54429694, 0.        , 0.60957115],\n",
       "       [0.14319923, 0.16679585, 1.03211241, 0.0288717 , 0.18859392,\n",
       "        0.56059965, 0.66652228, 0.00424306, 0.60957115, 0.        ]])"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sum the coordinate differences to get the squared distance\n",
    "dist_sq = sq_differences.sum(-1)\n",
    "dist_sq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Structured data: numpy structured arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = ['Alice', 'Bob', 'Cathy', 'Doug']\n",
    "age = [25, 45, 37, 19]\n",
    "weight = [55.0, 85.5, 68.0, 61.5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [],
   "source": [
    "data= np.zeros(4, dtype={'names':('name','age','weight'),\n",
    "                        'formats':('U10','i4','f8')})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['name']=name\n",
    "data['age']=age\n",
    "data['weight']=weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Alice', 25, 55.)\n",
      "['Alice' 'Bob' 'Cathy' 'Doug']\n",
      "Doug\n",
      "['Alice' 'Doug']\n"
     ]
    }
   ],
   "source": [
    "print(data[0])\n",
    "print(data['name'])\n",
    "print(data['name'][-1])\n",
    "print(data[data['age']<30]['name'])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}