python-primer/episodes/Dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries\n",
    "**Teaching**: 15min<br>\n",
    "**Exercises**: 5min"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use a set to store unique values\n",
    "* Create with `{...}`\n",
    "* But must use `set()` to create an empty set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "is 3 prime? True\n",
      "is 9 prime? False\n"
     ]
    }
   ],
   "source": [
    "primes = {2, 3, 5, 7}\n",
    "print('is 3 prime?', 3 in primes)\n",
    "print('is 9 prime?', 9 in primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Intersection, union, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "intersection {3, 5, 7}\n",
      "union {2, 3, 5, 7, 9}\n"
     ]
    }
   ],
   "source": [
    "odds = {3, 5, 7, 9}\n",
    "print('intersection', odds & primes)\n",
    "print('union', odds | primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets are mutable\n",
    "* But only store *unique* values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "primes becomes {2, 3, 5, 11}\n",
      "after removal {2, 3, 5, 11}\n",
      "after adding 11 again {2, 3, 5, 11}\n"
     ]
    }
   ],
   "source": [
    "primes.add(11)\n",
    "print('primes becomes', primes)\n",
    "primes.discard(7)\n",
    "print('after removal', primes)\n",
    "primes.add(11)\n",
    "print('after adding 11 again', primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets are unordered\n",
    "* Values are stored by *hashing*, which is intentionally as random as possible"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Turing\n",
      "Darwin\n",
      "Newton\n"
     ]
    }
   ],
   "source": [
    "names = {'Darwin', 'Newton', 'Turing'}\n",
    "for n in names:\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use a dictionary to store key/value pairs\n",
    "Equivalently, store extra information with elements of a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1602\n",
      "{'Newton': 1602, 'Darwin': 1809, 'Turing': 1912}\n"
     ]
    }
   ],
   "source": [
    "birthdays = {'Newton': 1602, 'Darwin': 1809}\n",
    "print(birthdays['Newton'])\n",
    "birthdays['Turing'] = 1612 # oops\n",
    "birthdays['Turing'] = 1912 # that's better\n",
    "print(birthdays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Just an accident that keys are in order of when entered.\n",
    "* Like sets, dictionaries store keys by hashing, which is as random as possible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set values and dictionary keys must be immutable\n",
    "* Changing them after insertion would leave data in the wrong place\n",
    "* Use a `tuple` for multi-valued keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "people = {('Isaac', 'Newton'): 1602, ('Charles', 'Darwin'): 1809}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can *destructure* a tuple in the heading of a for loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Isaac was born in 1602\n",
      "Charles was born in 1809\n"
     ]
    }
   ],
   "source": [
    "for (first, last) in people:\n",
    "    print(first,'was born in', people[(first, last)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: create a histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 5, 0: 4, 2: 3, 3: 1}\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 0, 1, 2, 0, 0, 1, 2, 1, 3, 1, 0, 2]\n",
    "count = {}\n",
    "for n in numbers:\n",
    "    if n not in count:\n",
    "        count[n] = 1\n",
    "    else:\n",
    "        count[n] = count[n] + 1\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reminder: there are lots of useful Python libraries, especially the \"standard library\" that comes with Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({1: 5, 0: 4, 2: 3, 3: 1})\n",
      "{1: 5, 0: 4, 2: 3, 3: 1}\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "print(Counter(numbers))\n",
    "print(dict(Counter(numbers)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Keys are often strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "atomic number of lithium: 3\n"
     ]
    }
   ],
   "source": [
    "atomic_numbers = {'H' : 1, 'He' : 2, 'Li' : 3, 'Be' : 4, 'B' : 5}\n",
    "print('atomic number of lithium:', atomic_numbers['Li'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "atomic number of H is 1\n",
      "atomic number of C is 6\n",
      "atomic number of O is 8\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "with open('../data/atomic_numbers.json') as f:\n",
    "    atomic_numbers = json.load(f)\n",
    "    \n",
    "for element in ('H', 'C', 'O'):\n",
    "    print('atomic number of', element, 'is', atomic_numbers[element])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can iterate over the keys of a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "He\n",
      "Li\n",
      "Be\n",
      "B\n"
     ]
    }
   ],
   "source": [
    "# Use a counter so we don't print out so much.\n",
    "n = 0\n",
    "for element in atomic_numbers:\n",
    "    if n < 5:\n",
    "        print(element)\n",
    "    n = n + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also iterate over (key, value) tuples of a dictionary using the `items` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H 1\n",
      "He 2\n",
      "Li 3\n",
      "Be 4\n",
      "B 5\n"
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "for (element, atomic_number) in atomic_numbers.items():\n",
    "    if n < 5:\n",
    "        print(element, atomic_number)\n",
    "    n = n + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: How heavy is this molecule?\n",
    "You are given two things:\n",
    "\n",
    "1. a JSON file (at `'../data/atomic_weights.json'`) which loads a dictionary mapping atomic symbols to atomic weights, and\n",
    "2. a list of (atomic_symbol, count) pairs for a molecule.\n",
    "\n",
    "```python\n",
    "# Example molecules:\n",
    "methane = [('C', 1), ('H', 4)]\n",
    "aminothiazole = [('C', 3), ('H', 4), ('N', 2), ('S', 1)]\n",
    "```\n",
    "\n",
    "Print that molecule's molecular weight.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Do stuff to create `atomic_weights` dictionary\n",
    "\n",
    "# ...\n",
    "\n",
    "# atomic weight is 16.0423\n",
    "methane = [('C', 1), ('H', 4)]\n",
    "# atomic weight is 100.1421\n",
    "aminothiazole = [('C', 3), ('H', 4), ('N', 2), ('S', 1)]\n",
    "\n",
    "# 2. Pick a molecule to test\n",
    "molecule = methane\n",
    "\n",
    "# 3. Do stuff to calculate `mol_weight`\n",
    "\n",
    "# ...\n",
    "\n",
    "print(mol_weight)"
   ]
  }
 ],
 "metadata": {
  "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}