solutions/3_Numpy_1_Solution.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge Problem "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Part 1: What is the benefit of numpy arrays? \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Part 1a: Numpy arrays are efficient! \n",
    "\n",
    "Say we want to convert a list of heights in inches to heights in centimeters \n",
    "\n",
    "Uses the conversion 1 inch = 2.54 cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "height_in = [60, 72, 65, 64]\n",
    "unit_conv = 2.54"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wouldn't it be nice if there was a simple command to multiply each element of our list, height_in, by our converstion factor, 2.54. \n",
    "\n",
    "Try running this line of code to see if it works. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can't multiply sequence by non-int of type 'float'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-12-df031e499546>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mheight_cm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mheight_in\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0munit_conv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'float'"
     ]
    }
   ],
   "source": [
    "height_cm = height_in * unit_conv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you saw, you got an error 'can't multiply sequence by non-int of type 'float''\n",
    "\n",
    "Understand that error by using the FUNCTIONS print() and type() to print the object types of height_in and unit_conv. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(height_in))\n",
    "print(type(unit_conv))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So we'll have to try another strategy to create a list of heights in cm, height_cm. \n",
    "\n",
    "Intialize a list called height_cm. \n",
    "\n",
    "Use the METHOD (a FUNCTION that \"belongs\" to an object) .append() to convert each element of height_in to a measurement of height in cm. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[152.4, 182.88, 165.1, 162.56]\n"
     ]
    }
   ],
   "source": [
    "height_cm = list()\n",
    "\n",
    "height_cm.append(height_in[0] * 2.54)\n",
    "height_cm.append(height_in[1] * 2.54)\n",
    "height_cm.append(height_in[2] * 2.54)\n",
    "height_cm.append(height_in[3] * 2.54)\n",
    "\n",
    "print(height_cm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That was a lot of lines of code to do a simple task! We'll see in  future lessons that we could automate this process (of typing each line manually) using LOOPS. \n",
    "\n",
    "But there is actually an even easier (and more efficient) way to do this using the PACKAGE, numpy. \n",
    "\n",
    "Import the PACKAGE numpy. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "You can import numpy with the command: \n",
    "import numpy \n",
    "Then you would have to type out numpy.array, for example to create a numpy array \n",
    "\n",
    "But you can change how you call numpy by importing NUMPY as a name with the command: \n",
    "import numpy as NAME \n",
    "(typically the name you'll see is np) \n",
    "\n",
    "But just a note you can import numpy as ANY name...even your own name, but that wouldn't be that logical or efficient. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert your list, height_in to a numpy ARRAY. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "height_np = np.array(height_in)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can do that simple command we wanted to do before with our list but could not. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "height_np_cm = height_np * unit_conv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(height_np_cm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Part 1b: Numpy arrays are faster!  \n",
    "\n",
    "Say we wanted to add two long lists of numbers together. It would take much less time if we used numpy arrays instead of lists! The following block of code will show you just that--   numpy arrays allow for more efficient calculations than lists. \n",
    "\n",
    "Note that some of the concepts in this block of code you haven't seen before. Try to understand what is going and then run the code! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python list took 1.0505850315093994\n",
      "numpy list took 0.2186439037322998\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "SIZE = 10000000\n",
    "\n",
    "#REGULAR PYTHON LISTS, L1 and L2\n",
    "#range(SIZE) makes a list of numbers from 1 to the variable SIZE, which equals 10000000\n",
    "L1 = range(SIZE)\n",
    "L2 = range(SIZE)\n",
    "\n",
    "#NUMPY ARRAYS, N1 and N2\n",
    "#np.arange(SIZE) makes a numpy array of numbers from 1 to the variable SIZE, which equals 10000000 \n",
    "N1 = np.arange(SIZE)\n",
    "N2 = np.arange(SIZE)\n",
    "\n",
    "#Record the start time in the variable, start \n",
    "start = time.time()\n",
    "#add the two python lists, L1 and L2 using loops and store in result \n",
    "result = [x+y for x,y in zip(L1,L2)]\n",
    "#print how long the addition took! \n",
    "print(\"python list took\", time.time()-start)\n",
    "\n",
    "#Record the start time in the variable, start \n",
    "start = time.time()\n",
    "#add the two numpy arrays, N1 and N2 and store in result \n",
    "result = N1+N2\n",
    "#print how long the addition took! \n",
    "print(\"numpy list took\",time.time()-start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PART 2: Let's work with numpy arrays, functions, and methods! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_array = np.array([[100, 125, 115, 104], [1.0, 3.4, 2.7, 5.5], [15,  15,  24,  5  ]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the max in the first list using the METHOD np.max(). Store answer in the VARIABLE max_first and print with the FUNCTION print. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "125.0\n"
     ]
    }
   ],
   "source": [
    "max_first  = np.max(my_array[0])\n",
    "print(max_first)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the min in the second list using the METHOD np.min(). Store answer in the VARIABLE min_second and print with the FUNCTION print. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "min_second = np.min(my_array[1])\n",
    "print(min_second)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the METHOD np.sort() to sort the third list from smallest to largest. Store in the VARIABLE my_array3_sorted and print with the FUNCTION print.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  5.  15.  15.  24.]\n"
     ]
    }
   ],
   "source": [
    "my_array3_sorted = np.sort(my_array[2])\n",
    "print(my_array3_sorted)\n"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}