Lesson 6 - Dict.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[<img src=\"http://cloud.blobcity.net/assets/images/badge.png\" height=\"20\" style=\"margin-bottom:-15px\" />](https://cloud.blobcity.com/#/ps/shared-cloudbook/66c4fcaa-b0e4-4e0a-b275-49cdf007667a)\n",
    "\n",
    "# Dict\n",
    "\n",
    "A dict stands for dictionary and is also commonly known as a hash map. HashMap as you might know it from other languages, is a very important data structure in many languages. In Python and specially for Data Science with Python, a dict is a very important data structure. You are most likely to use this in almost every data science project you undertake. \n",
    "\n",
    "Just like any other Map or HashMap, a dict is a collection of key -> value pairs. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = {'Tom': 42, 'Mike': 38}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above example creates a dictionary.\n",
    "\n",
    "In \n",
    "```\n",
    "'Tom': 42\n",
    "```\n",
    "\n",
    "`'Tom'` is the key and the number `42` is the value corresponding to the key. Here `42` and `38` can represent the age of the person for example. So we have created a key value pair, with the key being the name of the person and value being the age of the person.\n",
    "\n",
    "In general, dicts are mutable. So we can start from an empty dict and add the same values to it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Tom': 42, 'Mike': 38}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {}\n",
    "dict1['Tom'] = 42\n",
    "dict1['Mike'] = 38\n",
    "\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like we put key-value pairs inside a dict, we can fetch a value corresponding to a key. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "tomAge = dict1['Tom']\n",
    "print(tomAge)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Passing the key to the dict, fetchs the value corresponding to the element. But what happens if we pass a key that does not exist within the dict?\n",
    "\n",
    "``` Python\n",
    "harryAge = dict1['Harry']\n",
    "print(harryAge)\n",
    "```\n",
    "\n",
    "If we tried the above code, we could get a `KeyError`. This occurs when the specified key cannot be found in the dict. This means, as developers we have to be careful in invoking the dict with a key that is for sure present within the dict.\n",
    "\n",
    "Sometimes you might not be sure if the `dict` has the key you plan on looking for. This will typically happen when your `dict` is dynamically created in the program. In such cases we can use the `in` keyword to check if the dict has the specified key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "containsHarry = 'Harry' in dict1\n",
    "print(containsHarry)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also write this as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tom age: 42\n"
     ]
    }
   ],
   "source": [
    "if 'Harry' in dict1:\n",
    "    print('Harry age:', dict1['Harry'])\n",
    "\n",
    "if 'Tom' in dict1:\n",
    "    print('Tom age:', dict1['Tom'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using the get method\n",
    "\n",
    "The get method on the dict can be used as well to fetch the value corresponding to a key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'Tom': 42, 'Mike': 38}\n",
    "print(dict1.get('Tom'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `get` method accepts an additional optional parameter to specify a default value if the corresponding key is not found. This prevents the code from failing if the key is inexistent within the dict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'Tom': 42, 'Mike': 38}\n",
    "harryAge = dict1.get('Harry', -1)\n",
    "\n",
    "print(harryAge)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second parameter accepted by the `get` function is returned if the key as specified by the first parameter is not found within the dict. This allows for graceful handling of potential error conditions, such as setting the age of a person to `-1` if an actual age cannot be found. \n",
    "\n",
    "## Remove an element\n",
    "\n",
    "To remove a key-value pair that is added into the dict, we can use the key to remove the corresponding key-value pair. We use the `del` keyword in Python to achieve this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before: {'Tom': 42, 'Mike': 38}\n",
      "After:  {'Mike': 38}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'Tom': 42, 'Mike': 38}\n",
    "print('Before:', dict1)\n",
    "\n",
    "del dict1['Tom']\n",
    "print('After: ', dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The operation modifies the original dict and `dict1` in this case no longer has the key `Tom`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pop a key-value pair\n",
    "\n",
    "We also fetch a key and simultaneously remove it from the dict. This can be achieved by using the `pop` function provided on the dict. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before: {'Tom': 42, 'Mike': 38}\n",
      "After:  {'Mike': 38}\n",
      "Tom age: 42\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'Tom': 42, 'Mike': 38}\n",
    "print('Before:', dict1)\n",
    "\n",
    "tomAge = dict1.pop('Tom')\n",
    "print('After: ', dict1)\n",
    "\n",
    "print('Tom age:', tomAge)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the original dict was modified by the `pop` operation, but we were able to pop out the age of Tom before Tom was removed from the dict. This popped out value was returned by the `pop` function, which we assigned to the variable `tomAge`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with keys\n",
    "\n",
    "We can fetch all the keys of a dict by using the `keys` method provided on the dict. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Tom', 'Mike']\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'Tom': 42, 'Mike': 38}\n",
    "keys= list(dict1.keys())\n",
    "\n",
    "print(keys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We converted the keys of the dict into a list, and now have a list of all keys present within the dict. We can use this to iterate over the keys and fetch all the elements of the dict; at the same time being sure that all keys are indeed present within the dict; which ensures that we get no error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tom -> 42\n",
      "Mike -> 38\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'Tom': 42, 'Mike': 38}\n",
    "for key in list(dict1.keys()):\n",
    "    print(key, '->', dict1[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with values\n",
    "\n",
    "In some scenarious you might want to extra all the values present in the dict. This function is called the `values` function and is similar to the `keys` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[42, 38]\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'Tom': 42, 'Mike': 38}\n",
    "values = list(dict1.values())\n",
    "\n",
    "print(values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Merging dicts and bulk updates\n",
    "\n",
    "We can merge a dict into another dict. This is useful to append a dick with values from anohter dict, or to bulk update the contents of an existing dict. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Tom': 42, 'Mike': 38, 'Harry': 40, 'Alice': 36}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'Tom': 42, 'Mike': 38}\n",
    "dict2 = {'Harry': 40, 'Alice': 36}\n",
    "\n",
    "dict1.update(dict2)\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the operation modifies the original dict, in this case `dict1`. The `dict2` remains unchanged.\n",
    "\n",
    "The function is called `update` and in many scenarious it is used to not append dicts, but to actually perform a bulk update of values on an existing dict. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Tom': 43, 'Mike': 39}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'Tom': 42, 'Mike': 38}\n",
    "nextYear = {'Tom': 43, 'Mike': 39}\n",
    "\n",
    "dict1.update(nextYear)\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like in the above example, if in the following year we want to increment the age of each person by `1`, we can basically do this as an update operation. We can see that the previous age values of `42` and `38` and respectively revised to `43` and `39`\n",
    "\n",
    "## Understanding key and value types\n",
    "\n",
    "A dict can essentially store any value. Anything that is an object in Python can be stored as a value in the dict. This includes the fact that even functions can be stored as values. \n",
    "\n",
    "Keys of a dict can also be of any object type; but only as long as the object is immutable. A mutable object cannot be stored as a dict. Let's look at some examples. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{('Tom', 'Mike'): (42, 38), ('Harry', 'Alice'): [40, 36], 'Tom': 43, 'Mike': 39}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {('Tom', 'Mike'): (42,38), ('Harry', 'Alice'): [40,36]}\n",
    "dict1.update(nextYear)\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example `('Tom', 'Mike')` is the key of the dict and `(42,38)` is the value. In the second record, we have used an array of `[40,36]` instead of a tuple. \n",
    "\n",
    "We can use `(42,38)` as a key, but we cannot use `[42,38]` as a key. This is because the first is a tuple and a tuple is immutable, but the second is a list which is mutable. A mutable cannot be used as a key, as the object does not have a definite value; which when changed would require the dict to be completely re-keyed, which would be undesirable. "
   ]
  }
 ],
 "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.8.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}