03 - Dictionaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# New Data Type: Dictionaries\n",
    "\n",
    "### What we already know\n",
    "- basic data types (ints, floats, strings)\n",
    "- Some functions and methods to manipulate these data types (i.e. type(), len(), str.upper())\n",
    "- where to put our data\n",
    "    - one piece of data within a variable\n",
    "    - multiple pieces of data within a list\n",
    "- and how to manipulate and build these variables and lists\n",
    "\n",
    "### Learning Objectives\n",
    "\n",
    "- Understand the underlying structure of a dictionary\n",
    "- Know how to access dictionary elements\n",
    "- Adding and deleting dictionary elements\n",
    "    - Describe the difference between del & pop()\n",
    "- Be able to describe when a situation is best suited for a dictionary vs. a list\n",
    "- Checking the existence of a key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "\n",
    "Dictionaries are another kind of data type used by Python.\n",
    "\n",
    "Remember our List:\n",
    "\n",
    "|Index|Item|\n",
    "|-----|-----|\n",
    "|0|1|\n",
    "|1|2.5|\n",
    "|2|3|\n",
    "|3|'This'|\n",
    "|4|[]|\n",
    "\n",
    "in which each item in a list is associated with an index.... In a dictionary, we essentially make our own indices!\n",
    "\n",
    "\n",
    "\n",
    "A dictionary is an associative array. Each item in our list is associated with a key \n",
    "\n",
    "|Key|Value|\n",
    "|-----|-----|\n",
    "|iphone|2005|\n",
    "|iPhone Pod|3010|\n",
    "|iphone3G|2004|\n",
    "|iphone3GS|2009|\n",
    "|iphone4|2010|\n",
    "|iphone4S|2010|\n",
    "|iphone 4SS|2015|\n",
    "\n",
    "rather than using an index, like a list, a dictionary uses \"keys\", typically strings or numbers, that you define. Each \"key\" of this dictionary is mapped to a value. \n",
    "\n",
    "Like a list, a dictionary can contain any kind of data type for it's values. \n",
    "\n",
    "Dictionaries consist of key-value-pairs, and as they can only be accessed using the 'key' names, they are unordered. \n",
    "\n",
    "You can make a dictionary by using `dict()`, or `{}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# An empty dictionary\n",
    "dict()\n",
    "{}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Live example\n",
    "\n",
    "jons_shoes = {'for bike riding':['Left bike shoe','right bike shoe']\n",
    "              ,'for running':'runners',\n",
    "              'for pretending to be from colorado':'sandals',\n",
    "              'for pretending to be Rafa':'tennis shoe'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While the above makes an empty dictionary, sometimes you want to create one that already has values inside of it - like defining a list as [1,2,3,4].\n",
    "\n",
    "We do this by using the {} brackets, and defining the names of a \"key\", and it's \"value\" at the same time, like so:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# An example of a dictionary with keys and values\n",
    "\n",
    "released = {    \n",
    "    \"iphone\" : 2005,\n",
    "    \"iPhone Pod\": 3010,\n",
    "    \"iphone3G\" : str(2004),    \n",
    "    \"iphone3GS\": str(2009),\n",
    "    \"iPhone Smart\": 2001,\n",
    "    \"iphone4\" : 2010,\n",
    "    \"iphone4S\": '2010',\n",
    "    'iPhone 4SS' : 2015\n",
    "}\n",
    "\n",
    "print(released)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The great thing about dictionaries is that, like lists, the data stored inside of them can be any kind of data type.\n",
    "\n",
    "You can even store a dictionary inside a dictionary!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want actually access the value for a particular key in your dictionary, you can do so similar to how you do for a list - except instead of using a number to represent what 'index' your data is stored in, you use the key name instead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Accessing your dictionary\n",
    "jons_shoes['for running']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# our other dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition, just like a list, dictionaries are mutable! **like what if I got new shoes?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dictionaries are mutable (they can be changed)\n",
    "jons_shoes['for running']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#what if I got some new runners?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding and deleting from your dictionary\n",
    "\n",
    "Adding to your dicitonary is simple - you just \"call\" your dictionary with a new key name, and assign it a value.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Adding new elements\n",
    "released['temporary'] = \"Temporary record\"\n",
    "\n",
    "released"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly to how we delete items from lists, we can delete records from our dictionary using `.pop()` and `del`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Deleting elements\n",
    "# same as lists, \"pop\" gives you the deleted element\n",
    "released.pop(\"temporary\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# While del removes the key and value from the dictionary. \n",
    "del released[\"iphone4S\"]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Challenge 8\n",
    "\n",
    "Find the correct release dates for the iPhone models (google!), and change the dates currently inside the dictionary. In addition, add the newest iPhone model and release date, and delete any records that don't actually exist on the market (e.g. 'iPhone Smart')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What if we want to just see the keys? or just see the values of our  dictionary?\n",
    "\n",
    "##### Our Special dictionary object has special methods to do that\n",
    "\n",
    "```\n",
    "dict.keys()\n",
    "dict.values()\n",
    "\n",
    "``` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "temp_dict[\"temp\"] = \"temporary record\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "temp_dict.values()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What this does is give you a list that contains all of the values contained within your dictionary. As this is a list, you can thus use in/not in just as you would with a list!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While in/not in automatically checks inside your dictionary keys when testing for equality, sometimes you want a list of your keys as well. Just as with dict.values(), you can use dict.keys() to do the exact same thing!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "temp_dict.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### Discussion Question\n",
    "Which would you store the following data set as a List or a Dictionary?\n",
    "\n",
    "    1.) output from a single datalogger\n",
    "    2.) Coefficients and p values from a statistical test\n",
    "    3.) metadata for a GIS file\n",
    "    1.) temperature values from a network of data loggers\n",
    "    \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "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"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "navigate_num": "#000000",
    "navigate_text": "#333333",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700",
    "sidebar_border": "#EEEEEE",
    "wrapper_background": "#FFFFFF"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "173px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": false,
   "sideBar": false,
   "threshold": 4,
   "toc_cell": false,
   "toc_position": {
    "height": "201px",
    "left": "1085.78px",
    "right": "20px",
    "top": "3px",
    "width": "223px"
   },
   "toc_section_display": "none",
   "toc_window_display": true,
   "widenNotebook": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}