Lecture 01.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:9ca0e736ef120d01f7956646cf5695b540c8616d582da047542519084e49e819"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Today we'll cover:\n",
      "1. [if statement](#if-statement)\n",
      "2. [for and while loops](#for-and-while-loops) (and the use of `break`, `continue`, and the `else` clause in them)\n",
      "3. [pass statement](#pass-statement)\n",
      "4. [Functions and their arguments](#Functions-and-their-arguments) (defining functions using `def`, different ways to supply arguments to functions, and docstrings)"
     ]
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "`if` statement"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "speed = 25 # a horse's speed in m.p.h."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if speed < 0:\n",
      "    raise Exception(\"Expected non-negative horse speed, got negative.\") # raise statement causes an exception to occur\n",
      "elif speed < 2: # elif is short for \"else if\"\n",
      "    print \"Barely moving\"\n",
      "elif speed < 5:\n",
      "    print \"Walking\"\n",
      "elif speed < 10:\n",
      "    print \"Trotting\"\n",
      "elif speed < 20:\n",
      "    print \"Cantering\"\n",
      "else: # control gets here if speed >= 20\n",
      "    print \"Galloping\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Galloping\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "`for` and `while` loops"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The `for` loop in Python *always* iterates over a sequence (e.g. a string of characters or a list)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for c in 'statistics':\n",
      "    print c, # the comma prevents a newline from being printed"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "s t a t i s t i c s\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We saw the built-in function `range` in the last lecture. It is quite useful to loop over a range of numbers."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in range(90, 100): # print the 90s; note that 100 is *not* included\n",
      "    print i,"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "90 91 92 93 94 95 96 97 98 99\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We can also supply a step parameter."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in range(2, 20, 2): # even numbers from 2 (included) throguh 20 (excluded)\n",
      "    print i,"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2 4 6 8 10 12 14 16 18\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "However `range` expects integer arguments. To get floating point numbers, we can use list comprehensions. The `numpy` package (that we will study in detail later) provides an `arange` function."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "range(0,1,.1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "TypeError",
       "evalue": "range() integer step argument expected, got float.",
       "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-6-651d843fd06c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mrange\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;36m.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mTypeError\u001b[0m: range() integer step argument expected, got float."
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "[i/10.0 for i in range(0, 10)] # note that we wrote 10.0, not 10. Why?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 7,
       "text": [
        "[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from numpy import arange # Import the arange function from the numpy module (need numpy module installed)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arange(0,1,.1) # returns a numpy array, not a list"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 9,
       "text": [
        "array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now let us find all **perfect numbers** up to, but not including, 500. A number is called perfect if it is the sum of all its (proper) factors/divisors."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in range(2,500):\n",
      "    sum_of_factors = 0\n",
      "    for j in range(1, i/2 + 1): # a factor of i cannot be larger than i/2\n",
      "        if i % j == 0: # found a factor\n",
      "            sum_of_factors = sum_of_factors + j\n",
      "    if sum_of_factors == i: # found a perfect number\n",
      "        print str(i) + \" is perfect\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "6 is perfect\n",
        "28 is perfect\n",
        "496 is perfect\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "It is not known if there are infinitely many perfect numbers. It is also not known whether there is any odd perfect number."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A `while` loop is used to execute commands repeatedly till a specified condition is met."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's the find the first perfect number starting at 500"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "i = 500\n",
      "found = False\n",
      "while not found:\n",
      "    sum_of_factors = 0\n",
      "    for j in range(1, i/2 + 1): # a factor of i cannot be larger than i/2\n",
      "        if i % j == 0: # found a factor\n",
      "            sum_of_factors = sum_of_factors + j\n",
      "    if sum_of_factors == i: # found a perfect number\n",
      "        print \"First perfect number larger than 500 is \" + str(i)\n",
      "        found = True\n",
      "    i = i + 1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "First perfect number larger than 500 is 8128\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's now learn about `break` and `continue` statements."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "great_lakes = ['Superior', 'Michigan', 'Huron', 'Erie', 'Ontario']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "biggest_lakes = ['Caspian', 'Superior', 'Victoria', 'Huron', 'Michigan'] # top 5 lakes (by area)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 13
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Is there a Great Lake in the top 5 lakes?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for lake in biggest_lakes:\n",
      "    if lake in great_lakes: # The keyword 'in' in an expression tests for membership in a sequence\n",
      "        print \"Found Lake \" + lake + \", a Great Lake, in the top 5 lakes by area\"\n",
      "        break\n",
      "else:\n",
      "    print \"Didn't find any Great Lake in the top 5 lakes by area\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Found Lake Superior, a Great Lake, in the top 5 lakes by area\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Note that the `else` statement is aligned with the `for` statement, not the `if` statement. The `else` clause following a `for` (or `while`) loop is executing when the reason the loop finished is that the list was exhausted (or the condition in the `while` loop became false)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "deepest_lakes = [\"Baikal\", \"Tanganyika\", \"Caspian\", \"Vostok\", \"O'Higgins-San Martin\"]\n",
      "for lake in deepest_lakes:\n",
      "    if lake in great_lakes:\n",
      "        print \"Found Lake \" + lake + \", a Great Lake, in the top 5 deepest lakes\"\n",
      "        break\n",
      "else:\n",
      "    print \"Didn't find any Great Lake in the top 5 deepest lakes\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Didn't find any Great Lake in the top 5 deepest lakes\n"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now we want to list the top 5 lakes indicating which ones are also in the Great Lakes."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for lake in biggest_lakes:\n",
      "    if lake in great_lakes:\n",
      "        print lake + \" (Great Lake)\"\n",
      "        continue\n",
      "    print lake"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Caspian\n",
        "Superior (Great Lake)\n",
        "Victoria\n",
        "Huron (Great Lake)\n",
        "Michigan (Great Lake)\n"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "`pass` statement"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The `pass` statement does nothing! Its use is limited to a few situations. One situation is when you're developing code and want to remind yourself that you need to do something later."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "great_lakes = ['Superior', 'Michigan', 'huron', 'erie', 'Ontario'] # note some names not capitalized"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for lake in great_lakes:\n",
      "    if lake[0].islower():\n",
      "        pass # remember to print a warning about capitalization\n",
      "    print lake"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Superior\n",
        "Michigan\n",
        "huron\n",
        "erie\n",
        "Ontario\n"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Later you might go back and change the code."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for lake in great_lakes:\n",
      "    if lake[0].islower():\n",
      "        print lake + \" (Warning: Great Lake name not capitalized)\"\n",
      "        continue\n",
      "    print lake"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Superior\n",
        "Michigan\n",
        "huron (Warning: Great Lake name not capitalized)\n",
        "erie (Warning: Great Lake name not capitalized)\n",
        "Ontario\n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Functions and their arguments"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "As we saw in the last lecture, we use the keyword `def` in Python to define functions. The string right in the next line after `def` has a special status. It is called a *docstring* of the function. Various tools for automatically preparing documentation from source code will use the docstring. So make a habit of always supplying one! Also, docstrings are typically triple-quoted even if it fits one line to allow for later expansion."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def primes(n):\n",
      "    \"\"\"Print primes numbers till n.\"\"\"\n",
      "    \n",
      "    i = 2\n",
      "    while i < n:\n",
      "        for j in range(2, i/2 + 1): # loop through possible factors\n",
      "            if i % j == 0: # found a factor\n",
      "                break\n",
      "        else: # no factor found\n",
      "            print i\n",
      "        i = i + 1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print primes # print function object"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<function primes at 0x10f651f50>\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print primes.__doc__ # print the docstring"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Print primes numbers till n.\n"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "primes(10) # call function with argument 10"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2\n",
        "3\n",
        "5\n",
        "7\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Since `primes` doesn't return anything, it is interesting to see what happens if we try to print the returned value. It prints a special value `None`. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "val = primes(10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2\n",
        "3\n",
        "5\n",
        "7\n"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print val"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "None\n"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now we might want to have a second argument `format` to control how the list is printed."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def primes(n, format):\n",
      "    \"\"\"Print primes numbers till n.\n",
      "    \n",
      "    Testing for primality is done by simpy looping over all possible factors.\n",
      "    The format argument has to be either 'compact' or 'normal' and decides whether \\\n",
      "    the numbers are printed in the same lines or on different lines.\n",
      "    \"\"\"\n",
      "    \n",
      "    if format != \"compact\" and format != \"normal\":\n",
      "        raise Exception(\"Expected format to be either 'compact' or 'normal'.\")\n",
      "        \n",
      "    i = 2\n",
      "    while i < n:\n",
      "        for j in range(2, i/2 + 1): # loop through possible factors\n",
      "            if i % j == 0: # found a factor\n",
      "                break\n",
      "        else: # no factor found in entire loop hence prime\n",
      "            if format == \"compact\":\n",
      "                print i,\n",
      "            else:\n",
      "                print i\n",
      "        i = i + 1\n",
      "        \n",
      "    if format == \"compact\": # print a newline at the end\n",
      "        print"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 26
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "primes(20, \"compact\") # we can now call primes with a printing format option"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2 3 5 7 11 13 17 19\n"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "However, it is bit tedious to always supply the second formatting argument."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "primes(20)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "TypeError",
       "evalue": "primes() takes exactly 2 arguments (1 given)",
       "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-28-ac8fca6d68e5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprimes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mTypeError\u001b[0m: primes() takes exactly 2 arguments (1 given)"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "So let us supply a default value for the format argument."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def primes(n, format=\"normal\"):\n",
      "    \"\"\"Print primes numbers till n.\n",
      "    \n",
      "    Testing for primality is done by simpy looping over all possible factors from 2\n",
      "    through n/2. The optional format argument has to be either 'compact' or 'normal'\n",
      "    and decides whether the numbers are printed in the same lines or on different\n",
      "    lines.\n",
      "    \"\"\"\n",
      "    \n",
      "    if format != \"compact\" and format != \"normal\":\n",
      "        raise Exception(\"Expected format to be either 'compact' or 'normal'.\")\n",
      "        \n",
      "    i = 2\n",
      "    while i < n:\n",
      "        for j in range(2, i/2 + 1): # loop through possible factors\n",
      "            if i % j == 0: # found a factor\n",
      "                break\n",
      "        else: # no factor found in entire loop, hence prime\n",
      "            if format == \"compact\":\n",
      "                print i,\n",
      "            else:\n",
      "                print i\n",
      "        i = i + 1\n",
      "        \n",
      "    if format == \"compact\": # print a newline at the end\n",
      "        print"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 29
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "primes(20) # call primes with the default argument for format"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2\n",
        "3\n",
        "5\n",
        "7\n",
        "11\n",
        "13\n",
        "17\n",
        "19\n"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We have so far called the function `prime` using *positional* arguments. We can also call it using *keyword* arguments."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "primes(n=10, format=\"compact\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2 3 5 7\n"
       ]
      }
     ],
     "prompt_number": 31
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Keyword arguments do not have to provided in any specified order. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "primes(format=\"compact\", n=10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2 3 5 7\n"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "One can also mix positional argument with keyword arguments."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "primes(30, format=\"compact\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2 3 5 7 11 13 17 19 23 29\n"
       ]
      }
     ],
     "prompt_number": 33
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "However, all keywords arguments should come *after* positional arguments."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "primes(format=\"compact\", 30)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "SyntaxError",
       "evalue": "non-keyword arg after keyword arg (<ipython-input-34-39ebe1c28ae6>, line 1)",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-34-39ebe1c28ae6>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    primes(format=\"compact\", 30)\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m non-keyword arg after keyword arg\n"
       ]
      }
     ],
     "prompt_number": 34
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We are *not* permitted to supply the argument both positionally and via a keyword (even if the value supplied is the same)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "primes(10, n=10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "TypeError",
       "evalue": "primes() got multiple values for keyword argument 'n'",
       "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-35-ba124d1eea36>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprimes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mTypeError\u001b[0m: primes() got multiple values for keyword argument 'n'"
       ]
      }
     ],
     "prompt_number": 35
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Finally, let's look at *unpacking* argument lists. For example, range(a, b) returns integers from a through b (excluded). What if we had the starting and end values in a list?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "range_args = [5, 10]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 36
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "range(range_args)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "TypeError",
       "evalue": "range() integer end argument expected, got list.",
       "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-37-d07ee9153ce8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrange_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mTypeError\u001b[0m: range() integer end argument expected, got list."
       ]
      }
     ],
     "prompt_number": 37
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We have to unpack the arguments in the list `extreme_vals` which is done by adding an asterisk (*)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "range(*range_args)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 38,
       "text": [
        "[5, 6, 7, 8, 9]"
       ]
      }
     ],
     "prompt_number": 38
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "prime_args = [[10, \"compact\"], [10, \"normal\"], [100, \"compact\"], [10]]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 39
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for args in prime_args: # try out primes with a bunch of different argument lists\n",
      "    print \"Calling primes with arguments unpacked from: \" + str(args)\n",
      "    primes(*args)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Calling primes with arguments unpacked from: [10, 'compact']\n",
        "2 3 5 7\n",
        "Calling primes with arguments unpacked from: [10, 'normal']\n",
        "2\n",
        "3\n",
        "5\n",
        "7\n",
        "Calling primes with arguments unpacked from: [100, 'compact']\n",
        "2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97\n",
        "Calling primes with arguments unpacked from: [10]\n",
        "2\n",
        "3\n",
        "5\n",
        "7\n"
       ]
      }
     ],
     "prompt_number": 40
    }
   ],
   "metadata": {}
  }
 ]
}