1.BasicPython.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introductory Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "#### Quentin CAUDRON  <br /> <br />  Ecology and Evolutionary Biology <br /> <br />  qcaudron@princeton.edu <br /> <br />  @QuentinCAUDRON"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "This section moves quickly. I'm assuming that everyone speaks at least one programming language well, and / or has introductory Python experience, 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": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Variables and Arithmetic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "He said, 'what ?'\n"
     ]
    }
   ],
   "source": [
    "print(\"He said, 'what ?'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a string.\n",
      "<class 'str'>\n",
      "17\n"
     ]
    }
   ],
   "source": [
    "s = \"This is a string.\"\n",
    "print(s)\n",
    "print(type(s))\n",
    "print(len(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "s = 42\n",
    "print(s)\n",
    "print(type(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "84\n",
      "49\n"
     ]
    }
   ],
   "source": [
    "print(s * 2)\n",
    "print(s + 7)\n",
    "# Neither statement modifies the variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Single-line comments use `#`. \n",
    "\n",
    "Arithmetic uses the standard operators : `+`, `-`, `*`, `/`. \n",
    "\n",
    "You can take powers using `**`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python also allows `+=` syntax :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Same as s = s + 2**3\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "s += 2**3 # s is being incremented by 2^3\n",
    "print(\"Same as s = s + 2**3\")\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "This statement is equivalent to saying `s = s + 2**3`, it's just shorthand. Also works with \n",
    "\n",
    "`-=`, `*=`, `/=`, `**=`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(s == 42)\n",
    "print(s == 50)\n",
    "print(s > 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "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",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BlahBlah\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "x = \"Blah\"\n",
    "print(x + x)\n",
    "print(len(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings can be concatenated using the `+` operator. The `len()` function returns the length of a string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2.41341, 'We can mix types !']\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "mylist = [1, 2.41341]\n",
    "mylist.append(\"We can mix types !\")\n",
    "\n",
    "print(mylist)\n",
    "print(type(mylist))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python accesses elements in lists from 0, not from 1 as in Matlab or R. This will be familiar to C and Java users.\n",
    "\n",
    "`.append` is a *method* of the list class - it's a function that belongs to the list object, and so you can call it directly from the object itself. This particular function appends something to the end of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2.41341, 'We can mix types !'] \n",
      "\n",
      "1\n",
      "2.41341\n",
      "We can mix types !\n"
     ]
    }
   ],
   "source": [
    "print(mylist, \"\\n\")\n",
    "\n",
    "print(mylist[0])\n",
    "print(mylist[1])\n",
    "print(mylist[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Lists have several methods ( `count`, `sort`, `reverse`, `pop`, `insert`, `remove`, ... ). Here are a few."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length is 3 long.\n",
      "\n",
      "There are 1 ones in this list.\n",
      "\n",
      "Reversed ! ['We can mix types !', 2.41341, 1]\n"
     ]
    }
   ],
   "source": [
    "print(\"Length is {} long.\\n\".format(len(mylist)))\n",
    "\n",
    "print(\"There are {} ones in this list.\\n\".format(mylist.count(1)))\n",
    "\n",
    "mylist.reverse()\n",
    "print(\"Reversed ! {}\".format(mylist))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Any thoughts on why `len()` is a global function in Python, and not a method of the `list` object ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Control Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python objects like lists are *iterables*. That is, we can directly iterate over them :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We can mix types !\n",
      "Hello\n",
      "\n",
      "2.41341\n",
      "Hello\n",
      "\n",
      "1\n",
      "Hello\n",
      "\n",
      "Finished\n"
     ]
    }
   ],
   "source": [
    "for i in mylist :\n",
    "    print(i)\n",
    "    print(\"Hello\\n\")\n",
    "print(\"Finished\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note the indentation*. Loops in Python don't get delimited by brackets like in C or R. Each block gets its own indentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Users of languages like C or Java, where code blocks are delimited by curly braces, sometimes ask that they be made available in Python.\n",
    "\n",
    "    for i in range {\n",
    "        do something to i\n",
    "    }\n",
    "    \n",
    "Python's `__future__` module has already taken care of this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "not a chance (<ipython-input-12-2aebb3fc8ecf>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-12-2aebb3fc8ecf>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    from __future__ import braces\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m not a chance\n"
     ]
    }
   ],
   "source": [
    "from __future__ import braces"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The keyword `in` can also be used to check whether something is in a container :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(1 in mylist)\n",
    "print(2 in mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If you wanted to loop by indexing 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",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 We can mix types !\n",
      "1 2.41341\n",
      "2 1\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(mylist)) :\n",
    "    print(i, mylist[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Another way to do this is the `enumerate` function :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element number 0 in the list has the value We can mix types !\n",
      "Element number 1 in the list has the value 2.41341\n",
      "Element number 2 in the list has the value 1\n"
     ]
    }
   ],
   "source": [
    "for index, value in enumerate(mylist) :\n",
    "    print(\"Element number {} in the list has the value {}\".format(index, value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "What about if statements ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is greater than 3.\n",
      "We can see this, it's not in the if statement.\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "\n",
    "if x > 3 :\n",
    "    print(\"x is greater than 3.\")\n",
    "    \n",
    "elif x == 5 :\n",
    "    print(\"We aren't going to see this. Why ?\")\n",
    "    \n",
    "else :\n",
    "    print(\"x is not greater than 3.\")\n",
    "    \n",
    "print(\"We can see this, it's not in the if statement.\")"
   ]
  },
  {
   "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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Here's a nested loop to clarify :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BIG CLICK, outer loop change to 1\n",
      "*little click*, outer is still 1, and inner is 0.\n",
      "*little click*, outer is still 1, and inner is 1.\n",
      "*little click*, outer is still 1, and inner is 2.\n",
      "*little click*, outer is still 1, and inner is 3.\n",
      "BIG CLICK, outer loop change to 2\n",
      "*little click*, outer is still 2, and inner is 0.\n",
      "*little click*, outer is still 2, and inner is 1.\n",
      "*little click*, outer is still 2, and inner is 2.\n",
      "*little click*, outer is still 2, and inner is 3.\n",
      "I'm done here.\n"
     ]
    }
   ],
   "source": [
    "for outer in range(1, 3) :\n",
    "    print(\"BIG CLICK, outer loop change to {}\".format(outer))\n",
    "    \n",
    "    for inner in range(4) :\n",
    "        print(\"*little click*, outer is still {}, and inner is {}.\".format(outer, inner))\n",
    "        \n",
    "print(\"I'm done here.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Here, we used `range()` with two arguments. In Python 2, it generates a list from the first argument to the second argument minus 1. In Python 3, it returns an immutable iterable, but you can cast it to a list by calling something like `list(range(5))`. Also, note that we can feed the `print` function several things to print, separated by a comma."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Interacting Between Different Variable Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Beware of integer division with Python 2. Unlike R, Python 2 doesn't assume that everything is a float unless explicitly told; it recognises that `2` is an integer, and this can be good and bad. In Python 3, we don't need to worry about this; the following code was run under a Python 3 kernel, but test it under Python 2 to see the difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'> <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "myint = 2\n",
    "myfloat = 3.14\n",
    "print(type(myint), type(myfloat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.28\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# Multiplying an int with a float gives a float : the int was promoted.\n",
    "print(myint * myfloat)\n",
    "print(type(myint * myfloat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3333333333333335\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# A minor difference between Python 2 and Python 3 :\n",
    "print(7 / 3)\n",
    "# Py2 : 2\n",
    "# Py3 : 2.3333\n",
    "\n",
    "# In Python 2, operations between same type gives the same type :\n",
    "print(type(7 / 3))\n",
    "# Py2 : <type 'int'>\n",
    "# Py3 : <class 'float'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3333333333333335\n",
      "2.3333333333333335\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Quick hack with ints to floats - there's no need to typecast, just give it a float \n",
    "print(float(7) / 3)\n",
    "print(7 / 3.0)\n",
    "\n",
    "# In Python 3, this is handled \"correctly\"; you can use // as integer division\n",
    "print(7 // 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3333333333333335\n"
     ]
    }
   ],
   "source": [
    "# Quick note for Py2 users - see https://www.python.org/dev/peps/pep-0238/\n",
    "from __future__ import division\n",
    "print(7 / 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## More Lists : Accessing Elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Let's go back to lists. They're a type of generic, ordered container; their elements can be accessed in several ways."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# Create a list of integers 0, 1, 2, 3, 4\n",
    "A = list(range(5))\n",
    "print(A)\n",
    "\n",
    "# Py2 vs Py3 :\n",
    "# In Py2, range() returns a list already"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 'Naaaaah', 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# Let's replace the middle element\n",
    "A[2] = \"Naaaaah\"\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "What are the middle three elements ? Let's use the `:` operator. Like `range()`, it creates a list of integers.\n",
    "\n",
    "`[1:4]` will give us elements 1, 2, and 3, because we stop at n-1, like with `range()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'Naaaaah', 3]\n"
     ]
    }
   ],
   "source": [
    "print(A[1:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We don't need to give a start or an end :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1]\n",
      "['Naaaaah', 3, 4]\n"
     ]
    }
   ],
   "source": [
    "print(A[:2])\n",
    "print(A[2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Can we access the last element ? What about the last two ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4]\n",
      "[3, 4]\n"
     ]
    }
   ],
   "source": [
    "print(A[len(A)-2:])\n",
    "print(A[-2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Earlier, we saw that `range()` can take two arguments : `range(start, finish)`. It can actually take a third : `range(start, finish, stride)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(0, 5, 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `:` operator can also do the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 'Naaaaah', 4]\n"
     ]
    }
   ],
   "source": [
    "print(A[0:5:2])\n",
    "# Here, it will give us elements 0, 2, 4."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "What if I don't want to explicitly remember the size of the list ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 'Naaaaah', 4]\n"
     ]
    }
   ],
   "source": [
    "# This will simply go from start to finish with a stride of 2\n",
    "print(A[::2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3]\n"
     ]
    }
   ],
   "source": [
    "# And this one, from the second element to finish, with a stride of 2\n",
    "print(A[1::2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 3, 'Naaaaah', 1, 0]\n"
     ]
    }
   ],
   "source": [
    "# So, uh... Reverse ?\n",
    "print(A[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "List arithmetic ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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]\n"
     ]
    }
   ],
   "source": [
    "print(A + A)\n",
    "print(A * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "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",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Quentin': 0.3333333333333333, 'Paul': 42, 'Matthew': 1000.0}\n"
     ]
    }
   ],
   "source": [
    "pythonPoints = { \"Quentin\" : 1./3, \"Paul\" : 42, \"Matthew\" : 1e3 }\n",
    "print(pythonPoints)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['Quentin', 'Paul', 'Matthew'])\n",
      "dict_values([0.3333333333333333, 42, 1000.0])\n"
     ]
    }
   ],
   "source": [
    "# Dictionaries associate keys with values\n",
    "print(pythonPoints.keys())\n",
    "print(pythonPoints.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "84\n"
     ]
    }
   ],
   "source": [
    "# You can access them through their keys\n",
    "print(pythonPoints[\"Paul\"] * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ruthie has 0 mad skillz.\n"
     ]
    }
   ],
   "source": [
    "if \"Ruthie\" in pythonPoints :     # for dicts, \"in\" checks the keys\n",
    "    print(\"Ruthie's here too !\")\n",
    "    \n",
    "else :\n",
    "    pythonPoints[\"Ruthie\"] = 0\n",
    "    \n",
    "print(\"Ruthie has {} mad skillz.\".format(pythonPoints[\"Ruthie\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "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": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## List Comprehension and Inlines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "# Let's build a list of elements 1^2, 2^2, ..., 5^2\n",
    "y = [i**2 for i in range(6)]\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 squared is 0\n",
      "1 squared is 1\n",
      "2 squared is 4\n",
      "3 squared is 9\n",
      "4 squared is 16\n",
      "5 squared is 25\n"
     ]
    }
   ],
   "source": [
    "# Want to keep your index ? Use a dictionary.\n",
    "squares = { x : x**2 for x in range(6) }\n",
    "\n",
    "for key, val in squares.items() :\n",
    "    print(\"{} squared is {}\".format(key, val))\n",
    "    \n",
    "# Also useful : zip()\n",
    "# for key, val in zip(squares.keys(), squares.values()) :\n",
    "#     print(\"{} : {}\".format(key, val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "# We can inline if statements too\n",
    "print(42 if type(42) is int else 32)\n",
    "\n",
    "# Note this is interpreted as \n",
    "# print (something if a, else print something_else)\n",
    "# and not\n",
    "# (print something) if a, else (do something_else)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done defining.\n"
     ]
    }
   ],
   "source": [
    "# Fibonacci numbers\n",
    "# OH NO RECURSION\n",
    "\n",
    "def fib(n) :\n",
    "    if n < 2 :\n",
    "        return n\n",
    "    else :\n",
    "        return fib(n-1) + fib(n-2)\n",
    "    \n",
    "print(\"Done defining.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n"
     ]
    }
   ],
   "source": [
    "# Testing :\n",
    "for i in range(10) :\n",
    "    print(fib(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "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": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def printFib(i) :\n",
    "    print(\"The {}th number of the Fibonnaci sequence is {}.\".format(i, fib(i)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 20th number of the Fibonnaci sequence is 6765.\n"
     ]
    }
   ],
   "source": [
    "printFib(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Here, `%d` is a format code for *integer*. `%f` is for floating point numbers ( floats ), and `%s` is for strings.\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",
   "execution_count": 45,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start Start {} {} Start {} {}\n"
     ]
    }
   ],
   "source": [
    "# I modified this one from Learn Python The Hard Way ( highly recommended ) :\n",
    "formatstring = \"Start {} {}\"\n",
    "print(formatstring.format(formatstring, formatstring))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also worth knowing are `\\n` and `\\t` : the newline and tab characters, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a haiku\n",
      "\tI'm awful at poetry\n",
      "Wait, this really worked\n"
     ]
    }
   ],
   "source": [
    "# Written on-the-fly, because I got mad skills\n",
    "print(\"This is a haiku\\n\\tI'm awful at poetry\\nWait, this really worked\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "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",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is an example text file.\n",
      "\n",
      "It contains three lines.\n",
      "\n",
      "Maybe four.\n",
      "\n",
      "Four, definitely four.\n"
     ]
    }
   ],
   "source": [
    "myfile = open(\"example.txt\", \"r\")\n",
    "for line in myfile :\n",
    "    print(line.strip(\"\\n\"))\n",
    "    \n",
    "# There are other options instead of looping over each line. \n",
    "# You can instead use myfile.read().\n",
    "# Writing : you can dump a variable using myfile.write() \n",
    "# after having opened it in \"w\" mode.\n",
    "\n",
    "# There are many other ways to read and write files, \n",
    "# including ways to read and write CSV directly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Syntax Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ( very easy )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Generate a list `A` of integers from 4 to 28 inclusive in strides of 3. \n",
    "    - `range()`, and `list()` if you're in Python 3\n",
    "- Generate a new list `B`, squaring each element of A.\n",
    "    - list comprehensions\n",
    "    - `**` operator\n",
    "- Append a reversed version of `B` to itself\n",
    "    - `+` or `+=`\n",
    "    - `[::-1]` - be careful with `reverse`, it affects the list directly !\n",
    "- Write a function called `addflip` that will do all of this and return you the new list.\n",
    "    - `def`\n",
    "    - `return`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 7, 10, 13, 16, 19, 22, 25, 28]\n"
     ]
    }
   ],
   "source": [
    "A = list(range(4, 29, 3))\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[16, 49, 100, 169, 256, 361, 484, 625, 784]\n"
     ]
    }
   ],
   "source": [
    "B = [a**2 for a in A]\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[16, 49, 100, 169, 256, 361, 484, 625, 784, 784, 625, 484, 361, 256, 169, 100, 49, 16]\n"
     ]
    }
   ],
   "source": [
    "B += B[::-1]\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 16, 9, 4, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "def addflip(mylist) :\n",
    "    squared = [element**2 for element in mylist]\n",
    "    return squared + squared[::-1]\n",
    "\n",
    "print(addflip(range(5)))"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}