C3_NumPy_BayArea_HomePrice_Student.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = \"https://img.betapage.co/images/77640967-77641456.png\" height=50% width = 50%>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to NumPy\n",
    "\n",
    "\"Numpy is the core library for scientific computing in Python. It provides a high-performance multidimensional array object, and tools for working with these arrays. This library provides you with an array data structure that holds some benefits over Python lists, such as: being more compact, faster access in reading and writing items, being more convenient and more efficient.\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What is a NumPy array?\n",
    "\n",
    "\"The central feature of NumPy is the array object class. Arrays are similar to lists in Python, except that every element of an array must be of the same type, typically a numeric type like float or int. Arrays make operations with large amounts of numeric data very fast and are generally much more efficient than lists.\"\n",
    "\n",
    "LINK: https://engineering.ucsb.edu/~shell/che210d/numpy.pdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = \"http://community.datacamp.com.s3.amazonaws.com/community/production/ckeditor_assets/pictures/332/content_arrays-axes.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Array Syntax\n",
    "The function array takes two arguments: the list to be converted into the array and the type of each member of the list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#List to be converted\n",
    "lst = [1,2,3,4,5,6,7,8,9]\n",
    "\n",
    "arr = np.array(lst)\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Array elements are accessed, sliced, and manipulated just like lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Index from the 2nd index on\n",
    "arr[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10,  2,  3,  4,  5,  6,  7,  8,  9])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#manipulate item at index 0\n",
    "arr[0] = 10\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<b>* Why can't we simply use a python list for these scientific computations?<b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python List VS NumPy Array\n",
    "\n",
    "\"Arrays and lists are both used in Python to store data, but they don't serve exactly the same purposes. They both can be used to store any data type (real numbers, strings, etc), and they both can be indexed and iterated through, but the similarities between the two don't go much further. The main difference between a list and an array is the functions that you can perform to them. For example, you can divide an array by 3, and each number in the array will be divided by 3 and the result will be printed if you request it. If you try to divide a list by 3, Python will tell you that it can't be done, and an error will be thrown.\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'list' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-68-f77ccc9ee967>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mlst\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m9\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m12\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m15\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m18\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m12\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mlst\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'list' and 'int'"
     ]
    }
   ],
   "source": [
    "lst = [3,6,9,12,15,18,12]\n",
    "lst/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([3,6,9,12,15,18,12])\n",
    "arr/3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays can be multidimensional. Unlike lists, different axes are accessed using commas inside bracket notation. Here is an example with a two-dimensional array (e.g., a matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4, 5],\n",
       "       [5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst1 = [1,2,3,4,5]\n",
    "lst2 = [5,6,7,8,9]\n",
    "arr = np.array([lst1,lst2])\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.33333333, 0.66666667, 1.        , 1.33333333, 1.66666667,\n",
       "       2.        , 2.33333333, 2.66666667, 3.        ])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9]]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst_lst = [lst1,lst2]\n",
    "lst_lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'list' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-88-66863a021a51>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlst_lst\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'list' and 'int'"
     ]
    }
   ],
   "source": [
    "lst_lst/3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Indexing Arrays VS Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10,  2,  3,  4,  5,  6,  7,  8,  9])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[0][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9]]"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst_lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'lst_lst' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-86-bbf7ca5ac872>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlst_lst\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'lst_lst' is not defined"
     ]
    }
   ],
   "source": [
    "lst_lst[0,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst_lst[0][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst_lst[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4, 5],\n",
       "       [5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> How to index a multidemsional array? </h3><br>\n",
    "The individual elements of arrays can be accessed in the same way as for lists.\n",
    "\n",
    "<img src = \"http://www.scipy-lectures.org/_images/numpy_indexing.png\" height = 60% width = 60%>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_2d = [[0,1,2,3,4,5],\n",
    "           [10,11,12,13,14,15],\n",
    "           [20,21,22,23,24,25],\n",
    "           [30,31,32,33,34,35],\n",
    "           [40,41,42,43,44,45],\n",
    "           [50,51,52,53,54,55]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4  5]\n",
      " [10 11 12 13 14 15]\n",
      " [20 21 22 23 24 25]\n",
      " [30 31 32 33 34 35]\n",
      " [40 41 42 43 44 45]\n",
      " [50 51 52 53 54 55]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(6, 6)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_2d = np.array(list_2d)\n",
    "print(array_2d)\n",
    "array_2d.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 4]\n"
     ]
    }
   ],
   "source": [
    "print(array_2d[0,3:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[44 45]\n",
      " [54 55]]\n"
     ]
    }
   ],
   "source": [
    "print(array_2d[4:,4:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2 12 22 32 42 52]\n"
     ]
    }
   ],
   "source": [
    "print(array_2d[:,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[20 22 24]\n",
      " [40 42 44]]\n"
     ]
    }
   ],
   "source": [
    "print(array_2d[2::2,::2]) # step by 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "# adding new column to numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5.25 15.75 26.25 36.75 47.25 57.75]\n"
     ]
    }
   ],
   "source": [
    "calc = array_2d[:,5] * 1.05\n",
    "#new_column = np.array(calc)\n",
    "np.array(calc)\n",
    "#print(new_column)\n",
    "print(calc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.    1.    2.    3.    4.    5.    5.25]\n",
      " [10.   11.   12.   13.   14.   15.   15.75]\n",
      " [20.   21.   22.   23.   24.   25.   26.25]\n",
      " [30.   31.   32.   33.   34.   35.   36.75]\n",
      " [40.   41.   42.   43.   44.   45.   47.25]\n",
      " [50.   51.   52.   53.   54.   55.   57.75]]\n"
     ]
    }
   ],
   "source": [
    "#new_array_2d = np.column_stack((array_2d,new_column))\n",
    "new_array_2d = np.column_stack((array_2d,calc))\n",
    "print(new_array_2d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Changing Array to different DataType"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9]]"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = arr.tolist()\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4, 5],\n",
       "       [5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array(arr)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 5)"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Change Array Shape\n",
    "\n",
    "<img src = \"https://www.safaribooksonline.com/library/view/python-for-data/9781449323592/httpatomoreillycomsourceoreillyimages1346880.png\" height = 50% width = 30% style = display.left> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transposed versions of arrays can also be generated, which will create a new array with the final two axes switched:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4, 5],\n",
       "       [5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 5)"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 5],\n",
       "       [2, 6],\n",
       "       [3, 7],\n",
       "       [4, 8],\n",
       "       [5, 9]])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 2)"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.transpose().shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 5],\n",
       "       [6, 7],\n",
       "       [8, 9]])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.reshape((5,2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make multidimensional array into one-dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 5)"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10,)"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.flatten().shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create New Array (Specific)\n",
    "\n",
    "Numpy also provides many functions to create arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creates an array of all zeros with a specified shape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#1-Dimensional\n",
    "np.zeros(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0],\n",
       "       [0, 0]])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#2-Dimensional\n",
    "np.zeros((2,2), int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creates an array of all ones with a specified shape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#1-Dimensional\n",
    "np.ones(10, int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1.],\n",
       "       [1., 1.]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#2-Dimensional\n",
    "np.ones((2,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creates a constant array (specified number) with a specified shape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 7, 7, 7, 7, 7, 7, 7, 7, 7])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#1-Dimensional\n",
    "np.full(10,7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7, 7],\n",
       "       [7, 7]])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#2-Dimensional\n",
    "np.full((2, 2), 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Created an array of a specified shape with random values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.08175426, 0.8861075 , 0.74108718, 0.91054612, 0.24926835,\n",
       "       0.32773921, 0.42991257, 0.30222937, 0.05342004, 0.24071983])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#1-Dimensional\n",
    "np.random.random(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.39788404, 0.97631978],\n",
       "       [0.54156121, 0.66488147]])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#2-Dimensional\n",
    "np.random.random((2,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create an array of a specified length with evenly spaced values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#1-Dimensional\n",
    "np.arange(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create an array with a specified \"start\", \"stop\", and number of values, evenly spaced."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.        ,  1.47368421,  1.94736842,  2.42105263,  2.89473684,\n",
       "        3.36842105,  3.84210526,  4.31578947,  4.78947368,  5.26315789,\n",
       "        5.73684211,  6.21052632,  6.68421053,  7.15789474,  7.63157895,\n",
       "        8.10526316,  8.57894737,  9.05263158,  9.52631579, 10.        ])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#1-Dimensional\n",
    "np.linspace(1, 10, num = 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creates a 2x2 identity matrix (array).\n",
    "\n",
    "An identity matrix is a square matrix having 1s on the main diagonal, and 0s everywhere else. These are called identity matrices because, when you multiply them with a compatible matrix , you get back the same matrix.\n",
    "http://www.sparknotes.com/math/algebra2/matrices/section3.rhtml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#2-Dimensional\n",
    "np.eye(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#2-Dimensional\n",
    "np.identity(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Math Functions using NumPy\n",
    "\n",
    "\"As such, it probably won’t surprise you that you can just use +, -, *, / or % to add, subtract, multiply, divide or calculate the remainder of two (or more) arrays. However, a big part of why NumPy is so handy, is because it also has functions to do this. The equivalent functions of the operations that you have seen just now are, respectively, np.add(), np.subtract(), np.multiply(), np.divide() and np.remainder().\"\n",
    "\n",
    "https://www.datacamp.com/community/tutorials/python-numpy-tutorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.ones((10,10))\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.]])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add(arr,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.]])"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#OR\n",
    "arr + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.]])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.multiply(arr,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.]])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#OR\n",
    "arr*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.subtract(arr,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#OR\n",
    "arr -1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.divide(arr,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
       "       [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#OR\n",
    "arr/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.remainder(arr,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#OR\n",
    "arr % 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100.0"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color = magenta> NumPy Problem 1 </font>\n",
    "<font color = magenta>\n",
    "Create the three arrays displayed in the image, below.\n",
    "\n",
    "<img src = \"https://i.stack.imgur.com/ojnFF.jpg\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4 6 4]\n",
      " [1 1 8]\n",
      " [0 7 5]\n",
      " [5 3 3]\n",
      " [8 9 5]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(5, 3)"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Array 1\n",
    "lst1=[[4,6,4],[1,1,8],[0,7,5],[5,3,3],[8,9,5]]\n",
    "arr1=np.array(lst1)\n",
    "print(arr1)\n",
    "arr1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[8 8 4]\n",
      " [3 4 4]\n",
      " [0 0 9]\n",
      " [3 7 3]\n",
      " [3 4 7]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(5, 3)"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Array 2\n",
    "lst2=[[8,8,4],[3,4,4],[0,0,9],[3,7,3],[3,4,7]]\n",
    "arr2=np.array(lst2)\n",
    "print(arr2)\n",
    "arr2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9 5 4]\n",
      " [7 7 3]\n",
      " [9 5 9]\n",
      " [8 7 8]\n",
      " [5 8 8]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(5, 3)"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Array 3\n",
    "lst3=[[9,5,4],[7,7,3],[9,5,9],[8,7,8],[5,8,8]]\n",
    "arr3=np.array(lst3)\n",
    "print(arr3)\n",
    "arr3.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color = magenta> NumPy Problem 2 </font>\n",
    "<font color = magenta>\n",
    "Create a multidimensional array of your dimension choice and fill it random values(not filled manually)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.78908584, 0.11825321],\n",
       "       [0.84828395, 0.9189607 ],\n",
       "       [0.22493843, 0.42639609]])"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_prob2=np.random.random((3,2) )\n",
    "arr_prob2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the min and max values of your array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.11825320555713159\n",
      "0.9189606957149786\n"
     ]
    }
   ],
   "source": [
    "print(arr_prob2.min())\n",
    "\n",
    "print(arr_prob2.max())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color = magenta> NumPy Problem 3 </font>\n",
    "<font color = magenta>\n",
    "Create another multidimensional array of your dimension choice and fill it random values(not filled manually). Find the max value of your new array and replace it with your min value. Find the min value and replace it in your array with the max value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array is :\n",
      "[[3 4 0]\n",
      " [1 4 1]]\n",
      "Replace maximum with minimum:\n",
      "[[3 0 0]\n",
      " [1 0 1]]\n",
      "Replace minimum with maximum:\n",
      "[[3 4 4]\n",
      " [1 4 1]]\n"
     ]
    }
   ],
   "source": [
    "arr_prob3=np.random.randint(6,size=(2,3))\n",
    "maximum=arr_prob3.max()\n",
    "mimimum=arr_prob3.min()\n",
    "\n",
    "print('Original array is :')\n",
    "print(arr_prob3)\n",
    "\n",
    "arr_prob3[arr_prob3 == maximum] = minimum\n",
    "print('Replace maximum with minimum:')\n",
    "print(arr_prob3)\n",
    "\n",
    "arr_prob3[arr_prob3 == minimum] = maximum\n",
    "print('Replace minimum with maximum:')\n",
    "print(arr_prob3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color = magenta> NumPy Problem 4 </font>\n",
    "\n",
    "Create a random vector of size 10 and sort it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Originial array:\n",
      "\n",
      "\n",
      "[0.67590614 0.14435186 0.35539804 0.38544747 0.36629905 0.33181565\n",
      " 0.81860145 0.69817376 0.18203424 0.66343208]\n",
      "Sorted array:\n",
      "[0.14435186 0.18203424 0.33181565 0.35539804 0.36629905 0.38544747\n",
      " 0.66343208 0.67590614 0.69817376 0.81860145]\n"
     ]
    }
   ],
   "source": [
    "#just a list (single dimension) of random numbers and then sort\n",
    "arr_prob4= np.random.rand(10)\n",
    "print('Originial array:')\n",
    "print(arr_prob4)\n",
    "arr_prob4.sort()\n",
    "print('Sorted array:')\n",
    "print(arr_prob4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color = magenta> NumPy Problem 5 </font>\n",
    "\n",
    "<font color = magenta>\n",
    "How to swap two rows of an array?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array:\n",
      "[[9 5 4]\n",
      " [7 7 3]\n",
      " [9 5 9]\n",
      " [8 7 8]\n",
      " [5 8 8]]\n",
      "Swap row 0 with row 5\n",
      "[[5 8 8]\n",
      " [7 7 3]\n",
      " [9 5 9]\n",
      " [8 7 8]\n",
      " [5 8 8]]\n"
     ]
    }
   ],
   "source": [
    "#Use arr3 from Problem 1\n",
    "print('Original array:')\n",
    "print(arr3)\n",
    "print('Swap row 0 with row 5')\n",
    "temp=arr3[0]\n",
    "arr3[0] = arr3[4]\n",
    "arr3[4] = temp\n",
    "print(arr3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Numpy with Bay Area housing data set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_file_housing(filename):\n",
    "    file_open = open(filename,\"r\")\n",
    "    fixed_file = open(\"fixed-housing-data.csv\",\"w\")\n",
    "    line_count = 0\n",
    "    for line in iter(file_open):\n",
    "        line_count += 1\n",
    "        if \"HomeID\" in line:\n",
    "            continue\n",
    "        line_no_newline = line.rstrip()\n",
    "        line1 = line_no_newline.replace(\"84085\",\"94085\") #Ex9\n",
    "        line2 = line1.replace(\"84087\",\"94087\") #Ex9\n",
    "        line3 = line2.replace(\"85014\",\"95014\") #Ex9\n",
    "        line4 = line3.replace(\"85051\",\"95051\") #Ex9\n",
    "        line5 = line4.replace(\"l\",\"1\") #Ex11 -- Car_Garage\n",
    "        line_split = line5.split(\",\")\n",
    "        if (int(line_split[5]) < 100): #Ex10 -- School_API\n",
    "            line_split[5] = int(line_split[5]) * 10\n",
    "        else:\n",
    "            line_split[5] = int(line_split[5])\n",
    "        line_split = [str(x) for x in line_split]\n",
    "        myString = \",\".join(line_split) + \"\\n\"\n",
    "        fixed_file.write(myString)\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [],
   "source": [
    "read_file_housing(\"bayarea_home_prices.csv.xls\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "0 = HomeID\n",
    "1 = HomeAge\n",
    "2 = HomeSqft\n",
    "3 = LotSize\n",
    "4 = BedRooms\n",
    "5 = HighSchoolAPI\n",
    "6 = ProxFwy\n",
    "7 = CarGarage\n",
    "8 = ZipCode\n",
    "9 = HomePriceK\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "housing = np.loadtxt(\"fixed-housing-data.csv\",\n",
    "                          dtype=int,\n",
    "                          delimiter=\",\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[    1    24  1757  6056     2   899     3     3 94085   894]\n",
      " [    2    10  1563  6085     2   959     4     3 94085   861]]\n"
     ]
    }
   ],
   "source": [
    "print(housing[0:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(100, 10)\n"
     ]
    }
   ],
   "source": [
    "print(housing.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 894  861  831  809  890  867  843  820  874  885  903  912  933  865\n",
      "  918  950  882  896  942  859  904  912  916  972  908  934  914  949\n",
      "  919  953  991 1049 1042  994 1030 1019 1044 1038 1024  976 1115 1128\n",
      " 1071 1059 1000 1185 1015 1114 1138 1068 1068 1097 1074 1114 1075 1130\n",
      " 1116 1103 1080 1150 1177 1149 1163 1132 1138 1199 1179 1173 1128 1165\n",
      " 1233 1180 1240 1242 1184 1173 1194 1181 1190 1182 1221 1288 1275 1300\n",
      " 1272 1294 1219 1282 1256 1205 1252 1294 1269 1335 1267 1307 1336 1284\n",
      " 1269 1250]\n"
     ]
    }
   ],
   "source": [
    "# home prices\n",
    "print(housing[:,9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 904  871  841  819  900  877  853  830  884  895  913  922  943  875\n",
      "  928  960  892  906  952  869  914  922  926  982  918  944  924  959\n",
      "  929  963 1001 1059 1052 1004 1040 1029 1054 1048 1034  986 1125 1138\n",
      " 1081 1069 1010 1195 1025 1124 1148 1078 1078 1107 1084 1124 1085 1140\n",
      " 1126 1113 1090 1160 1187 1159 1173 1142 1148 1209 1189 1183 1138 1175\n",
      " 1243 1190 1250 1252 1194 1183 1204 1191 1200 1192 1231 1298 1285 1310\n",
      " 1282 1304 1229 1292 1266 1215 1262 1304 1279 1345 1277 1317 1346 1294\n",
      " 1279 1260]\n"
     ]
    }
   ],
   "source": [
    "print(housing[:,9] + 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[   5050    1720  161528  784050     271   90443     310     152 9455925\n",
      "  108099]\n"
     ]
    }
   ],
   "source": [
    "print(housing.sum(axis=0)) # sum by columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[103724 103574 103240 103224 103896 103638 104044 103869 103609 104170\n",
      " 104094 103592 103978 104376 104062 105595 104218 104335 104940 104012\n",
      " 104075 104583 104684 105583 104958 104446 104876 105593 104503 106006\n",
      " 105990 106058 106256 105929 106298 105629 106320 106196 106023 106261\n",
      " 105369 105445 106369 105987 105936 105549 106606 105320 105358 106782\n",
      " 106365 106479 106225 105461 106713 105795 106138 105594 106827 105847\n",
      " 105796 106180 105869 105800 106169 107018 106669 106315 106430 106551\n",
      " 107465 106524 107181 107608 106533 107139 107961 106805 106554 106595\n",
      " 107843 107864 108077 107983 108182 108227 107735 107879 108478 108106\n",
      " 107902 108487 107956 108654 108172 108678 108406 108111 108617 108407]\n"
     ]
    }
   ],
   "source": [
    "print(housing.sum(axis=1)) # sum by rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [],
   "source": [
    "homes_94085 = (housing[:,8] == 94085)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True  True  True  True  True  True  True  True  True  True  True  True\n",
      "  True  True  True False  True  True False  True  True  True  True False\n",
      "  True  True  True False  True False False False False False False False\n",
      " False False False False False False False False False False False False\n",
      " False False False False False False False False False False False False\n",
      " False False False False False False False False False False False False\n",
      " False False False False False False False False False False False False\n",
      " False False False False False False False False False False False False\n",
      " False False False False]\n"
     ]
    }
   ],
   "source": [
    "print(homes_94085)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[    1    24  1757  6056     2   899     3     3 94085   894]\n",
      " [    2    10  1563  6085     2   959     4     3 94085   861]\n",
      " [    3    14  1344  6089     2   865     4     3 94085   831]\n",
      " [    4    14  1215  6129     3   959     4     2 94085   809]\n",
      " [    5    24  1866  6141     3   877     4     1 94085   890]\n",
      " [    6    18  1589  6148     2   920     3     0 94085   867]\n",
      " [    7    13  1947  6183     3   959     3     1 94085   843]\n",
      " [    8    19  1839  6186     3   905     4     0 94085   820]\n",
      " [    9    17  1501  6233     2   884     3     1 94085   874]\n",
      " [   10    24  1933  6276     2   950     4     1 94085   885]\n",
      " [   11    12  1798  6346     3   931     3     2 94085   903]\n",
      " [   12    22  1221  6430     3   904     2     1 94085   912]\n",
      " [   13    15  1541  6514     2   872     2     1 94085   933]\n",
      " [   14    25  1974  6547     2   857     4     3 94085   865]\n",
      " [   15    10  1510  6633     2   884     3     2 94085   918]\n",
      " [   17    23  1464  6773     3   965     4     2 94085   882]\n",
      " [   18    16  1572  6809     2   935     2     0 94085   896]\n",
      " [   20    13  1358  6819     2   851     3     2 94085   859]\n",
      " [   21    17  1246  6870     3   922     4     3 94085   904]\n",
      " [   22    10  1752  6892     3   904     3     0 94085   912]\n",
      " [   23    15  1828  6956     3   851     4     3 94085   916]\n",
      " [   25    21  1991  7022     2   900     3     1 94085   908]\n",
      " [   26    12  1500  7025     2   856     4     2 94085   934]\n",
      " [   27    13  1836  7027     2   966     3     3 94085   914]\n",
      " [   29    17  1446  7098     2   900     4     3 94085   919]]\n",
      "(25, 10)\n"
     ]
    }
   ],
   "source": [
    "data_94085 = housing[homes_94085,][:,:]\n",
    "print(data_94085)\n",
    "print(data_94085.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22149\n"
     ]
    }
   ],
   "source": [
    "sum_price_94085 = data_94085[:,9].sum()\n",
    "print(sum_price_94085)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "885.96\n",
      "885.96\n"
     ]
    }
   ],
   "source": [
    "average_94085 = sum_price_94085/np.size(data_94085,0)\n",
    "average_94085_1 = sum_price_94085/25\n",
    "print(average_94085)\n",
    "print(average_94085_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Problem 6\n",
    "### Calculate average price in each zip code: 94085, 94087, 95014, 95051\n",
    "### Calculate minimum and max price in each zip code: 94085, 94087, 95014, 95051\n",
    "### Calculate standard deviation of price in each zip code: 94085, 94087, 95014, 95051"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Price in 94087:1151.48\n",
      "Minimum in 94087:1103\n",
      "Maximum in 94087:1190\n",
      "Standard Deviation in 94087:27.57\n",
      "\n",
      "\n",
      "Average Price in 95014:1263.32\n",
      "Minimum in 95014:1194\n",
      "Maximum in 95014:1336\n",
      "Standard Deviation in 95014:37.74\n",
      "\n",
      "\n",
      "Average Price in 95051:1023.2\n",
      "Minimum in 95051:942\n",
      "Maximum in 95051:1097\n",
      "Standard Deviation in 95051:46.04\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "homes_94087 = (housing[:,8] == 94087)\n",
    "homes_95014 = (housing[:,8] == 95014)\n",
    "homes_95051 = (housing[:,8] == 95051)\n",
    "\n",
    "data_94087=housing[homes_94087,][:,:]\n",
    "data_95014=housing[homes_95014,][:,:]\n",
    "data_95051=housing[homes_95051,][:,:]\n",
    "\n",
    "average_94087=data_94087[:,9].sum()/np.size(data_94087,0)\n",
    "min_94087=data_94087[:,9].min()\n",
    "max_94087=data_94087[:,9].max()\n",
    "std_94087=round(data_94087[:,9].std(),2)\n",
    "print('Average Price in 94087:' + str(average_94087))\n",
    "print('Minimum in 94087:' + str(min_94087))\n",
    "print('Maximum in 94087:' + str(max_94087))\n",
    "print('Standard Deviation in 94087:' + str(std_94087))\n",
    "print('\\n')\n",
    "\n",
    "average_95014=data_95014[:,9].sum()/np.size(data_95014,0)\n",
    "min_95014=data_95014[:,9].min()\n",
    "max_95014=data_95014[:,9].max()\n",
    "std_95014=round(data_95014[:,9].std(),2)\n",
    "print('Average Price in 95014:' + str(average_95014))\n",
    "print('Minimum in 95014:' + str(min_95014))\n",
    "print('Maximum in 95014:' + str(max_95014))\n",
    "print('Standard Deviation in 95014:' + str(std_95014))\n",
    "print('\\n')\n",
    "\n",
    "average_95051=data_95051[:,9].sum()/np.size(data_95051,0)\n",
    "min_95051=data_95051[:,9].min()\n",
    "max_95051=data_95051[:,9].max()\n",
    "std_95051=round(data_95051[:,9].std(),2)\n",
    "print('Average Price in 95051:' + str(average_95051))\n",
    "print('Minimum in 95051:' + str(min_95051))\n",
    "print('Maximum in 95051:' + str(max_95051))\n",
    "print('Standard Deviation in 95051:' + str(std_95051))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[   65    14  1617  8394     2   850     2     0 94087  1138]\n",
      " [   73    25  1302  8668     3   850     4     2 95014  1240]\n",
      " [   23    15  1828  6956     3   851     4     3 94085   916]\n",
      " [   20    13  1358  6819     2   851     3     2 94085   859]\n",
      " [   79    17  1373  8953     2   851     2     0 94087  1190]\n",
      " [   77    17  1881  8921     3   852     2     0 95014  1194]\n",
      " [   19    10  1246  6810     2   853     4     3 95051   942]\n",
      " [   32    18  1866  7181     2   854     2     3 95051  1049]\n",
      " [   95    13  1582  9339     3   856     3     0 95014  1267]\n",
      " [   26    12  1500  7025     2   856     4     2 94085   934]\n",
      " [   99    19  1880  9470     3   857     3     3 95014  1269]\n",
      " [   53    23  1289  7873     2   857     3     0 95051  1074]\n",
      " [   67    24  1947  8502     2   857     4     0 94087  1179]\n",
      " [  100    11  1691  9476     4   857     4     0 95014  1250]\n",
      " [   14    25  1974  6547     2   857     4     3 94085   865]\n",
      " [   44    11  1415  7541     3   859     4     0 95051  1059]\n",
      " [   85    22  1757  9163     3   861     2     3 95014  1272]\n",
      " [   94    21  1983  9337     4   862     2     2 95014  1335]\n",
      " [    3    14  1344  6089     2   865     4     3 94085   831]\n",
      " [   52    25  1535  7847     2   867     3     0 95051  1097]\n",
      " [   42    21  1836  7458     2   867     4     0 94087  1128]\n",
      " [   64    12  1249  8378     3   868     4     3 94087  1132]\n",
      " [   62    19  1672  8318     3   868     2     0 94087  1149]\n",
      " [   13    15  1541  6514     2   872     2     1 94085   933]\n",
      " [   74    17  1680  8698     2   875     3     3 95014  1242]\n",
      " [   56    11  1669  7958     3   876     4     1 94087  1130]\n",
      " [   82    19  1480  9095     4   877     4     1 95014  1288]\n",
      " [    5    24  1866  6141     3   877     4     1 94085   890]\n",
      " [   90    14  1652  9245     4   879     3     0 95014  1205]\n",
      " [   87    18  1314  9195     4   881     3     0 95014  1219]\n",
      " [   70    16  1739  8585     2   881     3     3 94087  1165]\n",
      " [   89    21  1994  9215     4   881     4     0 95014  1256]\n",
      " [   58    19  1382  8054     2   883     4     2 94087  1103]\n",
      " [   80    11  1370  8974     2   883     3     3 94087  1182]\n",
      " [   15    10  1510  6633     2   884     3     2 94085   918]\n",
      " [    9    17  1501  6233     2   884     3     1 94085   874]\n",
      " [   54    12  1401  7897     3   888     4     1 94087  1114]\n",
      " [   71    19  1615  8617     3   889     2     2 95014  1233]\n",
      " [   49    12  1385  7793     2   889     3     0 94087  1138]\n",
      " [   55    10  1721  7902     3   890     3     3 95051  1075]\n",
      " [   48    22  1420  7733     3   890     2     1 94087  1114]\n",
      " [   40    15  1883  7396     2   891     4     3 95051   976]\n",
      " [   28    10  1581  7073     3   892     4     2 95051   949]\n",
      " [   72    24  1643  8619     2   893     3     1 94087  1180]\n",
      " [   81    18  1524  9081     4   894     3     3 95014  1221]\n",
      " [   16    20  1979  6680     2   894     3     0 95051   950]\n",
      " [    1    24  1757  6056     2   899     3     3 94085   894]\n",
      " [   25    21  1991  7022     2   900     3     1 94085   908]\n",
      " [   29    17  1446  7098     2   900     4     3 94085   919]\n",
      " [   61    13  1432  8121     2   900     3     0 94087  1177]\n",
      " [   47    21  1871  7693     2   901     2     3 95051  1015]\n",
      " [   66    25  1358  8446     3   902     2     3 95014  1199]\n",
      " [   60    19  1522  8098     2   903     4     2 94087  1150]\n",
      " [   22    10  1752  6892     3   904     3     0 94085   912]\n",
      " [   12    22  1221  6430     3   904     2     1 94085   912]\n",
      " [    8    19  1839  6186     3   905     4     0 94085   820]\n",
      " [   24    10  1598  7011     2   911     3     1 95051   972]\n",
      " [   96    11  1981  9350     4   912     2     1 95014  1307]\n",
      " [   43    17  1773  7495     2   913     3     1 95051  1071]\n",
      " [   98    21  1312  9456     4   915     4     3 95014  1284]\n",
      " [   46    11  1639  7660     2   916     2     1 94087  1185]\n",
      " [   41    23  1754  7426     3   917     2     1 94087  1115]\n",
      " [   31    10  1843  7136     3   918     4     3 95051   991]\n",
      " [   92    18  1846  9292     4   920     4     3 95014  1294]\n",
      " [    6    18  1589  6148     2   920     3     0 94085   867]\n",
      " [   21    17  1246  6870     3   922     4     3 94085   904]\n",
      " [   86    19  1704  9179     4   924     3     0 95014  1294]\n",
      " [   36    14  1276  7303     2   925     3     0 95051  1019]\n",
      " [   78    25  1558  8942     3   927     4     0 94087  1181]\n",
      " [   63    25  1250  8348     2   928     3     0 94087  1163]\n",
      " [   88    22  1324  9211     4   929     2     3 95014  1282]\n",
      " [   84    25  1499  9122     4   931     4     0 95014  1300]\n",
      " [   11    12  1798  6346     3   931     3     2 94085   903]\n",
      " [   30    24  1893  7115     3   933     4     0 95051   953]\n",
      " [   18    16  1572  6809     2   935     2     0 94085   896]\n",
      " [   34    19  1659  7226     3   939     2     2 95051   994]\n",
      " [   75    14  1401  8825     3   940     2     2 94087  1184]\n",
      " [   68    12  1514  8512     3   940     3     3 94087  1173]\n",
      " [   91    16  1289  9289     4   941     3     3 95014  1252]\n",
      " [   83    24  1625  9106     3   941     3     3 95014  1275]\n",
      " [   93    25  1298  9309     3   942     3     0 95014  1269]\n",
      " [   97    10  1645  9352     4   942     3     3 95014  1336]\n",
      " [   39    22  1551  7388     2   942     2     2 95051  1024]\n",
      " [   51    19  1382  7841     2   948     3     0 95051  1068]\n",
      " [   50    19  1836  7803     3   949     3     0 95051  1068]\n",
      " [   10    24  1933  6276     2   950     4     1 94085   885]\n",
      " [   57    11  1927  7983     3   950     3     1 94087  1116]\n",
      " [   59    22  1559  8096     2   953     2     3 95051  1080]\n",
      " [   76    12  1947  8882     3   954     3     2 94087  1173]\n",
      " [    7    13  1947  6183     3   959     3     1 94085   843]\n",
      " [   33    11  1953  7199     3   959     3     2 95051  1042]\n",
      " [    4    14  1215  6129     3   959     4     2 94085   809]\n",
      " [    2    10  1563  6085     2   959     4     3 94085   861]\n",
      " [   45    15  1249  7609     3   960     2     2 95051  1000]\n",
      " [   37    13  1874  7333     3   960     3     2 95051  1044]\n",
      " [   69    21  1575  8579     2   962     4     3 94087  1128]\n",
      " [   17    23  1464  6773     3   965     4     2 94085   882]\n",
      " [   27    13  1836  7027     2   966     3     3 94085   914]\n",
      " [   35    12  1943  7249     2   974     2     0 95051  1030]\n",
      " [   38    22  1724  7339     3   975     3     3 95051  1038]]\n"
     ]
    }
   ],
   "source": [
    "h1 = housing[housing[:,5].argsort()] # by school_api ascending\n",
    "print(h1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[   38    22  1724  7339     3   975     3     3 95051  1038]\n",
      " [   35    12  1943  7249     2   974     2     0 95051  1030]\n",
      " [   27    13  1836  7027     2   966     3     3 94085   914]\n",
      " [   17    23  1464  6773     3   965     4     2 94085   882]\n",
      " [   69    21  1575  8579     2   962     4     3 94087  1128]\n",
      " [   37    13  1874  7333     3   960     3     2 95051  1044]\n",
      " [   45    15  1249  7609     3   960     2     2 95051  1000]\n",
      " [    2    10  1563  6085     2   959     4     3 94085   861]\n",
      " [    4    14  1215  6129     3   959     4     2 94085   809]\n",
      " [   33    11  1953  7199     3   959     3     2 95051  1042]\n",
      " [    7    13  1947  6183     3   959     3     1 94085   843]\n",
      " [   76    12  1947  8882     3   954     3     2 94087  1173]\n",
      " [   59    22  1559  8096     2   953     2     3 95051  1080]\n",
      " [   57    11  1927  7983     3   950     3     1 94087  1116]\n",
      " [   10    24  1933  6276     2   950     4     1 94085   885]\n",
      " [   50    19  1836  7803     3   949     3     0 95051  1068]\n",
      " [   51    19  1382  7841     2   948     3     0 95051  1068]\n",
      " [   39    22  1551  7388     2   942     2     2 95051  1024]\n",
      " [   97    10  1645  9352     4   942     3     3 95014  1336]\n",
      " [   93    25  1298  9309     3   942     3     0 95014  1269]\n",
      " [   83    24  1625  9106     3   941     3     3 95014  1275]\n",
      " [   91    16  1289  9289     4   941     3     3 95014  1252]\n",
      " [   68    12  1514  8512     3   940     3     3 94087  1173]\n",
      " [   75    14  1401  8825     3   940     2     2 94087  1184]\n",
      " [   34    19  1659  7226     3   939     2     2 95051   994]\n",
      " [   18    16  1572  6809     2   935     2     0 94085   896]\n",
      " [   30    24  1893  7115     3   933     4     0 95051   953]\n",
      " [   11    12  1798  6346     3   931     3     2 94085   903]\n",
      " [   84    25  1499  9122     4   931     4     0 95014  1300]\n",
      " [   88    22  1324  9211     4   929     2     3 95014  1282]\n",
      " [   63    25  1250  8348     2   928     3     0 94087  1163]\n",
      " [   78    25  1558  8942     3   927     4     0 94087  1181]\n",
      " [   36    14  1276  7303     2   925     3     0 95051  1019]\n",
      " [   86    19  1704  9179     4   924     3     0 95014  1294]\n",
      " [   21    17  1246  6870     3   922     4     3 94085   904]\n",
      " [    6    18  1589  6148     2   920     3     0 94085   867]\n",
      " [   92    18  1846  9292     4   920     4     3 95014  1294]\n",
      " [   31    10  1843  7136     3   918     4     3 95051   991]\n",
      " [   41    23  1754  7426     3   917     2     1 94087  1115]\n",
      " [   46    11  1639  7660     2   916     2     1 94087  1185]\n",
      " [   98    21  1312  9456     4   915     4     3 95014  1284]\n",
      " [   43    17  1773  7495     2   913     3     1 95051  1071]\n",
      " [   96    11  1981  9350     4   912     2     1 95014  1307]\n",
      " [   24    10  1598  7011     2   911     3     1 95051   972]\n",
      " [    8    19  1839  6186     3   905     4     0 94085   820]\n",
      " [   12    22  1221  6430     3   904     2     1 94085   912]\n",
      " [   22    10  1752  6892     3   904     3     0 94085   912]\n",
      " [   60    19  1522  8098     2   903     4     2 94087  1150]\n",
      " [   66    25  1358  8446     3   902     2     3 95014  1199]\n",
      " [   47    21  1871  7693     2   901     2     3 95051  1015]\n",
      " [   61    13  1432  8121     2   900     3     0 94087  1177]\n",
      " [   29    17  1446  7098     2   900     4     3 94085   919]\n",
      " [   25    21  1991  7022     2   900     3     1 94085   908]\n",
      " [    1    24  1757  6056     2   899     3     3 94085   894]\n",
      " [   16    20  1979  6680     2   894     3     0 95051   950]\n",
      " [   81    18  1524  9081     4   894     3     3 95014  1221]\n",
      " [   72    24  1643  8619     2   893     3     1 94087  1180]\n",
      " [   28    10  1581  7073     3   892     4     2 95051   949]\n",
      " [   40    15  1883  7396     2   891     4     3 95051   976]\n",
      " [   48    22  1420  7733     3   890     2     1 94087  1114]\n",
      " [   55    10  1721  7902     3   890     3     3 95051  1075]\n",
      " [   49    12  1385  7793     2   889     3     0 94087  1138]\n",
      " [   71    19  1615  8617     3   889     2     2 95014  1233]\n",
      " [   54    12  1401  7897     3   888     4     1 94087  1114]\n",
      " [    9    17  1501  6233     2   884     3     1 94085   874]\n",
      " [   15    10  1510  6633     2   884     3     2 94085   918]\n",
      " [   80    11  1370  8974     2   883     3     3 94087  1182]\n",
      " [   58    19  1382  8054     2   883     4     2 94087  1103]\n",
      " [   89    21  1994  9215     4   881     4     0 95014  1256]\n",
      " [   70    16  1739  8585     2   881     3     3 94087  1165]\n",
      " [   87    18  1314  9195     4   881     3     0 95014  1219]\n",
      " [   90    14  1652  9245     4   879     3     0 95014  1205]\n",
      " [    5    24  1866  6141     3   877     4     1 94085   890]\n",
      " [   82    19  1480  9095     4   877     4     1 95014  1288]\n",
      " [   56    11  1669  7958     3   876     4     1 94087  1130]\n",
      " [   74    17  1680  8698     2   875     3     3 95014  1242]\n",
      " [   13    15  1541  6514     2   872     2     1 94085   933]\n",
      " [   62    19  1672  8318     3   868     2     0 94087  1149]\n",
      " [   64    12  1249  8378     3   868     4     3 94087  1132]\n",
      " [   42    21  1836  7458     2   867     4     0 94087  1128]\n",
      " [   52    25  1535  7847     2   867     3     0 95051  1097]\n",
      " [    3    14  1344  6089     2   865     4     3 94085   831]\n",
      " [   94    21  1983  9337     4   862     2     2 95014  1335]\n",
      " [   85    22  1757  9163     3   861     2     3 95014  1272]\n",
      " [   44    11  1415  7541     3   859     4     0 95051  1059]\n",
      " [   14    25  1974  6547     2   857     4     3 94085   865]\n",
      " [  100    11  1691  9476     4   857     4     0 95014  1250]\n",
      " [   67    24  1947  8502     2   857     4     0 94087  1179]\n",
      " [   53    23  1289  7873     2   857     3     0 95051  1074]\n",
      " [   99    19  1880  9470     3   857     3     3 95014  1269]\n",
      " [   26    12  1500  7025     2   856     4     2 94085   934]\n",
      " [   95    13  1582  9339     3   856     3     0 95014  1267]\n",
      " [   32    18  1866  7181     2   854     2     3 95051  1049]\n",
      " [   19    10  1246  6810     2   853     4     3 95051   942]\n",
      " [   77    17  1881  8921     3   852     2     0 95014  1194]\n",
      " [   79    17  1373  8953     2   851     2     0 94087  1190]\n",
      " [   20    13  1358  6819     2   851     3     2 94085   859]\n",
      " [   23    15  1828  6956     3   851     4     3 94085   916]\n",
      " [   73    25  1302  8668     3   850     4     2 95014  1240]\n",
      " [   65    14  1617  8394     2   850     2     0 94087  1138]]\n"
     ]
    }
   ],
   "source": [
    "h2 = housing[housing[:,5].argsort()[::-1]] # by school_api descending\n",
    "print(h2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Problem 7\n",
    "### Find top-2 listings by School API for all zipcodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top2_API_94087:\n",
      "[[   69    21  1575  8579     2   962     4     3 94087  1128]\n",
      " [   76    12  1947  8882     3   954     3     2 94087  1173]]\n",
      "Top2_API_94085:\n",
      "[[   27    13  1836  7027     2   966     3     3 94085   914]\n",
      " [   17    23  1464  6773     3   965     4     2 94085   882]]\n",
      "Top2_api_95014:\n",
      "[[   97    10  1645  9352     4   942     3     3 95014  1336]\n",
      " [   93    25  1298  9309     3   942     3     0 95014  1269]]\n",
      "Top2_api_95051:\n",
      "[[   38    22  1724  7339     3   975     3     3 95051  1038]\n",
      " [   35    12  1943  7249     2   974     2     0 95051  1030]]\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "#filter by zipcode and then sort\n",
    "#h2 = housing[housing[:,5].argsort()[::-1]]\n",
    "api_94087=data_94087[data_94087[:,5].argsort()[::-1]]\n",
    "print(\"Top2_API_94087:\" )\n",
    "print(api_94087[0:2])\n",
    "\n",
    "api_94085=data_94085[data_94085[:,5].argsort()[::-1]]\n",
    "print(\"Top2_API_94085:\")\n",
    "print(api_94085[0:2])\n",
    "\n",
    "api_95014=data_95014[data_95014[:,5].argsort()[::-1]]\n",
    "print(\"Top2_api_95014:\")\n",
    "print(api_95014[0:2])\n",
    "\n",
    "api_95051=data_95051[data_95051[:,5].argsort()[::-1]]\n",
    "print(\"Top2_api_95051:\")\n",
    "print(api_95051[0:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Problem 8\n",
    "### Prices are expected to go up by 4% next year.\n",
    "### Add another column with predicted prices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[    1.      24.    1757.    6056.       2.     899.       3.       3.\n",
      "  94085.     894.     929.76]\n",
      " [    2.      10.    1563.    6085.       2.     959.       4.       3.\n",
      "  94085.     861.     895.44]]\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "\n",
    "\n",
    "#print(housing[0:2])\n",
    "p_price = housing[:,9] * 1.04\n",
    "new_column1=np.array(p_price)\n",
    "\n",
    "#np.set_printoptions(formatter={'float_kind':'{:f}'.format})\n",
    "np.set_printoptions(suppress=True)\n",
    "new_housing = np.column_stack((housing,new_column1))\n",
    "print(new_housing[0:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Problem 9\n",
    "### Sort the matrix based on HomePrices . Save the updated numpy matrix with added column in Problem 8 to a file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before Saving:\n",
      "[[    4.      14.    1215.    6129.       3.     959.       4.       2.\n",
      "  94085.     809.     841.36]\n",
      " [    8.      19.    1839.    6186.       3.     905.       4.       0.\n",
      "  94085.     820.     852.8 ]]\n",
      "After Save-Read:\n",
      "[[    4.      14.    1215.    6129.       3.     959.       4.       2.\n",
      "  94085.     809.     841.36]\n",
      " [    8.      19.    1839.    6186.       3.     905.       4.       0.\n",
      "  94085.     820.     852.8 ]]\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "#Sorting new_housing based on HomePrices in Acsending order\n",
    "sorted_housing= new_housing[new_housing[:,9].argsort()]\n",
    "print(\"Before Saving:\")\n",
    "print(sorted_housing[0:2])\n",
    "np.savetxt('sorted_housing.txt',sorted_housing)\n",
    "after_save=np.loadtxt('sorted_housing.txt')\n",
    "print (\"After Save-Read:\")\n",
    "print(after_save[0:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color = magenta> NumPy Problem 10 </font>\n",
    "\n",
    "Write a function that takes a long string containing multiple words. Print the same string, except with the words in backwards order. \n",
    "\n",
    "<i>HINT: Use <b>YOUR_STRING<code>.split()</code></b> function<br></i>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original String: We do not worry about grade in this class.\n",
      "Bacwards String: Class this in grade about worry not do we.\n"
     ]
    }
   ],
   "source": [
    "mystring = \"We do not worry about grade in this class.\"\n",
    "words=mystring.split()\n",
    "#print(words)\n",
    "indx=len(words)-1\n",
    "back_str=\"\"\n",
    "for i in range(indx,-1,-1):\n",
    "    back_str=back_str + words[i]+\" \"\n",
    "\n",
    "back_str=back_str.capitalize()\n",
    "back_str=back_str.rstrip()\n",
    "period=back_str.find('.')\n",
    "#back_str.replace(\".\",\"\")\n",
    "print(\"Original String: \" +mystring)\n",
    "print(\"Bacwards String: \" +back_str[0:period] + back_str[period+1:]+ back_str[period])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}