ch06(c).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction to Python (3)\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functions\n",
    "\n",
    "### Defining a function\n",
    "\n",
    "A function definition includes its __name__, __arguments__ and __body__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def add_two(number):\n",
    "    return number + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print add_two(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in xrange(4):\n",
    "    print i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in range(4):\n",
    "    print i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "xrange"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(xrange(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class xrange in module __builtin__:\n",
      "\n",
      "class xrange(object)\n",
      " |  xrange(stop) -> xrange object\n",
      " |  xrange(start, stop[, step]) -> xrange object\n",
      " |  \n",
      " |  Like range(), but instead of returning a list, returns an object that\n",
      " |  generates the numbers in the range on demand.  For looping, this is \n",
      " |  slightly faster than range() and more memory efficient.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __getattribute__(...)\n",
      " |      x.__getattribute__('name') <==> x.name\n",
      " |  \n",
      " |  __getitem__(...)\n",
      " |      x.__getitem__(y) <==> x[y]\n",
      " |  \n",
      " |  __iter__(...)\n",
      " |      x.__iter__() <==> iter(x)\n",
      " |  \n",
      " |  __len__(...)\n",
      " |      x.__len__() <==> len(x)\n",
      " |  \n",
      " |  __reduce__(...)\n",
      " |  \n",
      " |  __repr__(...)\n",
      " |      x.__repr__() <==> repr(x)\n",
      " |  \n",
      " |  __reversed__(...)\n",
      " |      Returns a reverse iterator.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __new__ = <built-in method __new__ of type object>\n",
      " |      T.__new__(S, ...) -> a new object with type S, a subtype of T\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(xrange)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function range in module __builtin__:\n",
      "\n",
      "range(...)\n",
      "    range(stop) -> list of integers\n",
      "    range(start, stop[, step]) -> list of integers\n",
      "    \n",
      "    Return a list containing an arithmetic progression of integers.\n",
      "    range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.\n",
      "    When step is given, it specifies the increment (or decrement).\n",
      "    For example, range(4) returns [0, 1, 2, 3].  The end point is omitted!\n",
      "    These are exactly the valid indices for a list of 4 elements.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(range)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dir(__builtin__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Functions\n",
    "===\n",
    "\n",
    "Keyword arguments\n",
    "---\n",
    "\n",
    "Besides regular arguments, functions can have keyword arguments. Note in definition the default-value argument should come after the non-default argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def add_some_other_number(number, other_number=12):\n",
    "    return number + other_number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_some_other_number(other_number=12, number=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_some_other_number(2, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_some_other_number(3, other_number=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_some_other_number(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Functions\n",
    "===\n",
    "\n",
    "Docstrings\n",
    "---\n",
    "\n",
    "Like many other definitions, functions can have docstrings.\n",
    "\n",
    "* Docstrings are regular string values which you start the definition body with.\n",
    "* You can access an object's docstring using `help`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    \"\"\"Compute factorial of n in the obious way.\"\"\"\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return factorial(n - 1) * n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function factorial in module __main__:\n",
      "\n",
      "factorial(n)\n",
      "    Compute factorial of n in the obious way.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(factorial)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Functions\n",
    "===\n",
    "\n",
    "Functions are values\n",
    "---\n",
    "\n",
    "We can pass functions around just like other values, and call them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "functions = [add_two, add_some_other_number]\n",
    "for function in functions:\n",
    "    print function(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simple anonymous functions can be created with `lambda`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "16\n",
      "28\n"
     ]
    }
   ],
   "source": [
    "functions.append(lambda x: x * 7)\n",
    "for function in functions:\n",
    "    print function(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Functions\n",
    "===\n",
    "\n",
    "Higher-order functions\n",
    "---\n",
    "\n",
    "A function that takes a function as argument is a higher-order function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function map in module __builtin__:\n",
      "\n",
      "map(...)\n",
      "    map(function, sequence[, sequence, ...]) -> list\n",
      "    \n",
      "    Return a list of the results of applying the function to the items of\n",
      "    the argument sequence(s).  If more than one sequence is given, the\n",
      "    function is called with an argument list consisting of the corresponding\n",
      "    item of each sequence, substituting None for missing values when not all\n",
      "    sequences have the same length.  If the function is None, return a list of\n",
      "    the items of the sequence (or a list of tuples if more than one sequence).\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5, 6]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map(add_two, [1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function reduce in module __builtin__:\n",
      "\n",
      "reduce(...)\n",
      "    reduce(function, sequence[, initial]) -> value\n",
      "    \n",
      "    Apply a function of two arguments cumulatively to the items of a sequence,\n",
      "    from left to right, so as to reduce the sequence to a single value.\n",
      "    For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates\n",
      "    ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items\n",
      "    of the sequence in the calculation, and serves as a default when the\n",
      "    sequence is empty.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(reduce)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(lambda x, y: x*y, [1,2,3,4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "$\\S$ Exercise: k-mer counting (1/2)\n",
    "===\n",
    "\n",
    "Remember the previous exercise of finding (unique) substrings of length 3.\n",
    "\n",
    "* Make a function from your implementation.\n",
    "* Have `k` as an argument to the function.\n",
    "* Test the function on several input strings.\n",
    "\n",
    "**Note:** Editing multi-line statements in the console can be frustrating. You can try the QT console (`ipython qtconsole`) or edit your function in an editor with `%edit`:\n",
    "\n",
    "    def my_function(arg):\n",
    "        print arg * 4\n",
    "    %edit my_function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "$\\S$ Exercise: k-mer counting (2/2)\n",
    "===\n",
    "\n",
    "Modify your function to use a dictionary with substring counts.\n",
    "\n",
    "* Use the substrings as dictionary keys.\n",
    "* Use the counts as dictionary values.\n",
    "* Have the function return the dictionary.\n",
    "* Add a docstring to the function.\n",
    "* Use the function to print k-mer counts for some strings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Comprehensions\n",
    "===\n",
    "\n",
    "List comprehensions\n",
    "---\n",
    "\n",
    "Similar to mathematical set notation (e.g., $\\{ x ~|~ x \\in \\mathbf R \\land x > 0\\}$), we can create lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 1), (3, 9), (5, 25), (7, 49), (9, 81)]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(x, x * x) for x in range(10) if x % 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do the same thing using `map` and `filter`, but list comprehensions are often more readable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 1), (3, 9), (5, 25), (7, 49), (9, 81)]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map(lambda x: (x, x * x), filter(lambda x: x % 2, range(10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Comprehensions\n",
    "===\n",
    "\n",
    "Set and dictionary comprehensions\n",
    "---\n",
    "\n",
    "Similar notation can be used for (non-empty) sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'd', 'n', 'r', 's', 't'}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{c for c in 'LUMC-standard' if 'a' <= c <= 'z'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'blue': 2, 'orange': 1, 'purple': 1, 'red': 2, 'white': 1}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colors = ['red', 'white', 'blue', 'orange', 'blue', 'red', 'purple']\n",
    "{c: colors.count(c) for c in colors}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Everything is an object\n",
    "===\n",
    "\n",
    "* Objects have properties and methods. \n",
    "* Explore them using `dir(o)`, or by typing `o.<tab>` in the IPython interpreter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['swapcase', 'title', 'translate', 'upper', 'zfill']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir('abc')[-5:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function upper:\n",
      "\n",
      "upper(...)\n",
      "    S.upper() -> string\n",
      "    \n",
      "    Return a copy of the string S converted to uppercase.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help('abc'.upper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ABC'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc'.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $\\S$ Exercise 1: Compare two strings\n",
    "\n",
    "Write a function `istrcmp` to compare two strings, ignoring the case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $\\S$ Exercise 2: Built-in functions\n",
    "\n",
    " What happens when you call the built-in `min` and `max` functions with a list of strings?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $\\S$ Exercise 3: Cumulative sums\n",
    "\n",
    "Cumulative sum of a list [a, b, c, ...] is defined as [a, a+b, a+b+c, ...]. Write a function cumulative_sum to compute cumulative sum of a list. Does your implementation work for a list of strings?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $\\S$ Exercise 4: Cumulative products\n",
    "\n",
    "Cumulative products of a list [a, b, c, ...] is defined as [a, a*b, a*b*c, ...]. Write a function `cumulative_sum` to compute cumulative product of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $\\S$ Exercise 5: Lists\n",
    "Write a function unique to find all the unique elements of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $\\S$ Exercise 6: Lists\n",
    "Write a function unique to find all the duplicate elements of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $\\S$ Exercise 7: Lists\n",
    "Write a function `group(list, size)` that take a `list` and splits into smaller lists of given `size`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $\\S$ Exercise 8: Strings\n",
    "\n",
    "* Write a function `mutate` to compute all words generated by a single mutation on a given word. A mutation is defined as\n",
    "\n",
    "   * inserting a character,\n",
    "   * deleting a character, \n",
    "   * replacing a character, or \n",
    "   * swapping 2 consecutive characters\n",
    "\n",
    "in a string. For simplicity consider only letters from a to z.\n",
    "\n",
    "* Write a function `nearly_equal` to test whether two strings are nearly equal. Two strings a and b are nearly equal when a can be generated by a single mutation on b."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $\\S$ Exercise 9: Dictionaries\n",
    "\n",
    "Write a `valuesort` function to sort a given dictionary based on the values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sorted in module __builtin__:\n",
      "\n",
      "sorted(...)\n",
      "    sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sorted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sort:\n",
      "\n",
      "sort(...)\n",
      "    L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;\n",
      "    cmp(x, y) -> -1, 0, 1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = [2, 3, 5]\n",
    "help(a.sort)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d = {'a':2, 'b':10, 'c':9}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = [(k,v) for k, v in d.items()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 2), ('c', 9), ('b', 10)]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x.sort(key=lambda x: x[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 2), ('c', 9), ('b', 10)]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a:2\n",
      "c:9\n",
      "b:10\n"
     ]
    }
   ],
   "source": [
    "for i,j in x:\n",
    "    print \"{}:{}\".format(i, j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Further reading\n",
    "===\n",
    "\n",
    "* [The Python Tutorial](http://docs.python.org/2/tutorial/index.html)\n",
    "  <br>\n",
    "  From the official Python documentation.\n",
    "\n",
    "\n",
    "* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)\n",
    "  <br>\n",
    "  Book on learning Python by exercises, online available for free.\n",
    "\n",
    "\n",
    "* [The Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)\n",
    "  <br>\n",
    "  This opinionated guide exists to provide both novice and expert Python developers a best-practice handbook to the installation, configuration, and usage of Python on a daily basis.\n",
    "\n",
    "\n",
    "* [A Primer on Scientific Programming with Python](http://codingcat.com/knjige/python/A%20Primer%20on%20Scientific%20Programming%20with%20Python.pdf)\n",
    "  <br>\n",
    "  Complete PDF version of the book. The aim of this book is to teach computer programming using examples from mathematics and the natural sciences.\n",
    "\n",
    "\n",
    "* [Python Module of the Week](http://pymotw.com/)\n",
    "  <br>\n",
    "  Series of articles providing a tour of the Python standard library through short examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}