Chapter2.BasicPython.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Chapter 2. Basic Python"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Quentin CAUDRON, Princeton University"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This section moves quickly. I'm assuming that everyone speaks at least one programming language, and so this chapter gives a lightning intro to syntax in Python. The sections are subheaded, but they really overlap quite a lot, so they're there more as a page reference..."
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Variables and Arithmetic"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(\"Is this thing on ?\")\n",
      "print 'Yeah, I think so.'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Is this thing on ?\n",
        "Yeah, I think so.\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In standard programming language tradition, we begin with a \"Hello world\" equivalent. We can immediately see a few things :\n",
      "\n",
      "1. Standard in / out ( writing to screen, for instance ) is available without invoking any libraries. That is, the Python Standard Library comes with some useful things - w00t.\n",
      "\n",
      "2. Strings are delimited by `\"\"`, but can also use `''`. This is useful because you can now use one set of quotes inside another, and it'll still be one big string.\n",
      "\n",
      "3. The `print` function seems to be happy with and without brackets. This is only true in Py2. Py3 requires brackets, and because `print` is a function that takes arguments like any other, we'll *try* keep the brackets as good practice - but I usually fail here..."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "s = \"This is a string.\"\n",
      "print(s)\n",
      "print(type(s))\n",
      "\n",
      "s = 42\n",
      "print(s)\n",
      "print(type(s))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "This is a string.\n",
        "<type 'str'>\n",
        "42\n",
        "<type 'int'>\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "raw",
     "metadata": {},
     "source": [
      "Variables don't need to be given a type, as Python is *dynamically-typed*. That means if I wanted to reuse `s` as an integer, Python would have no issue with that."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(s * 2) # Multiplication\n",
      "print(s + 7) # This one's really hard"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "84\n",
        "49\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Single-line comments use `#`. Arithmetic uses the standard operators : `+`, `-`, `*`, `/`. You can take powers using `**`. Python also allows C-like `+=` syntax :"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "s += 2**3\n",
      "print s"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "50\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Note that, two cells up, we called `s*2` and `s+7`, but never used `=`, so we never changed `s`. In the last cell, however, we used `+=`. \n",
      "\n",
      "That statement is equivalent to saying `s = s + 2**3`, it's just shorthand. Also works with `-=`, `*=`, `/=`, `**=`"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(s == 42)\n",
      "print(s == 50)\n",
      "print(s > 10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "False\n",
        "True\n",
        "True\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The `==` operator is the *comparison* operator. Here, we also see Python's syntax for logical statements : `True` and `False`. As with any programming syntax, capitalisation is important. In Python, `1` is also `True`, and `0` is also `False`."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = \"Blah\"\n",
      "print(x + x)\n",
      "print(len(x))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "BlahBlah\n",
        "4\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Lists"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Strings can be concatenated using the `+` operator. The `len()` function returns the length of a string. This also works for lists :"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "mylist = [1, 2.41341]\n",
      "mylist.append(\"We can mix types !\")\n",
      "\n",
      "print(mylist)\n",
      "print(\"Length is \" + str(len(mylist))) # note how we TYPECAST an integer ( returned by len() ) into a string\n",
      "print(type(mylist))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 2.41341, 'We can mix types !']\n",
        "Length is 3\n",
        "<type 'list'>\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Here, we typecast the integer `len(mylist)` into a string by simply calling `str` on it. We can typecast to any valid Python type : `float`, `int`, `str`, `complex`, ...\n",
      "\n",
      "Python accesses elements in lists from 0, not from 1 as in Matlab or R. This will be familiar to C users."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(mylist[0])\n",
      "print(mylist[1])\n",
      "print(mylist[2])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1\n",
        "2.41341\n",
        "We can mix types !\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Control Structures"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "For loops in Python are really cool. Python objects like lists are *iterables*. That is, we can directly iterate over them :"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in mylist :\n",
      "    print i"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1\n",
        "2.41341\n",
        "We can mix types !\n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "*Note the indentation* - this is really important. Loops in Python don't get delimited by brackets like in C or R. Each block gets its own indentation. Typically, people use tabs, but you can use any amount of whitespace you want *as long as you are consistent*. To end the loop, simply unindent. We'll see that in a few lines.\n",
      "\n",
      "Here, the keyword `in` individually returns members of `mylist`. It can also be used to check whether something is in a container :\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print (1 in mylist)\n",
      "print (2 in mylist)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "True\n",
        "False\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If you wanted to loop by number of the list, we can use `range()`, which, in its simplest ( single-argument ) form, returns a list from 0 to that element minus 1."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(range(5))\n",
      "\n",
      "for i in range(len(mylist)) :\n",
      "    print i, mylist[i]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0, 1, 2, 3, 4]\n",
        "0 1\n",
        "1 2.41341\n",
        "2 We can mix types !\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A quick way to do this is the `enumerate` function :"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for index, value in enumerate(mylist) :\n",
      "    print(\"Element number \" + str(index) + \" in the list has the value \" + str(value))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Element number 0 in the list has the value 1\n",
        "Element number 1 in the list has the value 2.41341\n",
        "Element number 2 in the list has the value We can mix types !\n"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Great. What about while loops and if statements ?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 10\n",
      "\n",
      "while x > 0 :\n",
      "    \n",
      "    if x != 1 :\n",
      "        print(str(x) + \" bottles of beer on the wall,\")\n",
      "        \n",
      "    elif x == 1 :\n",
      "        print(str(x) + \" bottle of beer on the wall,\")\n",
      "        \n",
      "    else : \n",
      "        print(\"This will never actually happen.\")\n",
      "        \n",
      "    x -= 1\n",
      "    \n",
      "print \"All the beer is gone :(\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "10 bottles of beer on the wall,\n",
        "9 bottles of beer on the wall,\n",
        "8 bottles of beer on the wall,\n",
        "7 bottles of beer on the wall,\n",
        "6 bottles of beer on the wall,\n",
        "5 bottles of beer on the wall,\n",
        "4 bottles of beer on the wall,\n",
        "3 bottles of beer on the wall,\n",
        "2 bottles of beer on the wall,\n",
        "1 bottle of beer on the wall,\n",
        "All the beer is gone :(\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Notice how the contents of the while loop are indented, and then code that is outside the loop continues unindented below. Here's a nested loop to clarify :"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in range(1, 5) :\n",
      "    blah = 0\n",
      "    \n",
      "    for j in range(i) :\n",
      "        blah += j\n",
      "        \n",
      "    print \"i = \" + str(i), blah"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "i = 1 0\n",
        "i = 2 1\n",
        "i = 3 3\n",
        "i = 4 6\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Here, we used `range()` with two arguments. It generates a list from the first argument to the second argument minus 1. Also, note that we can feed the `print` statement several things to print, separated by a comma. Again, we can use brackets if we want for `print`."
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Interacting Between Different Variable Types"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Beware of integer division. Unlike C, Python *uptypes* cross-type operations. Unlike R, Python does not uptype integer operations."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "myint = 2\n",
      "myfloat = 3.14\n",
      "print type(myint), type(myfloat)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<type 'int'> <type 'float'>\n"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Multiplying an int with a float gives a float, we've UPTYPED\n",
      "print myint * myfloat\n",
      "print type(myint * myfloat)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "6.28\n",
        "<type 'float'>\n"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# But operations between SAME type gives the same type :\n",
      "print 7 / 3\n",
      "print type(7/3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2\n",
        "<type 'int'>\n"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Quick hack with ints to floats - there's no need to typecast, just give it a float \n",
      "print 7. / 3\n",
      "print type(7 / 3.0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2.33333333333\n",
        "<type 'float'>\n"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "More Lists : Accessing Elements"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's go back to lists. They're a type of generic, ordered container; their elements can be access in several ways."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create a list of integers 0, 1, 2, 3, 4\n",
      "A = range(5);\n",
      "print A"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0, 1, 2, 3, 4]\n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Let's replace the middle element\n",
      "A[2] = \"Naaaaah\"\n",
      "print A"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0, 1, 'Naaaaah', 3, 4]\n"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# What are the middle three elements ? Let's use the : operator\n",
      "# Like range(), it creates a list of integers\n",
      "# 1:4 will give us 1, 2, 3 because we stop at n-1, like with range()\n",
      "print A[1:4]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 'Naaaaah', 3]\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# So what's the point of both range() and the : operator ?\n",
      "# We don't need to give it a start or an end with :\n",
      "print A[:2]\n",
      "print A[2:]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0, 1]\n",
        "['Naaaaah', 3, 4]\n"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Can we access the last element ? What about the last two ?\n",
      "print A[len(A)-2:]\n",
      "print A[-2:]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[3, 4]\n",
        "[3, 4]\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Earlier, we saw that range() can take two arguments : range(start, finish) \n",
      "# It can actually take a third : range(start, finish, stride)\n",
      "print range(0, 10, 2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0, 2, 4, 6, 8]\n"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Similarly, the : operator can also do this\n",
      "print A[0:5:2]\n",
      "# Here, it will give us elements 0, 2, 4."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0, 'Naaaaah', 4]\n"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Again, what if I don't want to explicitly remember the size of the list ?\n",
      "print A[::2]\n",
      "# This will simply go from start to finish with a stride of 2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0, 'Naaaaah', 4]\n"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# And this one, from the second element to finish, with a stride of 2\n",
      "print A[1::2]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 3]\n"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# So, uh... Reverse ?\n",
      "print A[::-1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[4, 3, 'Naaaaah', 1, 0]\n"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# List arithmetic is fun, but don't get too attached : you may not be using many lists in the future...\n",
      "print A + A\n",
      "print A * 4"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0, 1, 'Naaaaah', 3, 4, 0, 1, 'Naaaaah', 3, 4]\n",
        "[0, 1, 'Naaaaah', 3, 4, 0, 1, 'Naaaaah', 3, 4, 0, 1, 'Naaaaah', 3, 4, 0, 1, 'Naaaaah', 3, 4]\n"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Dictionaries"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's take a very brief look at *dictionaries*. These are unordered containers that you can use to pair elements in, similar to a `std::map` if you're a C++ coder. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "pythonSkillz = { \"Quentin\" : 37651765, \"Paul\" : 0.2 }\n",
      "print pythonSkillz"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "{'Paul': 0.2, 'Quentin': 37651765}\n"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Dictionaries associate keys with values\n",
      "print pythonSkillz.keys()\n",
      "print pythonSkillz.values()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['Paul', 'Quentin']\n",
        "[0.2, 37651765]\n"
       ]
      }
     ],
     "prompt_number": 31
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# You can access them through their keys\n",
      "print pythonSkillz[\"Quentin\"]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "37651765\n"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "There are a couple of other built-in containers, like *tuples* and *sets*. I won't go into them here, plainly because I have to use them so rarely that it's not worth the time during the session. If you want to read up : `http://docs.python.org/2/tutorial/datastructures.html`"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "List Comprehension and Inlines"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A couple of cool final tricks :"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Let's build a list of elements 1^2, 2^2, 3^2, ..., 10^2\n",
      "x = range(1, 11)\n",
      "print [i**2 for i in x]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
       ]
      }
     ],
     "prompt_number": 33
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# We can inline if statements too\n",
      "print \"Trust me, I know what I'm doing.\" if pythonSkillz[\"Paul\"] > 0 else \"Whaaaaaaa\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Trust me, I know what I'm doing.\n"
       ]
      }
     ],
     "prompt_number": 34
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "That concludes the syntactical introduction to Python. Next : functions."
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Functions"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Fibonacci numbers\n",
      "# OH NO RECURSION\n",
      "\n",
      "def fib(n) :\n",
      "    if n == 0 :\n",
      "        return 0\n",
      "    elif n == 1 :\n",
      "        return 1\n",
      "    else :\n",
      "        return fib(n-1) + fib(n-2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 35
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Testing :\n",
      "for i in range(10): \n",
      "    print fib(i)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0\n",
        "1\n",
        "1\n",
        "2\n",
        "3\n",
        "5\n",
        "8\n",
        "13\n",
        "21\n",
        "34\n"
       ]
      }
     ],
     "prompt_number": 36
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Looks good. We've just defined a function that takes one argument, `n`, and returns something based on what `n` is. The Fibonacci function is quite particular because it calls itself ( recursion ), but it's a small, fun example, so why not."
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Better Printing"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Earlier, I used the `+` operator to *concatenate* a number into a string. To do that, I had to typecast it. Not great. This is the better way to do it :"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def printFib(i) :\n",
      "    print \"The %dth number of the Fibonnaci sequence is %d.\" % (i, fib(i))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 37
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "printFib(20)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The 20th number of the Fibonnaci sequence is 6765.\n"
       ]
      }
     ],
     "prompt_number": 38
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Here, `%d` is a format code for *integer*. `%f` is for floating point numbers ( floats ), and `%s` is for strings. The sneaky one to know is `%r`, which just takes any type.\n",
      "\n",
      "Note how, to pass more than one thing in, we had to put it into round brackets. This is a *tuple*, we mentioned it briefly in the last notebook. It's basically just an immutable list. String formatting like this takes tuples. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# I stole this one from Learn Python The Hard Way ( highly recommended ) :\n",
      "formatstring = \"%r %r %r %r\"\n",
      "print formatstring % (formatstring, formatstring, formatstring, formatstring)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "'%r %r %r %r' '%r %r %r %r' '%r %r %r %r' '%r %r %r %r'\n"
       ]
      }
     ],
     "prompt_number": 39
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Also worth knowing are `\\n` and `\\t` : the newline and tab characters, respectively."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Written on-the-fly, because I got mad skills\n",
      "print \"This is a haiku\\n\\tI'm crappy at poetry\\n\\t\\tWait, this really worked\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "This is a haiku\n",
        "\tI'm crappy at poetry\n",
        "\t\tWait, this really worked\n"
       ]
      }
     ],
     "prompt_number": 40
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "File IO"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A very, *very* quick look at file IO, because there are packages that can do a better job."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "myfile = open(\"README.MD\", \"r\")\n",
      "for line in myfile :\n",
      "    print line\n",
      "    \n",
      "# There are other options instead of looping over each line. You can instead use myfile.read().\n",
      "# Writing : you can dump a variable using myfile.write() after having opened it in \"w\" mode.\n",
      "\n",
      "# There are many other ways to read and write files, including ways to read and write CSV directly."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Getting Started With Python\n",
        "\n",
        "===========================\n",
        "\n",
        "\n",
        "\n",
        "A very quick set of IPython Notebooks to get you started with Python.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "Target Audience\n",
        "\n",
        "---------------\n",
        "\n",
        "\n",
        "\n",
        "I'll be using this set of notebooks to give a very brief intro do Python, and how to get started writing in Python. This is not intended to be a standalone tutorial : it's written so you can come back to it and remind yourself of what was said during the session. I hope they'll help.\n"
       ]
      }
     ],
     "prompt_number": 41
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "OK, with that - onto the Scientific Python Stack."
     ]
    }
   ],
   "metadata": {}
  }
 ]
}