lessons/IntroductionToPython.ipynb

{
 "metadata": {
  "name": "IntroductionToPython"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Introduction to Python"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This lecture is based loosely on the online tutorial : http://www.afterhoursprogramming.com/tutorial/Python/Introduction/"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We will be using Python a fair amount in this class.  Python is a high-level scripting language that offers an interactive programming environment.  We assume programming experience, so this lecture will focus on the unique properties of Python. "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Programming languages generally have the following common ingredients: variables, operators, iterators,\n",
      "conditional statements, functions (built-in and user defined) and higher-order data structures.  We will look at these in \n",
      "Python and highlight qualities unique to this language.\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Variables\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Variables in Python are defined and typed for you when you set a value to them."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Myvariable = 2 \n",
      "print(Myvariable)\n",
      "type(Myvariable)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2\n"
       ]
      },
      {
       "output_type": "pyout",
       "prompt_number": 3,
       "text": [
        "int"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This makes variable definition easy for the programmer.  As usual, though, great power comes with great responsibility.  For example:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Myvarible= Myvariable+1\n",
      "print (Myvariable)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\"If you leave out word, spell-check will not put the word in you\" -- Taylor Mali, <em>The the impotence of proofreading</em>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If you accidentally mistype a variable name, Python will not catch it for you.  This can lead to bugs that can be hard to track - so beware."
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Types and Typecasting"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The usual typecasting is available in Python, so it is easy to convert strings to ints or floats, floats to ints, etc.  The syntax is slightly different than C:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=\"1\"\n",
      "b=5\n",
      "print(a+b)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "TypeError",
       "evalue": "cannot concatenate 'str' and 'int' objects",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
        "\u001b[0;32m<ipython-input-7-bf1e73fdfc72>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"1\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mTypeError\u001b[0m: cannot concatenate 'str' and 'int' objects"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=\"1\"\n",
      "b=5\n",
      "print(int(a)+b)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "6\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Note that the typing is <em>dynamic.</em>  I.e. a variable that was initally say an integer can become another type (float, string, etc.) via reassignment."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=\"1\"\n",
      "type(a)\n",
      "print(type(a))\n",
      "\n",
      "a=1.0\n",
      "print(type(a))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<type 'str'>\n",
        "<type 'float'>\n"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python has some other special data types such as lists, tuples and dictionaries that we will address later."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Operators"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python offers the usual operators such as +,-,/,\\*,=,>,<,==,!=,&,|, \n",
      "(sum, difference, divide, product, assignment, greater than, less than, equal - comparison,not equal, and, or, respectively).  \n",
      "Additionally, there are %,// and ** (modulo, floor division and 'to the power'). Note a few specifics:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(3/4)\n",
      "print(3.0 / 4.0)\n",
      "print(3%4)\n",
      "print(3//4)\n",
      "print(3**4)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0\n",
        "0.75\n",
        "3\n",
        "0\n",
        "81\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Note the behavior of / when applied to integers!  This is similar to the behavior of other strongly typed languages such as C/C++.  The result of the integer division is the same as the floor division //.  If you want the floating point result, the arguments to / must be floats as well (or appropriately typecast)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=3\n",
      "b=4\n",
      "print(a/b)\n",
      "print(float(a)/float(b))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0\n",
        "0.75\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Iterators"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python has the usual iterators, while, for, and some other constructions that will be addressed later.  Here are examples of each:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in range(1,10):\n",
      "     print(i)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1\n",
        "2\n",
        "3\n",
        "4\n",
        "5\n",
        "6\n",
        "7\n",
        "8\n",
        "9\n"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The most important thing to note above is that the range function gives us values up to, but not including, the upper limit."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "i=1\n",
      "while i < 10:\n",
      "    print(i)\n",
      "    i+=1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1\n",
        "2\n",
        "3\n",
        "4\n",
        "5\n",
        "6\n",
        "7\n",
        "8\n",
        "9\n"
       ]
      }
     ],
     "prompt_number": 34
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This is unremarkable, so we proceeed without further comment."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Conditional Statements"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = 20\n",
      "if a >= 22:\n",
      "   print(\"if\")\n",
      "elif a >= 21:\n",
      "    print(\"elif\")\n",
      "else:\n",
      "    print(\"else\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "else\n"
       ]
      }
     ],
     "prompt_number": 37
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Again, nothing remarkable here, just need to learn the syntax.  Here, we should also mention spacing.  Python is picky about indentation - you must start a newline after each conditional statemen\n",
      "(it is the same for the iterators above) and indent the same number of spaces for every statement within the scope of that condition.  "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = 23\n",
      "if a >= 22:\n",
      "   print(\"if\")\n",
      "    print(\"greater than or equal 22\")\n",
      "elif a >= 21:\n",
      "    print(\"elif\")\n",
      "else:\n",
      "    print(\"else\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "IndentationError",
       "evalue": "unexpected indent (<ipython-input-42-355bcdcef6c8>, line 4)",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unexpected indent\n"
       ]
      }
     ],
     "prompt_number": 42
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = 23\n",
      "if a >= 22:\n",
      "   print(\"if\")\n",
      "   print(\"greater than or equal 22\")\n",
      "elif a >= 21:\n",
      "    print(\"elif\")\n",
      "else:\n",
      "    print(\"else\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "if\n",
        "greater than or equal 22\n"
       ]
      }
     ],
     "prompt_number": 43
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Four spaces are customary, but you can use whatever you like. Consistency is necessary."
     ]
    },
    {
     "cell_type": "heading",
     "level": 4,
     "metadata": {},
     "source": [
      "Exceptions"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python has another type of conditional expression that is very useful.  Suppose your program is processing user input or data from a file. You don't always know for sure what you are getting in that case, and this can lead to problems.  The 'try/except' conditional can solve them!\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = \"1\"\n",
      "\n",
      "try:\n",
      "  b = a + 2 \n",
      "except:\n",
      "  print(a, \" is not a number\") \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "('1', ' is not a number')\n"
       ]
      }
     ],
     "prompt_number": 47
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Here, we have tried to add a number and a string.  That generates an exception - but we have trapped the exception and\n",
      "informed the user of the problem.  This is much preferable to the programming crashing with some cryptic error like:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = \"1\"\n",
      "b = a + 2 \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "TypeError",
       "evalue": "cannot concatenate 'str' and 'int' objects",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
        "\u001b[0;32m<ipython-input-49-1b1ef016a6b2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"1\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mTypeError\u001b[0m: cannot concatenate 'str' and 'int' objects"
       ]
      }
     ],
     "prompt_number": 49
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Functions\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def Division(a, b):\n",
      "    print(a/b)\n",
      "Division(3,4)\n",
      "Division(3.0,4.0)\n",
      "Division(3,4.0)\n",
      "Division(3.0,4)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0\n",
        "0.75\n",
        "0.75\n",
        "0.75\n"
       ]
      }
     ],
     "prompt_number": 55
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Notice that the function does not specify the types of the arguments, like you would see in statically typed languages.  This is both useful and dangerous.  For example:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def Division(a, b):\n",
      "    print(a/b)\n",
      "Division(2,\"2\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "TypeError",
       "evalue": "unsupported operand type(s) for /: 'int' and 'str'",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
        "\u001b[0;32m<ipython-input-56-663c15047357>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mDivision\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mDivision\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"2\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;32m<ipython-input-56-663c15047357>\u001b[0m in \u001b[0;36mDivision\u001b[0;34m(a, b)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mDivision\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0;32mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mDivision\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"2\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
        "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'int' and 'str'"
       ]
      }
     ],
     "prompt_number": 56
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In a statically typed language, the programmer would have specified the type of a and b (float, int, etc.) and the compiler\n",
      " would have complained about the function being passed a variable of the wrong type. This does not happen here, but we can use the try/except construction."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def Division(a, b):\n",
      "    try:\n",
      "        print(a/b)\n",
      "    except:\n",
      "        if b == 0:\n",
      "           print(\"cannot divide by zero\")\n",
      "        else:\n",
      "           print(float(a)/float(b))\n",
      "Division(2,\"2\")\n",
      "Division(2,0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1.0\n",
        "cannot divide by zero\n"
       ]
      }
     ],
     "prompt_number": 58
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Strings and String Handling\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "One of the most important features of Python is its powerful and easy handling of strings.  Defining strings is simple enough in most languages.  But in Python, it is easy to search and replace, convert cases, concatenate, or access elements.  We'll discuss a few of these here.  For a complete list, see: http://www.tutorialspoint.com/python/python_strings.htm"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=\"A string of characters, with newline \\n CAPITALS, etc.\"\n",
      "print(a)\n",
      "b=5.0\n",
      "newstring=a+\"\\n We can format strings for printing %.2f\"\n",
      "print(newstring %b)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "A string of characters, with newline \n",
        " CAPITALS, etc.\n",
        "A string of characters, with newline \n",
        " CAPITALS, etc.\n",
        " We can format strings for printing 5.00\n"
       ]
      }
     ],
     "prompt_number": 60
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now let's try some other string operations:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=\"ABC DEFG\"\n",
      "a[1:3]\n",
      "a[0:5]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 64,
       "text": [
        "'ABC D'"
       ]
      }
     ],
     "prompt_number": 64
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "There are several things to learn from the above.  First, Python has associated an index to the string. Second the indexing starts at 0, and lastly, the upper limit again means 'up to but not including' (a[0:5] prints elements 0,1,2,3,4)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=\"ABC defg\"\n",
      "print(a.lower())\n",
      "print(a.upper())\n",
      "print(a.find('d'))\n",
      "print(a.replace('de','a'))\n",
      "print(a)\n",
      "b=a.replace('def','aaa')\n",
      "print(b)\n",
      "b=b.replace('a','c')\n",
      "print(b)\n",
      "b.count('c')\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "abc defg\n",
        "ABC DEFG\n",
        "4\n",
        "ABC afg\n",
        "ABC defg\n",
        "ABC aaag\n",
        "ABC cccg\n"
       ]
      },
      {
       "output_type": "pyout",
       "prompt_number": 72,
       "text": [
        "3"
       ]
      }
     ],
     "prompt_number": 72
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This is fun! What else can you do with strings in Python?  Pretty much anything you can think of!  "
     ]
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Lists, Tuples, Dictionaries\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Lists"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Lists are exactly as the name implies.  They are lists of objects.  The objects can be any data type (including lists), and it is allowed to mix data types.  In this way they are much more flexible than arrays.  It is possible to append, delete, insert and count elements and to sort, reverse, etc. the list."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Alist=[1,2,3,\"this is a string\",5.3]\n",
      "Blist=[\"A\",\"B\",\"F\",\"G\",\"d\",\"x\",\"c\",Alist,3]\n",
      "print(Blist)\n",
      "print(Blist[7:9])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['A', 'B', 'F', 'G', 'd', 'x', 'c', [1, 2, 3, 'this is a string', 5.3], 3]\n",
        "[[1, 2, 3, 'this is a string', 5.3], 3]\n"
       ]
      }
     ],
     "prompt_number": 76
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=[1,2,3,4,5,6,7]\n",
      "a.insert(0,0)\n",
      "print(a)\n",
      "a.append(8)\n",
      "print(a)\n",
      "a.reverse()\n",
      "print(a)\n",
      "a.sort()\n",
      "print(a)\n",
      "a.pop()\n",
      "print(a)\n",
      "a.remove(3)\n",
      "print(a)\n",
      "a.remove(a[4])\n",
      "print(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0, 1, 2, 3, 4, 5, 6, 7]\n",
        "[0, 1, 2, 3, 4, 5, 6, 7, 8]\n",
        "[8, 7, 6, 5, 4, 3, 2, 1, 0]\n",
        "[0, 1, 2, 3, 4, 5, 6, 7, 8]\n",
        "[0, 1, 2, 3, 4, 5, 6, 7]\n",
        "[0, 1, 2, 4, 5, 6, 7]\n",
        "[0, 1, 2, 4, 6, 7]\n"
       ]
      }
     ],
     "prompt_number": 92
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Just like with strings, elements are indexed beginning with 0."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Tuples"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Tuples are like lists with one very important difference. Tuples are not changeable.    "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=(1,2,3,4)\n",
      "print(a)\n",
      "a[1]=2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "TypeError",
       "evalue": "'tuple' object does not support item assignment",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
        "\u001b[0;32m<ipython-input-94-3f7ee3924a64>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(1, 2, 3, 4)\n"
       ]
      }
     ],
     "prompt_number": 94
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=(1,\"string in a tuple\",5.3)\n",
      "b=(a,1,2,3)\n",
      "print(a)\n",
      "print(b)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(1, 'string in a tuple', 5.3)\n",
        "((1, 'string in a tuple', 5.3), 1, 2, 3)\n"
       ]
      }
     ],
     "prompt_number": 96
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "As you can see, all of the other flexibility remains - so use tuples when you have a list that you <em>do not want to modify</em>."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Dictionaries"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Dictionaries are unordered, keyed lists.  Lists are ordered, and the index may be viewed as a key."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=[\"A\",\"B\",\"C\",\"D\"] #list example\n",
      "print(a[1])\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "B\n"
       ]
      }
     ],
     "prompt_number": 99
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a={'anItem': \"A\", 'anotherItem': \"B\",'athirdItem':\"C\",'afourthItem':\"D\"} # dictionary example\n",
      "print(a[1])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 101
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a={'anItem': \"A\", 'anotherItem': \"B\",'athirdItem':\"C\",'afourthItem':\"D\"} # dictionary example\n",
      "print(a['anItem'])\n",
      "print(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "A\n",
        "{'athirdItem': 'C', 'afourthItem': 'D', 'anItem': 'A', 'anotherItem': 'B'}\n"
       ]
      }
     ],
     "prompt_number": 104
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "The dictionary does not order the items, and you cannot access them assuming an order (as an index does).  You access elements using the keys."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}