lecture_03_while_loops_lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Could not find kernel error?\n",
    "\n",
    "If you ever see a \"could not find a kernel for this notebook\" error message, it will offer you a pull down menu for you to pick a fitting kernel.\n",
    "\n",
    "Remember, `kernels` are the notebook's way to find the correct interpretor for the code you write into notebook cells. And these days this can be `R`, `Julia`, `Python` and several other things (Find the available kernels list [here](https://github.com/ipython/ipython/wiki/IPython-kernels-for-other-languages))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Review on your own time:  A few \"last\" things about types"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "We did some examples last class which illustrated the difference between integers and floats. \n",
    "\n",
    "Let's do one more using the conversion between Fahrenheit and Celsius as a test case.\n",
    "\n",
    "Recall the conversion formula:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$T_C = \\frac{5}{9} \\left(T_F - 32 \\right)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100.0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tempF = 212.0\n",
    "tempC = (5 / 9) * (tempF - 32.0)\n",
    "tempC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What will be printed?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Depending on Python version!\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What went wrong?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Nothing in Python 3, yay! ;)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### You can force variables to be certain types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 45\n",
    "type(x)  #  Gives (returns) the type of variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "45.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = float(x)\n",
    "print(type(x))\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What will this produce?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 26.9\n",
    "int(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Review continued:  One \"last\" note on modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4142135623730951\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import *\n",
    "import math\n",
    "print(sqrt(2))\n",
    "math.sqrt(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's using the exact same library twice, you just told Python 2 different ways to get to it.\n",
    "And there's even a way to prove it: With the `id()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4331469056"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(sqrt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4331469056"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(math.sqrt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see it's the same memory address (but this number is not necessarily the same on your computer), meaning the Python interpreter uses the exact same object twice, you just gave it 2 different names."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another syntax is available to import modules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  Import math module and give it a new name\n",
    "import math as m               #  Note the use of \"as\", a reserved word\n",
    "m.sqrt(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or specific functions within a module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  Import sqrt from math and give it a new name\n",
    "from math import sqrt as sq\n",
    "from math import pi as PIE\n",
    "sq(2)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Recap of importing styles:\n",
    "\n",
    "from module import function    \n",
    "from module import *           \n",
    "import module\n",
    "import module as mod\n",
    "from module import function as func"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Today: Loops & Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The point of loops is to compactly code repetitive tasks.\n",
    "For example, computing the gravitational force for multiple planetary masses.\n",
    " \n",
    "Loops are an essential programming tool (this is why we program!)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python supports two types of loops:\n",
    "\n",
    "  1. while loops\n",
    "  2. for loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While Loops (Section 2.1.2 in the book)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Basic While Loop\n",
    "\n",
    "<Talk about how Python knows what's in the loop>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of x is 0\n",
      "The value of x is 1\n",
      "The value of x is 2\n"
     ]
    }
   ],
   "source": [
    "x = 0                               # Initialize the variable x to 0\n",
    "\n",
    "while(x != 3):                      # While (as long as) x is not equal to 3\n",
    "    print(\"The value of x is\", x)    # Print this to the screen\n",
    "    x += 1                          # Increment x by 1 (add 1 to x)\n",
    "    #  REPEAT!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(x)\n",
    "\n",
    "#  What is the value of x?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Without a while loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of x is 0\n",
      "The value of x is 1\n",
      "The value of x is 2\n"
     ]
    }
   ],
   "source": [
    "x = 0                          # Initialize the variable x to 0\n",
    "\n",
    "print(\"The value of x is\", x)   # Print this to the screen\n",
    "x += 1                         # Increment x by 1 (add 1 to x)\n",
    "\n",
    "print(\"The value of x is\", x)   # Print this to the screen\n",
    "x += 1                         # Increment x by 1 (add 1 to x)\n",
    "\n",
    "print(\"The value of x is\", x)   # Print this to the screen\n",
    "x += 1                         # Increment x by 1 (add 1 to x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall the Gravitational Force Equation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$F(r) = G \\frac{m_1 m_2}{r^2}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# Table of Gravitational Forces for Multiple Planet Masses\n",
      "\n",
      "# mass1/mass_earth  Force\n",
      "1.0\t 686.94\n",
      "2.0\t1373.88\n",
      "3.0\t2060.82\n",
      "4.0\t2747.76\n",
      "5.0\t3434.70\n",
      "6.0\t4121.65\n",
      "7.0\t4808.59\n",
      "8.0\t5495.53\n",
      "9.0\t6182.47\n",
      "10.0\t6869.41\n",
      "# Done\n"
     ]
    }
   ],
   "source": [
    "print('# Table of Gravitational Forces for Multiple Planet Masses\\n')\n",
    "\n",
    "#  Initialize variables - use meters and kilograms for units\n",
    "G           = 6.67e-11         # Gravitational constant\n",
    "mass_earth   = 5.97e24          # Earth mass\n",
    "mass_person  = 70               # Person mass \n",
    "radius_earth = 6.37e6           # Earth radius\n",
    "\n",
    "#  Begin calculation\n",
    "mass1 = mass_earth\n",
    "\n",
    "#  Print a header\n",
    "print('# mass1/mass_earth  Force')\n",
    "\n",
    "#  The loop ends when conditional mass1 <= (10.0 * massEarth) is no longer true\n",
    "while(mass1 <= (10.0 * mass_earth)):                   #  Note the colon!\n",
    "    force = G * mass1 * mass_person / radius_earth**2   #  All lines in the loop must be indented by\n",
    "                                                      #  the same amount (iPython does it automatically)\n",
    "#     print(str(mass1 / mass_earth) + \" \" + str(force))\n",
    "    print(\"{mass_ratio}\\t{force:7.2f}\".format(mass_ratio=mass1 / mass_earth,\n",
    "                                              force=force))\n",
    "    mass1 = mass1 + mass_earth                         # Increment by Earth's mass\n",
    "\n",
    "# No indent!  This line is executed after the loop is done\n",
    "print('# Done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What will this loop do (\"trace\" it)?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The increment could have been done in shorthand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# mass1/mass_earth  Force\n",
      "               1.0  686.94\n",
      "               2.0 1373.88\n",
      "               3.0 2060.82\n",
      "               4.0 2747.76\n",
      "               5.0 3434.70\n",
      "               6.0 4121.65\n",
      "               7.0 4808.59\n",
      "               8.0 5495.53\n",
      "               9.0 6182.47\n",
      "              10.0 6869.41\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'# Done'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Note that I have to reset mass1 here!!\n",
    "mass1 = mass_earth\n",
    "\n",
    "print('# mass1/mass_earth  Force')\n",
    "\n",
    "while(mass1 <= (10.0 * mass_earth)):\n",
    "    force = G * mass1 * mass_person / radius_earth**2\n",
    "    \n",
    "    print(\"{:18.1f} {:7.2f}\".format(mass1 / mass_earth, force))\n",
    "    \n",
    "    #  mass1 = mass1 + mass_earth\n",
    "    mass1 += mass_earth      #  Shorthand version of the line above.\n",
    "\n",
    "'# Done'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What about this one? Can you predict any problems it may cause?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#  Example 1\n",
    "x = 0\n",
    "while(True):\n",
    "    x = x + 1\n",
    "\n",
    "#  Example 2\n",
    "x = 0\n",
    "while(x >= -1):\n",
    "    x = x + 1"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "NEVER, EVER DO THIS!! (well, not EXACTLY like this...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Infinite loops"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "If you create a while loop and the conditional never becomes false, you have just made yourself an infinite loop!\n",
    "\n",
    "If you accidentally make an infinite loop in iPython notebook, go to \"Kernel\" then \"Interrupt\" in the toolbar above, then go to \"Kernel\" then \"Restart\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loop count: 0\n",
      "Loop count: 1\n",
      "Loop count: 2\n",
      "Loop count: 3\n",
      "Loop count: 4\n",
      "Loop count: 5\n",
      "Loop count: 6\n",
      "Loop count: 7\n",
      "Loop count: 8\n",
      "Loop count: 9\n"
     ]
    }
   ],
   "source": [
    "#  How to prevent an infinite loop\n",
    "\n",
    "maxCount = 10      #  A number that is more than your loop should ever do\n",
    "count = 0          #  The current number your loop is on\n",
    "\n",
    "#  Adding \"and < maxCount\" to the end of your conditional prevents infinite loops\n",
    "while(True and count < maxCount):\n",
    "    print(\"Loop count: \" + str(count))\n",
    "    count += 1     #  Increment your current loop count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. How does this work?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Remember the basic structure of a while loop:\n",
    "\n",
    "while <conditional statement>:\n",
    "    <commands indented by 1 tab (usually 3 or 4 spaces)>\n",
    "    <more commands>\n",
    "    <more commands>\n",
    "    <...>\n",
    "\n",
    "<eventually exit loop and return to no indent>\n",
    "\n",
    "*The <conditional statement> must evaluate to True or False.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### INTERLUDE:  Boolean (logic) expressions (Section 2.1.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boolean expressions are conditional statements.  There are only \n",
    "two possible values:  True or False\n",
    "\n",
    "I've capitalized True and False because these are reserved words in Python."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#\n",
    "x == y      # Is x equal to y?  (remember, a single = symbol is used to assign values)\n",
    "#\n",
    "x != y      # Is x not equal to y?\n",
    "#\n",
    "x >= y      # Is x greater than or equal to y?\n",
    "#\n",
    "x <= y      # Is x less than or equal to y?\n",
    "#\n",
    "x < y       # Is x less than y?\n",
    "#\n",
    "x > y       # Is x greater than y?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What is the value of this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 <= 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What is the value of this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 >= 10"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The reserved word \"not\" can be inserted in front of boolean expressions to change the value\n",
    "to its opposite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not 5 >= 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What is the value of this?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See how readable Python is?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boolean expressions can be combined with \"and\", \"or\" and \"not\" to form compound conditional expressions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "5 <= 10 and 5 >= 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. How about this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "5 <= 10 or 5 >= 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Back to while loops"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "While loops are good to use when you don't know exactly how many times you need your loop to run.\n",
    "\n",
    "They are very useful when asking the user for input."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example - User Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess a number between 1 and 10: 1\n",
      "Guess a number between 1 and 10: 2\n",
      "Guess a number between 1 and 10: 3\n",
      "Guess a number between 1 and 10: 4\n",
      "Guess a number between 1 and 10: 5\n",
      "You have guessed the correct number! 5\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "minNumber = 1\n",
    "maxNumber = 10\n",
    "\n",
    "#  Get a random number between 1 and 10\n",
    "randomNumber = random.randint(minNumber, maxNumber)\n",
    "\n",
    "userGuess = -1\n",
    "\n",
    "while(userGuess != randomNumber):\n",
    "    userPrompt = \"Guess a number between \" + str(minNumber) + \" and \" + str(maxNumber) + \": \"\n",
    "    \n",
    "    userGuess = input(userPrompt)      #  Prompt the user\n",
    "    \n",
    "    userGuess = int(userGuess)\n",
    "\n",
    "print(\"You have guessed the correct number! \" + str(userGuess))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What happens if you enter a letter instead of a number?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists (Section 2.2)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Lists are sequences of objects (which can be of different types) in a given order.\n",
    "\n",
    "To define a list of mass ratios with ten elements\n",
    "    ** (and indices running from 0 to 9): **\n",
    "\n",
    "Referring to our previous gravitational force example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "massRatio = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]\n",
    "massRatio"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "We can access an element of the list by supplying its \n",
    "index in SQUARE BRACKETS (not parentheses or braces):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "massRatio[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What will this print?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(massRatio[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lesson learned: Python is zero-index based"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifying lists"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "We can append an element to the end of a list\n",
    "using the append \"method\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "massRatio.append(11.0)\n",
    "massRatio"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Note the syntax \"object.method(argument)\"\n",
    "\n",
    "Append acts like a function, but it is reached through an object.\n",
    "That object (which we created) is a list called massRatio."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "We can insert a new element at a specific location too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# This inserts 4.5 into index 4 of the list:\n",
    "massRatio.insert(4, 4.5)\n",
    "\n",
    "massRatio"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "We can delete an element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "del massRatio[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What will the next line produce?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "massRatio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# We can find out its length with len(object)\n",
    "len(massRatio)\n",
    "\n",
    "# Python uses [] to access elements and () to perform a function on an object."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Lists can be added:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 12.0, 13.0, 14.0]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "massRatio = massRatio + [12.0, 13.0, 14.0]\n",
    "massRatio"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "which is equivalent to using the method \"extend\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "massRatio.extend([15.0, 16.0, 17.0])\n",
    "print(\"Extend\", massRatio)\n",
    "\n",
    "massRatio.append([18.0, 19.0, 20.0])\n",
    "print(\"Append\", massRatio)\n",
    "print(massRatio[17][1])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The \"index\" function returns the index of the first appearance of a value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What will this produce?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "massRatio.index(12.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "20.0 is not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-29-24206e7e4f7f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#  And, this fails\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmassRatio\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m20.0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: 20.0 is not in list"
     ]
    }
   ],
   "source": [
    "#  And, this fails\n",
    "massRatio.index(20.0)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The \"in\" keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#  We can check if there is an element in a list.  The result of the check\n",
    "#  is boolean:  True or False.\n",
    "\n",
    "14.0 in massRatio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "99.0 in massRatio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "massRatio"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Negative indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#  Negative indices start counting from the right (the end) of a list:\n",
    "massRatio[-4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What will this give us?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating lists with while loops"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "We can create lists using a while loop.\n",
    "\n",
    "Again, this is useful when you don't know how many elements\n",
    "are going to be put in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Initializations first\n",
    "massRatio      = []       #  Creates an empty list\n",
    "massRatioValue = 1.0      #  For the conditional\n",
    "massRatioMax   = 5.0      #  Also for the conditional\n",
    "\n",
    "userInput = \"BIG NOPE\"\n",
    "\n",
    "# And the while loop\n",
    "while(userInput != \"N\" and massRatioValue <= massRatioMax):   #  Remember the colon!\n",
    "    #  Remember to indent!\n",
    "    massRatio.append(massRatioValue)\n",
    "    massRatioValue += 1.0\n",
    "    \n",
    "    userInput = input(\"Add another mass ratio value? \")\n",
    "    userInput = userInput.upper()\n",
    "\n",
    "print(\"Finished creating the list massRatio!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What is massRatio?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "massRatio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.1"
  },
  "widgets": {
   "state": {},
   "version": "1.1.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}