python-nb-demo.ipynb

{
 "metadata": {
  "name": "python-nb-demo"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Scientific Python Basics\n",
      "\n",
      "__Software Carpentry Bootcamp  \n",
      "Columbia University, NYC,  \n",
      "January 2013__  \n",
      "\n",
      "Uploaded and Presented by: Adina Howe  \n",
      "Based on material prepared by: Matt Davis, Katy Huff, Justin Kitzes, and Tracy Teal"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## 1. Individual things\n",
      "\n",
      "The most basic component of any programming language are \"things\", also called variables or\n",
      "(in special cases) objects.\n",
      "\n",
      "The most common basic \"things\" in Python are integers, floats, strings, booleans, and\n",
      "some special objects of various types. We'll meet many of these as we go through the lesson."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "__TIP:__ To run the code in a cell quickly, press Ctrl-Enter."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "__TIP:__ To quickly create a new cell below an existing one, type Ctrl-m then b.\n",
      "Other shortcuts for making, deleting, and moving cells are in the menubar on the left of the\n",
      "screen. To hide the menubar, click on the vertical gray divider separating it from this\n",
      "main page."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# A thing\n",
      "2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 452,
       "text": [
        "2"
       ]
      }
     ],
     "prompt_number": 452
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Use print to show multiple things in the same cell\n",
      "# Note that you can use single or double quotes for strings\n",
      "print 2\n",
      "print 'hello'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2\n",
        "hello"
       ]
      }
     ],
     "prompt_number": 453
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Things can be stored as variables\n",
      "a = 2\n",
      "b = 'hello'\n",
      "c = True  # This is case sensitive\n",
      "print a, b, c"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2 hello True"
       ]
      }
     ],
     "prompt_number": 454
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# The type function tells us the type of thing we have\n",
      "print type(a)\n",
      "print type(b)\n",
      "print type(c)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<type 'int'>\n",
        "<type 'str'>\n",
        "<type 'bool'>"
       ]
      }
     ],
     "prompt_number": 455
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## 2. Commands that operate on things\n",
      "\n",
      "Just storing data in variables isn't much use to us. Right away, we'd like to start performing\n",
      "operations and manipulations on data and variables.\n",
      "\n",
      "There are three very common means of performing an operation on a thing."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### 2.1 Use an operator\n",
      "\n",
      "All of the basic math operators work like you think they should for numbers. They can also\n",
      "do some useful operations on other things, like strings. There are also boolean operators that\n",
      "compare quantities and give back a `bool` variable as a result."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Standard math operators work as expected on numbers\n",
      "a = 2\n",
      "b = 3\n",
      "print a + b\n",
      "print a * b\n",
      "print a ** b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "5\n",
        "6\n",
        "8"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Except for division\n",
      "print 2 / 3\n",
      "print 2 / 3."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0\n",
        "0.666666666667"
       ]
      }
     ],
     "prompt_number": 457
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# There are also operators for strings\n",
      "print 'hello' + 'world'\n",
      "print 'hello' * 3\n",
      "# print hello / 3"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "helloworld\n",
        "hellohellohello"
       ]
      }
     ],
     "prompt_number": 458
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Boolean operators compare two things\n",
      "a = (1 > 3)\n",
      "b = (3 == 3)\n",
      "print a\n",
      "print b\n",
      "print a & b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "False\n",
        "True\n",
        "False"
       ]
      }
     ],
     "prompt_number": 459
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### 2.2 Variables, Print"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = 5\n",
      "b = 2\n",
      "a + b\n",
      "#print a + b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 4,
       "text": [
        "7"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "c = b\n",
      "b = 95 # changing b doesn't change c\n",
      "a + c"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 5,
       "text": [
        "7"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "d = (a + b) * c # doesn't print anything"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print a, b, c\n",
      "print d"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "5 95 2\n",
        "200"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Exercise\n",
      "\n",
      "1. Calculate the mean of the numbers 2, 3, and 10.\n",
      "2. Calculate the hypotenuse of a triangle with sides 6 and 8.  (Bonus:  Print out the answer: \"The hypotenuse of a triangle is...\")"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### 2.3 Use a function\n",
      "\n",
      "These will be very familiar to anyone who has programmed in any language, and work like you\n",
      "would expect."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# There are thousands of functions that operate on things\n",
      "print type(3)\n",
      "print len('hello')\n",
      "print round(3.3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<type 'int'>\n",
        "5\n",
        "3.0"
       ]
      }
     ],
     "prompt_number": 460
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "__TIP:__ To find out what a function does, you can type it's name and then a question mark to\n",
      "get a pop up help window. Or, to see what arguments it takes, you can type its name, an open\n",
      "parenthesis, and hit tab."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#round?\n",
      "#round(\n",
      "round(3.14159, 2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 461,
       "text": [
        "3.14"
       ]
      }
     ],
     "prompt_number": 461
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "__TIP:__ Many useful functions are not in the Python built in library, but are in external\n",
      "scientific packages. These need to be imported into your Python notebook (or program) before\n",
      "they can be used. Probably the most important of these are numpy and matplotlib."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "# Many useful functions are in external packages\n",
      "# Let's meet numpy\n",
      "import numpy as np"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 462
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "# To see what's in a package, type the name, a period, then hit tab\n",
      "#np?\n",
      "#np."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 463
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Some examples of numpy functions and \"things\"\n",
      "print np.sqrt(4)\n",
      "print np.pi  # Not a function, just a variable\n",
      "print np.sin(np.pi)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2.0\n",
        "3.14159265359\n",
        "1.22464679915e-16"
       ]
      }
     ],
     "prompt_number": 464
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### 2.3 Use a method\n",
      "\n",
      "In the simplest terms, you can think of an object as a small bundled \"thing\" that contains within\n",
      "itself both data and functions that operate on that data. For example, strings in Python are\n",
      "objects that contain a set of characters and also various functions that operate on the set of\n",
      "characters. When bundled in an object, these functions are called \"methods\".\n",
      "\n",
      "A function is a piece of code that is called by name. It takes data as an input to perform operations on (in other words, it is passed data explicitly).\n",
      "A method is a piece of code that is called by name that is associated with an object. It is very similar to a function and is passed data implicitly."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# A string object\n",
      "a = 'hello, world'\n",
      "print type(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<type 'str'>"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# String objects have bundled methods\n",
      "#a.\n",
      "#a.count?\n",
      "print a.capitalize()\n",
      "print a.replace('l', 'X')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hello, world\n",
        "heXXo, worXd"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Challenge - Uncle Clay and his cats\n",
      "\n",
      "A discrete time equation for logistic population growth is shown below.  For the specific population of study, cats at my uncle's house, the constants are given.\n",
      "\n",
      ">N1 = N0 + r * N0 * [1 - N0 / K]\n",
      "\n",
      "where n(t) is the population size at time t, r is the growth rate, and K is the\n",
      "carrying capacity of the home.\n",
      "\n",
      "Given:  r is 0.6, K is 100, and N0 is 10.\n",
      "\n",
      "Write Python expressions that do the following:\n",
      "\n",
      "1. Create variables for `r`, `K`, and `n0`, setting these equal to their given values.\n",
      "1. Create the variable `n1` and calculate it's value. Do the same for `n2`.\n",
      "1. Check the type of `n2` - what is it?\n",
      "1. Test whether `n2` is larger than 20, and print out a line that says \"n2 more than 20: \"\n",
      "followed by the answer.\n",
      "1. Figure out whether `n2` is an integer, and print out a line that says \"n2 is int: \" followed\n",
      "by the answer (HINT: look at the methods of `n2`.)\n",
      "1. Modify your calculations for `n1` and `n2` so that these values are rounded to the nearest\n",
      "integer."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "r = 0.6\n",
      "K = 100.\n",
      "n0 = 10.\n",
      "\n",
      "n1 = n0 + r*n0*(1 - n0/K)\n",
      "n2 = n1 + r*n1*(1 - n1/K)\n",
      "\n",
      "print n0, n1, n2\n",
      "print type(n2)\n",
      "print 'n2 more than 20: ', n2 > 20\n",
      "print 'n2 is int: ', n2.is_integer()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10.0 15.4 23.21704\n",
        "<type 'float'>\n",
        "n2 more than 20:  True\n",
        "n2 is int:  False\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## 3. Collections of things\n",
      "\n",
      "Once the number of variables that you are interested in starts getting large, working with them\n",
      "all individually starts to get unwieldy. To help stay organized, we can use collections of things.\n",
      "\n",
      "Probably 99% of your work in scientific Python will use one of four types of collections:\n",
      "lists, tuples, dictionaries, and numpy arrays. We'll look quickly at each of these and what\n",
      "they can do for you."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### 3.1 Lists\n",
      "\n",
      "Lists are probably the handiest and most flexible type of container. Lists are declared with\n",
      "square brackets []. Individual elements of a list can be selected using the syntax `a[ind]`."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Lists are created with square bracket syntax\n",
      "a = ['hi', 'hello', 'yo']\n",
      "print a, type(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['hi', 'hello', 'yo'] <type 'list'>"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Lists (and all collections) are also indexed with square brackets\n",
      "# NOTE: The first index is zero, not one\n",
      "print a[0]\n",
      "print a[1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "hi\n",
        "hello"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Lists can be sliced by putting a colon between indexes\n",
      "# NOTE: The end value is not inclusive\n",
      "print a[0:2]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['hi', 'hello']"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# You can leave off the start or end if desired\n",
      "print a[:2]\n",
      "print a[2:]\n",
      "print a[:]\n",
      "print a[:-1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['hi', 'hello']\n",
        "['yo']\n",
        "['hi', 'hello', 'yo']\n",
        "['hi', 'hello']"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Lists are objects, like everything else, and have methods such as append\n",
      "a.append('hiya')\n",
      "print a\n",
      "\n",
      "a.append([1,2])\n",
      "print a\n",
      "\n",
      "#Functions can also be applied to lists.\n",
      "print len(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['hi', 'hello', 'yo', 'hiya', [1, 2], 'hiya']\n",
        "['hi', 'hello', 'yo', 'hiya', [1, 2], 'hiya', [1, 2]]\n",
        "7"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Exercise\n",
      "\n",
      "Make a list with 5 things in it.\n",
      "Print the 4th thing in the list.\n",
      "Print the sublist containing the 3rd, 4th, and 5th things in the list."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### 3.2 Tuples\n",
      "\n",
      "We won't say a whole lot about tuples except to mention that they basically work just like lists, with\n",
      "two major exceptions:\n",
      "\n",
      "1. You declare tuples using () instead of []\n",
      "1. Once you make a tuple, you can't change what's in it"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "t = ('zero', 1, 2.0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 19
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "t"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 20,
       "text": [
        "('zero', 1, 2.0)"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "t[0] = 99"
     ],
     "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/Users/adina/Documents/swc/boot-camps/1-Python/notebooks/prepared-demos/<ipython-input-21-e77c201e67de>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m99\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### 3.3 Dictionaries\n",
      "\n",
      "A dictionary is a unordered collection of key/value pairs.  Dictionary keys are immutable, unique,and not stored in any order. There are no restrictions on values stored in dictionaries. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "d = {'first': 'alpha', 'two': 2, 2: 'two'}\n",
      "print d\n",
      "print d['first'], d[2]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{2: 'two', 'two': 2, 'first': 'alpha'}\n",
        "alpha two"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "d['first'] = 'uno'\n",
      "print d['first']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "uno"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "d['last'] = 'omega'\n",
      "print d['last']\n",
      "d[3.14159] = 'pi'\n",
      "print d[3.14159]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "omega\n",
        "pi"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print len(d), d"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "5 {3.14159: 'pi', 2: 'two', 'last': 'omega', 'two': 2, 'first': 'uno'}"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Exercise\n",
      "\n",
      "1. Make a dictionary of roman numerals to arabic (\"normal\") numerals from 1-10.  print out the equivalent of III, VI, and IX."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## If statements\n",
      "`< > <= >= == !=`"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "x = 5\n",
      "if x < 0:\n",
      "    print \"x is negative\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 27
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = -5\n",
      "if x < 0:\n",
      "    print \"x is negative\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "x is negative"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 5\n",
      "if x < 0:\n",
      "    print \"x is negative\"\n",
      "else:\n",
      "    print \"x in non-negative\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "x in non-negative"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 5\n",
      "if x < 0:\n",
      "    print \"x is negative\"\n",
      "elif x == 0:\n",
      "    print \"x is zero\"\n",
      "else:\n",
      "    print \"x is positive\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "x is positive"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Exercise\n",
      "1. Write an if statement that prints whether x is even or odd"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Loops"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "fruits = ['apples', 'oranges', 'pears', 'bananas']\n",
      "i = 0\n",
      "while i < len(fruits):\n",
      "    print fruits[i]\n",
      "    i = i + 1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "apples\n",
        "oranges\n",
        "pears\n",
        "bananas"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for fruit in fruits:\n",
      "    print fruit"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "apples\n",
        "oranges\n",
        "pears\n",
        "bananas"
       ]
      }
     ],
     "prompt_number": 33
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Use range for a range on integers\n",
      "for i in range(len(fruits)):\n",
      "    print i, fruits[i]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0 apples\n",
        "1 oranges\n",
        "2 pears\n",
        "3 bananas"
       ]
      }
     ],
     "prompt_number": 34
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Use zip to iterate over two lists at once\n",
      "fruits = ['apples', 'oranges', 'pears', 'bananas']\n",
      "prices = [0.49, 0.99, 1.49, 0.32]\n",
      "for fruit, price in zip(fruits, prices):\n",
      "    print fruit, \"cost\", price, \"each\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "apples cost 0.49 each\n",
        "oranges cost 0.99 each\n",
        "pears cost 1.49 each\n",
        "bananas cost 0.32 each"
       ]
      }
     ],
     "prompt_number": 35
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Use \"items\" to iterate over a dictionary\n",
      "# Note the order is non-deterministic\n",
      "prices = {'apples': 0.49, 'oranges': 0.99, 'pears': 1.49, 'bananas': 0.32}\n",
      "for fruit, price in prices.items():\n",
      "    print fruit, \"cost\", price, \"each\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "pears cost 1.49 each\n",
        "apples cost 0.49 each\n",
        "oranges cost 0.99 each\n",
        "bananas cost 0.32 each"
       ]
      }
     ],
     "prompt_number": 36
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Calculating a sum\n",
      "sum = 0\n",
      "values = [1,2,3,4]\n",
      "for x in values:\n",
      "    sum = sum + x\n",
      "sum"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 38,
       "text": [
        "10"
       ]
      }
     ],
     "prompt_number": 38
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Challenge:\n",
      "\n",
      "1. Using a loop, calculate the factorial of 42 (the product of all integers up to and including 42)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "product = 1\n",
      "for x in range(1, 42 + 1):\n",
      "    product = product * x\n",
      "print '%.4e' % product"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1.4050e+51"
       ]
      }
     ],
     "prompt_number": 52
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}