Tutorials 2 Tuples & Dictionairies.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Tuples and Dictionairies\n",
    "\n",
    "This is part of a tutorial on python basic objects.\n",
    "\n",
    "Authors: ['Arthur de Fluiter', 'Cheng-yu Lam']\n",
    "\n",
    "This particular document deals with python's `tuple`, `namedtuple`, `dict`, `defaultdict` and `Counter`. \n",
    "\n",
    "**Note, it might be good to read through the Lists and Sets Tutorial first**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuples\n",
    "\n",
    "Python has a data structure for simple data points, like coordinates called `tuples`\n",
    "\n",
    "In Python, a tuples are \n",
    " - *static* - tuples cannot be altered after creation. \n",
    " - *ordered* - the elements added first are in the tuple first\n",
    " - *non-type specific* - any element can be of a different type\n",
    "\n",
    "They typically use braces and a comma seperated list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "simple_tuple = (1,2)          # tuple with 2 elements\n",
    "large_tuple  = (1,2,3,4,5,6)  # tuple with 6 elements\n",
    "single_tuple = (1,)           # tuple with 1 element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples can, similar to lists and sets also be made with a comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "large_tuple = tuple(i+1 for i in range(6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note** like briefly mentioned above you cannot change the contents of a tuple after creation.\n",
    "Because of this there is no way to add/append anything.\n",
    "\n",
    "Similarly to lists they can be accessed with indices, slices though.\n",
    "\n",
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5, 6)\n",
      "index   3   =  4\n",
      "indices 3-5 =  (4, 5)\n"
     ]
    }
   ],
   "source": [
    "print(large_tuple)\n",
    "print(\"index   3   = \", large_tuple[3])\n",
    "print(\"indices 3-5 = \", large_tuple[3:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are a large part of what makes Python readible compared to other languages, allowing for things like nicer for-loops, sorting, formatting etc.\n",
    "\n",
    "We'll go over some of the things it enables, starting with packing/unpacking, especially in for loops.\n",
    "\n",
    "Unpacking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 1 b = 2 c = 3 d = 4\n",
      "[2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "a, b, c, d  = (1,2,3,4) # a,b,c and d are assigned the 1st till 4th part of the tuple\n",
    "print(\"a =\", a, \"b =\", b, \"c =\", c, \"d =\", d)\n",
    "\n",
    "# imagine the following conditions\n",
    "# - tuples is has at least 3 elements to unpack\n",
    "# - first and last must be in a and c\n",
    "# - middle one(s) must be captured in b\n",
    "a, *b, c = (1,2,3,4,5,6)  # Note in such an unpack, only one * is allowed\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly for loops can do the same with indices as we will see in a bit.\n",
    "\n",
    "First we'll create a list of tuples to iterate over. We want a list of tuples of letters and their index in the alphabet\n",
    "\n",
    "a has index 0, b has index 1 etc.\n",
    "\n",
    "We'll store it as (index, letter) tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 'a'), (1, 'b'), (2, 'c')]\n"
     ]
    }
   ],
   "source": [
    "letters = [(0, 'a'), (1, 'b'), (2, 'c')]\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'a') 0 a\n",
      "(1, 'b') 1 b\n",
      "(2, 'c') 2 c\n"
     ]
    }
   ],
   "source": [
    "# The normal way lists work, we loop over each element.\n",
    "# Since theyre all tuples, t is also a tuple\n",
    "for t in letters:\n",
    "    print(t, t[0], t[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'a') 0 a\n",
      "(1, 'b') 1 b\n",
      "(2, 'c') 2 c\n"
     ]
    }
   ],
   "source": [
    "# Now we can use the same unpacking\n",
    "# the same tuple is now unpacked into index and l\n",
    "for index,l in letters:\n",
    "    print((index,l), index, l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unpacking can also do one other thing when calling functions:\n",
    "It can fill in the functions arguments for us.\n",
    "\n",
    "Syntax for this is `function_name(*tuple)` or `function_name(*list)`. \n",
    "\n",
    "Example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n",
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "print(1,2,3)\n",
    "\n",
    "# same as\n",
    "args = (1,2,3)\n",
    "print(*args)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `enumerate`\n",
    "\n",
    "Earlier we create `letters` the list of indices and letters. \n",
    "\n",
    "We would like to not type this out for every letter manually, but we also don't want to make it ugly code.\n",
    "\n",
    "This is where `enumerate` comes in. It takes something to loop over, and returns a tuple of the index of the element and the element. \n",
    "\n",
    "In the case below it will be `(0, 'a'), ..., (25, 'z')`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "printing letters\n",
      "( 0,a) ( 1,b) ( 2,c) ( 3,d) ( 4,e) ( 5,f) ( 6,g) ( 7,h) ( 8,i) ( 9,j) (10,k) (11,l) (12,m)\n",
      "(13,n) (14,o) (15,p) (16,q) (17,r) (18,s) (19,t) (20,u) (21,v) (22,w) (23,x) (24,y) (25,z)\n",
      "\n",
      "\n",
      "printing letters\n",
      "( 0,a) ( 1,b) ( 2,c) ( 3,d) ( 4,e) ( 5,f) ( 6,g) ( 7,h) ( 8,i) ( 9,j) (10,k) (11,l) (12,m)\n",
      "(13,n) (14,o) (15,p) (16,q) (17,r) (18,s) (19,t) (20,u) (21,v) (22,w) (23,x) (24,y) (25,z)\n",
      "\n",
      "\n",
      "printing letters\n",
      "( 0,a) ( 1,b) ( 2,c) ( 3,d) ( 4,e) ( 5,f) ( 6,g) ( 7,h) ( 8,i) ( 9,j) (10,k) (11,l) (12,m)\n",
      "(13,n) (14,o) (15,p) (16,q) (17,r) (18,s) (19,t) (20,u) (21,v) (22,w) (23,x) (24,y) (25,z)\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# some helper code\n",
    "alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "\n",
    "def print_letters():\n",
    "    print(\"printing letters\")\n",
    "    for index, l in letters:\n",
    "        print(\"(%2d,%s)\" % (index, l), end=\"\\n\" if ((index + 1) % 13) == 0 else \" \")\n",
    "    print(\"\\n\")\n",
    "# ---------------------------\n",
    "# actual code\n",
    "\n",
    "# Naive code\n",
    "i       = 0\n",
    "letters = []\n",
    "for letter in alphabet:\n",
    "    letters.append((i, letter))\n",
    "    i += 1\n",
    "print_letters()\n",
    "    \n",
    "    \n",
    "# Better code, with enumerate\n",
    "letters = []\n",
    "for index, letter in enumerate(alphabet):\n",
    "    letters.append((index, letter))\n",
    "print_letters()\n",
    "    \n",
    "# Best code, list comprehension and enumerate\n",
    "letters = [ (index, letter) for index, letter in enumerate(alphabet)]\n",
    "print_letters()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `zip`\n",
    "\n",
    "`zip` allows you to \"transpose\" lists, tuples and other iterables, like you would a matrix.\n",
    "\n",
    "that is \n",
    "\n",
    "    zip([1,2,3,4], ['a', 'b', 'c', 'd'])        becomes [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')] and\n",
    "    zip((1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')) becomes [1,2,3,4], ['a', 'b', 'c', 'd']\n",
    "\n",
    "Or viewed as a table\n",
    "\n",
    "  | col1 | col2 | col3\n",
    "---- | ---- | ---- | ---- \n",
    "row1 |    2 |    3 |    4\n",
    "row2 |    5 |    6 |    7\n",
    "\n",
    "Becomes\n",
    "\n",
    "   | row1 | row2\n",
    "---- | ---- | ----\n",
    "col1 |    2 |    5\n",
    "col2 |    3 |    6\n",
    "col3 |    4 |    7\n",
    "\n",
    "And its the reverse.\n",
    "\n",
    "Example: getting the individual letters back from `letters`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "printing letters\n",
      "( 0,a) ( 1,b) ( 2,c) ( 3,d) ( 4,e) ( 5,f) ( 6,g) ( 7,h) ( 8,i) ( 9,j) (10,k) (11,l) (12,m)\n",
      "(13,n) (14,o) (15,p) (16,q) (17,r) (18,s) (19,t) (20,u) (21,v) (22,w) (23,x) (24,y) (25,z)\n",
      "\n",
      "\n",
      "becomes\n",
      "\n",
      "(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25)\n",
      "('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z')\n"
     ]
    }
   ],
   "source": [
    "print_letters()\n",
    "\n",
    "print(\"becomes\\n\")\n",
    "\n",
    "indices, indiv_letters = zip(*letters)\n",
    "print(indices)\n",
    "print(indiv_letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### string formatting\n",
    "\n",
    "Often you will want to print something in a nice fashion, as misaligned text does not make people very happy. \n",
    "\n",
    "The \"old way\" of formatting strings in python is done with tuples. It works as follows:\n",
    "\n",
    "    \"format string\" % (tuple, with, data)\n",
    "\n",
    "The format string is very similar to C-style formatting (exact details [here](https://docs.python.org/2.4/lib/typesseq-strings.html))\n",
    "\n",
    "In basis: \n",
    "\n",
    " Symbol | Meaning\n",
    "------  | --------\n",
    "  `%%`  | just a percentage sign (escaped)\n",
    "   `%`  | should be filled in with variable\n",
    "  `%s`  | should be filled in with string (calls `str`) if not string\n",
    "  `%d`  | should be printed as integer. \n",
    "  `%x`  | view argument as number and print as hexidecimal \n",
    "`%15s`  | filled with string, if string falls short of 15 characters, fills rest with spaces from left\n",
    "`%-15s` | same as previous but fills from the right. \n",
    "\n",
    "Note that the nth argument in the tuple should correspond to the nth variable in the format string\n",
    "\n",
    "For details, again, you can check out the documentation. \n",
    "\n",
    "Example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Albert        20\n",
      "Heijn         49\n",
      "Stein         10\n",
      "\n",
      "rather than\n",
      "\n",
      "Albert 20\n",
      "Heijn 49\n",
      "Stein 10\n"
     ]
    }
   ],
   "source": [
    "person_names =   ['Albert', 'Heijn', 'Stein']\n",
    "person_incomes = [     20 ,     49 ,     10 ]\n",
    "\n",
    "for name,income in zip(person_names, person_incomes):\n",
    "    print(\"%-10s %5d\" % (name, income))\n",
    "\n",
    "print(\"\\nrather than\\n\")\n",
    "\n",
    "for name,income in zip(person_names, person_incomes):\n",
    "    print(name, income)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** sorting **\n",
    "\n",
    "Also you'll often come across a situation where you want to sort something based on something else, say you're dealing with persons, and you want to sort based on income. Tuples come in quite handy here as well.\n",
    "\n",
    "Sorting with tuples happens as follows, by default the sorting algorithm looks at the first part of the tuple and sorts based first on that, after that the second one etc.\n",
    "\n",
    "so sorting the following \n",
    "    \n",
    "    (2, \"def\"), (2, \"aaa\"), (1, \"abc\") \n",
    "\n",
    "will output\n",
    "\n",
    "    (1, \"abc\"), (2, \"aaa\"), (2, \"def\")\n",
    "\n",
    "\n",
    "Alternatively, we can tell the sorting algorithm where to find the `key` which it sorts on"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "People sorted on salary low to high\n",
      "Stein         10\n",
      "Albert        20\n",
      "Heijn         49\n"
     ]
    }
   ],
   "source": [
    "print(\"People sorted on salary low to high\")\n",
    "for income, name in sorted(zip(person_incomes, person_names)):\n",
    "    print(\"%-10s %5d\" % (name, income))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "People sorted on salary high to low\n",
      "Heijn         49\n",
      "Albert        20\n",
      "Stein         10\n"
     ]
    }
   ],
   "source": [
    "print(\"People sorted on salary high to low\")\n",
    "for income, name in sorted(zip(person_incomes, person_names), reverse=True):\n",
    "    print(\"%-10s %5d\" % (name, income))    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we keep the order of name first and income as second argument but sort based on the second argument with a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "People sorted on salary high to low\n",
      "Heijn         49\n",
      "Albert        20\n",
      "Stein         10\n"
     ]
    }
   ],
   "source": [
    "# we want to sort based on the second argument, the income\n",
    "def give_second(person):\n",
    "    return person[1]\n",
    "\n",
    "print(\"People sorted on salary high to low\")\n",
    "for name, income in  sorted(zip(person_names, person_incomes), key=give_second, reverse=True):\n",
    "    print(\"%-10s %5d\" % (name, income))   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Named tuples\n",
    "\n",
    "Accessing tuples by indexes (`t[0]`) is considered difficult to read, so to help out, named_tuples were created (you need to get them from the `collections` module)\n",
    "\n",
    "They work the same as tuples in almost any aspect, except that you can access elements with nice names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2)\n",
      "1\n",
      "2\n",
      "coordinate(x=1, y=2)\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "from collections import namedtuple\n",
    "\n",
    "# Create a new sort of tuple called a coordinate, consisting of an x, and a y\n",
    "Coordinate = namedtuple('coordinate', ['x', 'y'])\n",
    "\n",
    "# create a coordinate with a raw tuple\n",
    "raw_coordinate = (1, 2)\n",
    "proper_coordinate = Coordinate(1, 2)\n",
    "\n",
    "# difficult to tell what argument is the x and what argument is the y\n",
    "print(raw_coordinate)\n",
    "print(raw_coordinate[0])   # this is the x\n",
    "print(raw_coordinate[1])   # this is the y\n",
    "\n",
    "# easier to tell the x and y apart\n",
    "print(proper_coordinate)\n",
    "print(proper_coordinate.x) # this is the x\n",
    "print(proper_coordinate.y) # this is the y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# dict\n",
    "\n",
    "A very basic data type in python is the dict, short for dictionairy.\n",
    "\n",
    "The idea behind it is to map one object to another, a simple example would be an actual dictionairy, which maps a word to its definition.\n",
    "\n",
    "Or in python terminology, dicts consists of keys (the words) and a values (the desciptions), the keys as well as the values may be of any type. \n",
    "\n",
    "Going back to the dictionairy example, imagine we're trying to make an oxford `dict`. For instance if we look up the word `\"python\"` in the oxford dictionairy, we get these entries:\n",
    "\n",
    "- A large heavy-bodied non-venomous snake occurring throughout the Old World tropics, killing prey by constriction and asphyxiation.\n",
    "- Computing [mass noun] A high-level general-purpose programming language.\n",
    "\n",
    "Let's find out how we can make this, starting with an empty dictionairy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "oxford = dict()  # long  form\n",
    "oxford = {}      # short form"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filling the `dict`\n",
    "\n",
    "As mentioned before, `dicts` consist out of keys and values. \n",
    "\n",
    "You're trying to map one thing to another.\n",
    "\n",
    "Let's see an example of this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "oxford['python'] = 'A snake'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's all there is to it, now let's set some more entries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# needs to be created first, if it didnt exist already\n",
    "oxford = dict() \n",
    "\n",
    "# filling the oxford with\n",
    "# 'a' -> 'Letter 1 of alphabet'\n",
    "# ...\n",
    "# 'z' -> 'Letter 26 of alphabet'\n",
    "for i, l in enumerate(\"abcdefghijklmnopqrstuvwxyz\"):\n",
    "    oxford[l] = 'Letter %d of the alphabet' % (i + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since python is trying to be as short and readable as possible, it is possible to set some key value pairs while creating a dictionairy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Letter 1 of the alphabet\n"
     ]
    }
   ],
   "source": [
    "# python's simple way of creating initialised dicts (stores 2 key,value pairs)\n",
    "oxford = {\n",
    "    'a' : 'First letter of alphabet',\n",
    "    'z' : 'Last letter of alphabet'\n",
    "}\n",
    "\n",
    "# more complicated comprehension form, allows for 26 key value pairs to be created here\n",
    "oxford = { l : 'Letter %d of the alphabet' % (i + 1) for i, l in enumerate(\"abcdefghijklmnopqrstuvwxyz\") }\n",
    "\n",
    "print(oxford['a'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### our oxford `dict`\n",
    "\n",
    "Looking back we saw that `\"python\"` actually can mean 2 things, since we can only store one thing in `oxford['python']` we need to work around this.\n",
    "\n",
    "We can do this by letting `oxford['python']` be a list rather than just a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python:\n",
      " -  A large heavy-bodied non-venomous snake occurring throughout the Old World tropics.\n",
      " -  Computing [mass noun] A high-level general-purpose programming language.\n"
     ]
    }
   ],
   "source": [
    "oxford           = dict()\n",
    "oxford['python'] = list()\n",
    "\n",
    "# oxford['python'] is a list, so we can use the append function on it\n",
    "oxford['python'].append('A large heavy-bodied non-venomous snake occurring throughout the Old World tropics.')\n",
    "oxford['python'].append('Computing [mass noun] A high-level general-purpose programming language.')\n",
    "\n",
    "#Let's see the definitions of python:\n",
    "print(\"python:\")\n",
    "for definition in oxford['python']:\n",
    "    print(\" - \", definition)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "alternatively, it could be that a dictionairy entry does not exist, resulting in a key error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KeyError(\"key that wasn't added\",)\n"
     ]
    }
   ],
   "source": [
    "# Wrapped in try ... except to show that an error is printed\n",
    "try:\n",
    "    oxford[\"key that wasn't added\"]\n",
    "except Exception as e:\n",
    "    print(repr(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Advanced features of dicts\n",
    "\n",
    "At times we want to know what is in a certain dict, loop over them etc.\n",
    "\n",
    "We'll discuss those here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# create a larger dictionairy:\n",
    "\n",
    "oxford = {\n",
    "    'html' : [\n",
    "        'Hypertext Markup Language, system for tagging text files to display World Wide Web pages.'\n",
    "    ],\n",
    "    'python' : [\n",
    "        'A large heavy-bodied non-venomous snake occurring throughout the Old World tropics.',\n",
    "        'A high-level general-purpose programming language.'\n",
    "    ],\n",
    "    'c' : [\n",
    "        'The third letter of the alphabet.',\n",
    "        'The Roman numeral for 100.'\n",
    "        'A computer programming language.'\n",
    "    ]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Check whether a key exists in a dict\n",
    "print(\"key that wasn't added\" in oxford)\n",
    "print(\"python\" in oxford)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- c\n",
      "- html\n",
      "- python\n"
     ]
    }
   ],
   "source": [
    "# Loop over keys\n",
    "for k in oxford.keys():\n",
    "    print(\"-\", k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- c\n",
      "- html\n",
      "- python\n"
     ]
    }
   ],
   "source": [
    "# Looping over just the dictionairy, loops over keys as well\n",
    "for k in oxford:\n",
    "    print(\"-\", k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- entry:\n",
      "    - The third letter of the alphabet.\n",
      "    - The Roman numeral for 100.A computer programming language.\n",
      "\n",
      "- entry:\n",
      "    - Hypertext Markup Language, system for tagging text files to display World Wide Web pages.\n",
      "\n",
      "- entry:\n",
      "    - A large heavy-bodied non-venomous snake occurring throughout the Old World tropics.\n",
      "    - A high-level general-purpose programming language.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Looping over values (note that you cannot easily get back to keys from here)\n",
    "for value in oxford.values():\n",
    "    print(\"- entry:\")\n",
    "    for description in value:\n",
    "        print(\"    -\", description)\n",
    "    print(\"\") # leave some space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- entry c\n",
      "    - The third letter of the alphabet.\n",
      "    - The Roman numeral for 100.A computer programming language.\n",
      "\n",
      "- entry html\n",
      "    - Hypertext Markup Language, system for tagging text files to display World Wide Web pages.\n",
      "\n",
      "- entry python\n",
      "    - A large heavy-bodied non-venomous snake occurring throughout the Old World tropics.\n",
      "    - A high-level general-purpose programming language.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Looping over key value pairs\n",
    "for key, value in oxford.items():\n",
    "    print(\"- entry\", key)\n",
    "    for description in value:\n",
    "        print(\"    -\", description)\n",
    "    print(\"\") # leave some space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `defaultdict` and `Counter`\n",
    "\n",
    "**Note these objects need to be imported from collections**\n",
    "\n",
    "At some point there was a need for 2 extra objects, which work for a large part the same as `dicts` with some modifications. \n",
    "\n",
    "The defaultdict is able to call what are called default constructors, and Counters... well they count stuff.\n",
    "\n",
    "We'll see some examples.\n",
    "\n",
    "In our previous example, with the oxford `dict` every value was supposed to be a list. The disadvantage is that before you can add a definition it needs the list to be there\n",
    "\n",
    "    # assumes we already made a list at oxford['Ruby']\n",
    "    oxford['Ruby'].append('precious stone') \n",
    "    \n",
    "    # creates a new list, possibly overwriting a previous one\n",
    "    oxford['Ruby'] = [ 'precious stone' ]\n",
    "    \n",
    "    # overwrites possible previous one and doesn't allow multiple definitions of 'ruby'\n",
    "    oxford['Ruby'] = 'precious stone'       \n",
    "\n",
    "Now in an attempt to make it easier for python developers, the `defaultdict` was created. \n",
    "This allows for default objects to be placed. For example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a new item']\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "# Every item that is requested, but not set will be an empty list\n",
    "oxford = defaultdict(list)\n",
    "\n",
    "# add as if it was already in the dictionairy\n",
    "oxford['item that didnt yet exist'].append('a new item')\n",
    "\n",
    "print(oxford['item that didnt yet exist'])\n",
    "print(oxford['another item that didnt yet exist'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essentially, it changes the behaviour when you want to read from something that isn't in the dictionairy yet.\n",
    "\n",
    "Usually that would result in an exception as seen before, but with the defaultdict, it creates an object with the given function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# This also works with other objects/functions etc.\n",
    "have_i_visited = defaultdict(bool) # bool returns False by default\n",
    "print(have_i_visited['grandma'])   # not even, you monster\n",
    "\n",
    "have_i_visited['grandma'] = True\n",
    "print(have_i_visited['grandma'])   # better"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Counter`\n",
    "\n",
    "It takes... well, a number of objects and counts them. \n",
    "\n",
    "The object than works as a dictionairy, with all the keys being the objects it got, and the values how many times it found them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Letter - Frequency\n",
      "a        5\n",
      "b        2\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "to_count = ['a', 'a', 'b', 'a', 'a', 'a', 'b']\n",
    "counter = Counter(to_count)\n",
    "\n",
    "print(\"Letter - Frequency\")\n",
    "for key, value in counter.items():\n",
    "    print(key,\"      \",value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally it offers the following interesting functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a a a a a b b "
     ]
    }
   ],
   "source": [
    "# elements()\n",
    "# return the input back, by returning the elements x the times they occurred\n",
    "for word in counter.elements():\n",
    "    print(word, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a  -  5\n",
      "b  -  2\n"
     ]
    }
   ],
   "source": [
    "# most_common(n)\n",
    "# returns the n most common elements, in order of most common to least.\n",
    "for word, freq in counter.most_common(2):\n",
    "    print(word, \" - \", freq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the  :  1505\n",
      "and  :   714\n",
      "to   :   703\n",
      "a    :   611\n",
      "of   :   490\n",
      "she  :   484\n",
      "said :   416\n",
      "it   :   346\n",
      "in   :   344\n",
      "was  :   328\n"
     ]
    }
   ],
   "source": [
    "# update()\n",
    "# allows to add another input, which it will add to the counted words\n",
    "\n",
    "# unimportant function that returns all words in the alice.txt file\n",
    "def words_alice():\n",
    "    with open(\"alice.txt\") as f:\n",
    "        for line in f:\n",
    "            for word in line.split():\n",
    "                yield word\n",
    "\n",
    "# updating our counter with all the words in alice in wonderland\n",
    "counter.update(words_alice())\n",
    "\n",
    "\n",
    "for word, freq in counter.most_common(10):\n",
    "    # don't pay attention to the formatting below, its just to align\n",
    "    print(\"%-4s : %5d\" % (word, freq))"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}