03 - Dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook is based on [Python Cheat Sheet](http://ehmatthes.github.io/pcc/cheatsheets/README.html) by [Eric Matthes](https://github.com/ehmatthes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "\n",
    "### What are dictionaries?\n",
    "Python's dictionaries allow you to connect pieces of related information. Each piece of information in a dictionary is stored as a key-value pair. When you provide a key, Python returns the value associated with that key. You can loop through all the key-value pairs, all the keys, or all the values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining a dictionary\n",
    "Use curly braces to define a dictionary. Use colons to connect keys and values, and use commas to separate individual key-value pairs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Making a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'color': 'green', 'points': 5}\n"
     ]
    }
   ],
   "source": [
    "alien_0 = {'color': 'green', 'points': 5}\n",
    "\n",
    "print(alien_0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing values\n",
    "To access the value associated with an individual key give the name of the dictionary and then place the key in a set of square brackets. If the key you're asking for is not in the dictionary, an error will occur.\n",
    "You can also use the get() method, which returns None instead of an error if the key doesn't exist. You can also specify a default value to use if the key is not in the dictionary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Getting the value associated with a key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "green\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "print(alien_0['color'])\n",
    "print(alien_0['points'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Getting the value with get()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "green\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "alien_0 = {'color': 'green'}\n",
    "\n",
    "alien_color = alien_0.get('color')\n",
    "alien_points = alien_0.get('points', 0)\n",
    "\n",
    "print(alien_color)\n",
    "print(alien_points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding new key-value pairs\n",
    "You can store as many key-value pairs as you want in a dictionary, until your computer runs out of memory. To add a new key-value pair to an existing dictionary give the name of the dictionary and the new key in square brackets, and set it equal to the new value.\n",
    "This also allows you to start with an empty dictionary and add key-value pairs as they become relevant."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Adding a key-value pair"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'color': 'green', 'points': 5, 'x': 0, 'y': 25, 'speed': 1.5}\n"
     ]
    }
   ],
   "source": [
    "alien_0 = {'color': 'green', 'points': 5}\n",
    "\n",
    "alien_0['x'] = 0\n",
    "alien_0['y'] = 25\n",
    "alien_0['speed'] = 1.5\n",
    "\n",
    "print(alien_0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Adding to an empty dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'color': 'green', 'points': 5}\n"
     ]
    }
   ],
   "source": [
    "alien_0 = {}\n",
    "alien_0['color'] = 'green'\n",
    "alien_0['points'] = 5\n",
    "\n",
    "print(alien_0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Modifying values\n",
    "You can modify the value associated with any key in a dictionary. To do so give the name of the dictionary and enclose the key in square brackets, then provide the new value for that key."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Modifying values in a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'color': 'green', 'points': 5}\n",
      "{'color': 'yellow', 'points': 10}\n"
     ]
    }
   ],
   "source": [
    "alien_0 = {'color': 'green', 'points': 5}\n",
    "print(alien_0)\n",
    "\n",
    "# Change the alien's color and point value.\n",
    "alien_0['color'] = 'yellow'\n",
    "alien_0['points'] = 10\n",
    "print(alien_0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing key-value pairs\n",
    "You can remove any key-value pair you want from a dictionary. To do so use the del keyword and the dictionary name, followed by the key in square brackets. This will\n",
    " delete the key and its associated value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Deleting a key-value pair"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'color': 'green', 'points': 5}\n",
      "{'color': 'green'}\n"
     ]
    }
   ],
   "source": [
    "alien_0 = {'color': 'green', 'points': 5}\n",
    "print(alien_0)\n",
    "\n",
    "del alien_0['points']\n",
    "print(alien_0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looping through a dictionary\n",
    "You can loop through a dictionary in three ways: you can loop through all the key-value pairs, all the keys, or all the values.\n",
    "\n",
    "A dictionary only tracks the connections between keys and values; it doesn't track the order of items in the dictionary. If you want to process the information in order, you can sort the keys in your loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Looping through all key-value pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jen: python\n",
      "sarah: c\n",
      "edward: ruby\n",
      "phil: python\n"
     ]
    }
   ],
   "source": [
    "# Store people's favorite languages.\n",
    "fav_languages = {\n",
    "    'jen': 'python',\n",
    "    'sarah': 'c',\n",
    "    'edward': 'ruby',\n",
    "    'phil': 'python',\n",
    "}\n",
    "\n",
    "# Show each person's favorite language.\n",
    "for name, language in fav_languages.items():\n",
    "    print(name + \": \" + language)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Looping through all the keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jen\n",
      "sarah\n",
      "edward\n",
      "phil\n"
     ]
    }
   ],
   "source": [
    "# Show everyone who's taken the survey.\n",
    "for name in fav_languages.keys():\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Looping through all the values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python\n",
      "c\n",
      "ruby\n",
      "python\n"
     ]
    }
   ],
   "source": [
    "# Show all the languages that have been chosen.\n",
    "for language in fav_languages.values():\n",
    "    print(language)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Looping through all the keys in order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "edward: ruby\n",
      "jen: python\n",
      "phil: python\n",
      "sarah: c\n"
     ]
    }
   ],
   "source": [
    "# Show each person's favorite language, in order by the person's name.\n",
    "for name in sorted(fav_languages.keys()):\n",
    "    print(name + \": \" + fav_languages[name])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Dictionary length\n",
    "You can find the number of key-value pairs in a dictionary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Finding a dictionary's length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "num_responses = len(fav_languages)\n",
    "\n",
    "print(num_responses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nesting - A list of dictionaries\n",
    "It's sometimes useful to store a set of dictionaries in a list; this is called nesting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Storing dictionaries in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "last: fermi\n",
      "first: enrico\n",
      "username: efermi\n",
      "last: curie\n",
      "first: marie\n",
      "username: mcurie\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Start with an empty list.\n",
    "users = []\n",
    "\n",
    "# Make a new user, and add them to the list.\n",
    "new_user = {\n",
    "    'last': 'fermi',\n",
    "    'first': 'enrico',\n",
    "    'username': 'efermi',\n",
    "    }\n",
    "users.append(new_user)\n",
    "\n",
    "# Make another new user, and add them as well.\n",
    "new_user = {\n",
    "    'last': 'curie',\n",
    "    'first': 'marie',\n",
    "    'username': 'mcurie',\n",
    "    }\n",
    "users.append(new_user)\n",
    "\n",
    "# Show all information about each user.\n",
    "for user_dict in users:\n",
    "    for k, v in user_dict.items():\n",
    "        print(k + \": \" + v)\n",
    "print(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### You can also define a list of dictionaries directly, without using append():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "last: fermi\n",
      "first: enrico\n",
      "username: efermi\n",
      "last: curie\n",
      "first: marie\n",
      "username: mcurie\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Define a list of users, where each user\n",
    "#   is represented by a dictionary.\n",
    "\n",
    "users = [\n",
    "    {\n",
    "        'last': 'fermi',\n",
    "        'first': 'enrico',\n",
    "        'username': 'efermi',\n",
    "    },\n",
    "    {\n",
    "        'last': 'curie',\n",
    "        'first': 'marie',\n",
    "        'username': 'mcurie',\n",
    "    }\n",
    "]\n",
    "\n",
    "# Show all information about each user.\n",
    "for user_dict in users:\n",
    "    for k, v in user_dict.items():\n",
    "        print(k + \": \" + v)\n",
    "print(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nesting - Lists in a dictionary\n",
    "Storing a list inside a dictionary alows you to associate more than one value with each key."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Storing lists in a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jen: \n",
      "- python\n",
      "- ruby\n",
      "sarah: \n",
      "- c\n",
      "edward: \n",
      "- ruby\n",
      "- go\n",
      "phil: \n",
      "- python\n",
      "- haskell\n"
     ]
    }
   ],
   "source": [
    "# Store multiple languages for each person.\n",
    "\n",
    "fav_languages = {\n",
    "    'jen': ['python', 'ruby'],\n",
    "    'sarah': ['c'],\n",
    "    'edward': ['ruby', 'go'],\n",
    "    'phil': ['python', 'haskell'],\n",
    "}\n",
    "\n",
    "# Show all responses for each person.\n",
    "for name, langs in fav_languages.items():\n",
    "    print(name + \": \")\n",
    "    for lang in langs:\n",
    "        print(\"- \" + lang)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nesting - A dictionary of dictionaries\n",
    "You can store a dictionary inside another dictionary. In this case each value associated with a key is itself a dictionary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Storing dictionaries in a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Username: aeinstein\n",
      "\tFull name: Albert Einstein\n",
      "\tLocation: Princeton\n",
      "\n",
      "Username: mcurie\n",
      "\tFull name: Marie Curie\n",
      "\tLocation: Paris\n"
     ]
    }
   ],
   "source": [
    "users = {\n",
    "     'aeinstein': {\n",
    "         'first': 'albert',\n",
    "         'last': 'einstein',\n",
    "         'location': 'princeton',\n",
    "         },\n",
    "     'mcurie': {\n",
    "         'first': 'marie',\n",
    "         'last': 'curie',\n",
    "         'location': 'paris',\n",
    "         },\n",
    "     }\n",
    "\n",
    "for username, user_dict in users.items():\n",
    "    print(\"\\nUsername: \" + username)\n",
    "    full_name = user_dict['first'] + \" \"\n",
    "    full_name += user_dict['last']\n",
    "    location = user_dict['location']\n",
    "    \n",
    "    print(\"\\tFull name: \" + full_name.title())\n",
    "    print(\"\\tLocation: \" + location.title())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Levels of nesting\n",
    "Nesting is extremely useful in certain situations. However, be aware of making your code overly complex. If you're nesting items much deeper than what you see here there are probably simpler ways of managing your data, such as using classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using an OrderedDict\n",
    "Standard Python dictionaries don't keep track of the order in which keys and values are added; they only preserve the association between each key and its value. If you want to preserve the order in which keys and values are added, use an OrderedDict."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Preserving the order of keys and values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jen:\n",
      "- python\n",
      "- ruby\n",
      "sarah:\n",
      "- c\n",
      "edward:\n",
      "- ruby\n",
      "- go\n",
      "phil:\n",
      "- python\n",
      "- haskell\n"
     ]
    }
   ],
   "source": [
    "from collections import OrderedDict\n",
    "\n",
    "# Store each person's languages, keeping # track of who respoded first.\n",
    "fav_languages = OrderedDict()\n",
    "\n",
    "fav_languages['jen'] = ['python', 'ruby']\n",
    "fav_languages['sarah'] = ['c']\n",
    "fav_languages['edward'] = ['ruby', 'go']\n",
    "fav_languages['phil'] = ['python', 'haskell']\n",
    "\n",
    "# Display the results, in the same order they were entered.\n",
    "for name, langs in fav_languages.items():\n",
    "    print(name + \":\")\n",
    "    for lang in langs:\n",
    "        print(\"- \" + lang)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generating a million dictionaries\n",
    "You can use a loop to generate a large number of dictionaries efficiently, if all the dictionaries start out with similar data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### A million aliens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of aliens created:\n",
      "1000000\n"
     ]
    }
   ],
   "source": [
    "aliens = []\n",
    "\n",
    "# Make a million green aliens, worth 5 points each. Have them all start in one row.\n",
    "for alien_num in range(1000000):\n",
    "    new_alien = {}\n",
    "    new_alien['color'] = 'green'\n",
    "    new_alien['points'] = 5\n",
    "    new_alien['x'] = 20 * alien_num\n",
    "    new_alien['y'] = 0\n",
    "    aliens.append(new_alien)\n",
    "    \n",
    "# Prove the list contains a million aliens.\n",
    "num_aliens = len(aliens)\n",
    "\n",
    "print(\"Number of aliens created:\")\n",
    "print(num_aliens)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Notebook created by [Sujeevan Nagarajah](https://github.com/sujee81)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}