Chapter7_Dictionary_Tricks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "clean-convention",
   "metadata": {},
   "source": [
    "# Chapter 7 - Dictionary Tricks"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "stunning-sunset",
   "metadata": {},
   "source": [
    "___\n",
    "## 7.1 Dictionary Default Values\n",
    "\n",
    "Python’s dictionaries have a get() method for looking up a key while\n",
    "providing a fallback value\n",
    "\n",
    "### Summary\n",
    "* Avoid explicit key in ```dict``` checks when testing for membership.\n",
    "* EAFP-style exception handling or using the built-in ```get()```\n",
    "method is preferable.\n",
    "* In some cases, the ```collections.defaultdict``` class from the\n",
    "standard library can also be helpful."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "banned-enzyme",
   "metadata": {},
   "source": [
    "#### the problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "traditional-suite",
   "metadata": {},
   "outputs": [],
   "source": [
    "name_for_userid = {\n",
    "    382: 'Alice',\n",
    "    950: 'Bob',\n",
    "    590: 'Dilbert',\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "chief-illustration",
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting(userid):\n",
    "    return 'Hi %s' % name_for_userid[userid]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bridal-witness",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hi Alice'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting(382)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "local-paradise",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "33333",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-4-9d7d89d60058>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mgreeting\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m33333\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-2-dd6085ff16fb>\u001b[0m in \u001b[0;36mgreeting\u001b[1;34m(userid)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mgreeting\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0muserid\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[1;34m'Hi %s'\u001b[0m \u001b[1;33m%\u001b[0m \u001b[0mname_for_userid\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0muserid\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 33333"
     ]
    }
   ],
   "source": [
    "greeting(33333)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "statewide-minimum",
   "metadata": {},
   "source": [
    "#### Returning a default value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "experienced-morrison",
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is not very pythonic\n",
    "def greeting(userid):\n",
    "    if userid in name_for_userid:\n",
    "        return 'Hi %s!' % name_for_userid[userid]\n",
    "    else:\n",
    "        return 'Hi there!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "vietnamese-soviet",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hi Alice!'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting(382)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "legitimate-module",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hi there!'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "tamil-identifier",
   "metadata": {},
   "outputs": [],
   "source": [
    "# a more pythonic implementation using the EAFP - easier to ask for forgiveness than permission\n",
    "def greeting(userid):\n",
    "    try:\n",
    "        return 'Hi %s!' % name_for_userid[userid]\n",
    "    except KeyError:\n",
    "        return 'Hi there'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "legal-sight",
   "metadata": {},
   "source": [
    "### preferred implmentation with the get method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "partial-radical",
   "metadata": {},
   "outputs": [],
   "source": [
    "# the most pythonic way to do this is with the get function\n",
    "def greeting(userid):\n",
    "    return 'Hi %s!' % name_for_userid.get(\n",
    "        userid, 'there')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "composite-conducting",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hi there!'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting(33333)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "undefined-field",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hi Alice!'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting(382)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "blessed-nigeria",
   "metadata": {},
   "source": [
    "___\n",
    "## 7.2 Sorting dictionaries for fun and profit\n",
    "\n",
    "Python dicionaries don't have an inherent order. \n",
    "\n",
    "### Summary\n",
    "* When creating sorted “views” of dictionaries and other collections, you can influence the sort order with a **key func**.\n",
    "* *Key funcs* are an important concept in Python. The most frequently used ones were even added to the operator module in the standard library.\n",
    "* Functions are first-class citizens in Python. This is a powerful\n",
    "feature you’ll find used everywhere in the language.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "hairy-spoke",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 4), ('b', 3), ('c', 2), ('d', 1)]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# default sorted\n",
    "xs = {'a' : 4, 'c' : 2, 'b' : 3, 'd' : 1}\n",
    "sorted(xs.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "certified-illinois",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 4), ('b', 3), ('c', 2), ('d', 1)]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(xs.items(), key=lambda x:x[1], reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "governmental-privilege",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 4), ('b', 3), ('c', 2), ('d', 1)]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import operator\n",
    "sorted(xs.items(), key=operator.itemgetter(1), reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "blocked-cylinder",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', -4), ('b', 3), ('c', 2), ('d', 1)]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a more abstract key func\n",
    "xs = {'a' : -4, 'c' : 2, 'b' : 3, 'd' : 1}\n",
    "sorted(xs.items(), key=lambda x: abs(x[1])**(-0.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adverse-drill",
   "metadata": {},
   "source": [
    "___\n",
    "## 7.3 Emulating switch/case statements with dicts\n",
    "\n",
    "### Summary \n",
    "* Python doesn’t have a switch/case statement. But in some cases\n",
    "you can avoid long if-chains with a dictionary-based dispatch\n",
    "table.\n",
    "* Once again Python’s first-class functions prove to be a powerful\n",
    "tool. But with great power comes great responsibility.\n",
    "\n",
    "Python doesn’t have switch/case statements so it’s sometimes necessary to write long ```if…elif…else``` chains as a workaround. In this chapter you’ll discover a trick you can use to emulate switch/case statements in Python with dictionaries and first-class functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "published-simpson",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we make use of python's first-class functions\n",
    "def myfunc(a,b):\n",
    "    return a + b\n",
    "funcs = [myfunc]\n",
    "funcs[0](2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "recognized-hundred",
   "metadata": {},
   "source": [
    "### first attempt at solution using conditional logic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "confused-peeing",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dispatch_if(operator, x, y):\n",
    "    if operator == 'add':\n",
    "        return x + y\n",
    "    elif operator == 'sub':\n",
    "        return x - y\n",
    "    elif operator == 'mul':\n",
    "        return x * y\n",
    "    elif operator == 'div':\n",
    "        return x/y\n",
    "    # implicit return statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "current-button",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dispatch_if('mul', 2, 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "nutritional-industry",
   "metadata": {},
   "source": [
    "### Preferred solution\n",
    "\n",
    "#### Notes on this implementation\n",
    "First of all, every time we call ```dispatch_dict()```, it creates a temporary dictionary and a bunch of lambdas for the opcode lookup. This\n",
    "isn’t ideal from a performance perspective. For code that needs to be\n",
    "fast, **it makes more sense to create the dictionary once as a constant**\n",
    "and then to reference it when the function is called. We don’t want to\n",
    "recreate the dictionary every time we need to do a lookup."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "optional-leave",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can pass functions around as objects\n",
    "# we also make use of the get function and provide a default function\n",
    "def dispatch_dict(operator, x, y):\n",
    "     return {\n",
    "         'add': lambda: x + y,\n",
    "         'sub': lambda: x - y,\n",
    "         'mul': lambda: x * y,\n",
    "         'div': lambda: x / y,\n",
    "     }.get(operator, lambda: None)()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "municipal-converter",
   "metadata": {},
   "outputs": [],
   "source": [
    "dispatch_dict('unknown', 2, 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adaptive-variable",
   "metadata": {},
   "source": [
    "___\n",
    "## 7.4 The craziest dict expression in the west\n",
    "\n",
    "“The **Boolean type is a subtype of the integer type**, and\n",
    "**Boolean values behave like the values 0 and 1**, respectively, in almost all contexts, the exception being that\n",
    "when converted to a string, the strings ‘False’ or ‘True’\n",
    "are returned, respectively\"\n",
    "\n",
    "(Python docs, https://docs.python.org/3/reference/datamodel.html#the-standard-type-hierarchy)\n",
    "\n",
    "### Summary \n",
    "* Dictionaries treat keys as identical if their ```__eq__``` comparison\n",
    "result says they’re equal and their hash values are the same.\n",
    "* **Unexpected dictionary key collisions** can and will lead to surprising results.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "purple-confirmation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{True: 'maybe'}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zen_koan = {True : 'yes', 1 : 'no', 1.0 : 'maybe'}\n",
    "zen_koan"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "synthetic-african",
   "metadata": {},
   "source": [
    "**The original key object is not updated when a new value is associated with it**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "stock-evening",
   "metadata": {},
   "outputs": [],
   "source": [
    "# equivalent to this sequence of code\n",
    "xs = dict()\n",
    "xs[True] = 'yes'\n",
    "xs[1] = 'no'\n",
    "xs[1.0] = 'maybe'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "spoken-syndrome",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# they are all equivalent\n",
    "True == 1 == 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "equivalent-circulation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'yes'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['no', 'yes'][True]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "colored-healthcare",
   "metadata": {},
   "source": [
    "This behaviour is related to hash collisions in the implementation of the ```dict``` class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "spiritual-flower",
   "metadata": {},
   "source": [
    "### Investigating the hashtable structure \n",
    "\n",
    "This class is special in two ways:\n",
    "\n",
    "* First, because its ```__eq__``` dunder method always returns ```True```, all instances of this class will pretend they’re equal to any other object\n",
    "* And second, each ```AlwaysEquals``` instance will also return a unique\n",
    "hash value generated by the built-in ```id()``` function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "qualified-williams",
   "metadata": {},
   "source": [
    "#### Equality comparison test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "solar-mortality",
   "metadata": {},
   "outputs": [],
   "source": [
    "class AlwaysEquals:\n",
    "    def __eq__(self, other):\n",
    "        return True\n",
    "    \n",
    "    def __hash__(self):\n",
    "        return id(self)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "living-relaxation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AlwaysEquals() == AlwaysEquals()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "configured-spanish",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AlwaysEquals() == 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "optional-frequency",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AlwaysEquals() == 'whaaaat?'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "intelligent-brook",
   "metadata": {},
   "source": [
    "In CPython, ```id()``` returns the **address of the object in memory**, which\n",
    "is guaranteed to be unique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "patent-powell",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1686759430320, 1686759429936, 1686759428448]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "objects = [AlwaysEquals(),\n",
    "           AlwaysEquals(),\n",
    "           AlwaysEquals(),]\n",
    "[hash(obj) for obj in objects]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "timely-country",
   "metadata": {},
   "source": [
    "This will allow us to **test if dictionary keys are overwritten** based on their **equality comparison result alone**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "marked-lexington",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{<__main__.AlwaysEquals at 0x188bab254c0>: 'yes',\n",
       " <__main__.AlwaysEquals at 0x188bab256a0>: 'no'}"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the keys in the next example are not overwritten even though they compare as equal\n",
    "{AlwaysEquals(): 'yes', AlwaysEquals(): 'no'}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "greenhouse-norway",
   "metadata": {},
   "source": [
    "#### hash comparison test and overwritting keys"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "virtual-accommodation",
   "metadata": {},
   "source": [
    "Instances of this class will return the same hash but compares as **non-equal**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "italian-particle",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SameHash:\n",
    "    def __hash__(self):\n",
    "        return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "surgical-drama",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = SameHash()\n",
    "b = SameHash()\n",
    "a == b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "martial-zimbabwe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hash(a), hash(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "acquired-circus",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{<__main__.SameHash at 0x188bab25e50>: 'a',\n",
       " <__main__.SameHash at 0x188bab25130>: 'b'}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{a : 'a', b : 'b'}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "technical-liberty",
   "metadata": {},
   "source": [
    "The keys getting overwritten effect isn’t caused\n",
    "by hash value collisions alone either"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "great-surgery",
   "metadata": {},
   "source": [
    "### Summary of findings\n",
    "\n",
    "Both equality and the hash value have to be the same to get this strange behaviour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "ranking-stable",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# they all compare equal\n",
    "True == 1 == 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "imposed-cincinnati",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1, 1)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# they all have the same hash value\n",
    "(hash(True), hash(1), hash(1.0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "civic-afternoon",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{True: 'maybe'}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the combined effect is this strange dictionary expression\n",
    "{True: 'yes', 1: 'no', 1.0: 'maybe'}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "particular-daughter",
   "metadata": {},
   "source": [
    "___\n",
    "## 7.5 So many ways to merge dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "flying-office",
   "metadata": {},
   "source": [
    "Often using dictionaries as the underlying data structure for representing configuration keys and values is beneficial. And so frequently a way is needed to combine or to **merge the config defaults and the user overrides** into a single dictionary with the final configuration values.\n",
    "\n",
    "Sometimes you need a way to merge two or more dictionaries into one, so that the resulting dictionary contains a combination of the keys and values of the source dicts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "similar-medicine",
   "metadata": {},
   "outputs": [],
   "source": [
    "# config defaults\n",
    "xs = {'a' : 1, 'b' : 2}\n",
    "# overrides\n",
    "ys = {'b' : 3, 'c': 4}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "incorporate-membership",
   "metadata": {},
   "source": [
    "### Classical solution for merging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "enormous-haven",
   "metadata": {},
   "outputs": [],
   "source": [
    "zs = {}\n",
    "zs.update(xs)\n",
    "# note that b is the default value for b is overwritten\n",
    "zs.update(ys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "greek-missile",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 3, 'c': 4}"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "inner-object",
   "metadata": {},
   "outputs": [],
   "source": [
    "# implementation\n",
    "def update(dict1, dict2):\n",
    "    for key, value in dict2.items():\n",
    "        dict1[key] = value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bearing-economy",
   "metadata": {},
   "source": [
    "### Modern approach \n",
    "However, just like making repeated ```update()``` calls, this approach\n",
    "only works for merging two dictionaries and **cannot be generalized\n",
    "to combine an arbitrary number of dictionaries in one step**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "adjusted-stone",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 3, 'c': 4}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zs = dict(xs, **ys)\n",
    "zs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "documentary-czech",
   "metadata": {},
   "source": [
    "___\n",
    "## 7.6 Dictionary Pretty-Printing\n",
    "\n",
    "### Summary\n",
    "* The default to-string conversion for dictionary objects in\n",
    "Python can be difficult to read.\n",
    "* The ```pprint``` and ```json``` module are “higher-fidelity” options built\n",
    "into the Python standard library.\n",
    "* Be careful with using ```json.dumps()``` and non-primitive keys\n",
    "and values as this will trigger a ```TypeError```.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "cleared-letter",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"{'a': 23, 'b': 42, 'c': 12648430}\""
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# no identation!\n",
    "mapping = {'a': 23, 'b': 42, 'c': 0xc0ffee}\n",
    "str(mapping)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "honey-rings",
   "metadata": {},
   "source": [
    "### ```json``` module \n",
    "While this looks nice and readable, it isn’t a perfect solution. Printing dictionaries with the json module **only works with dicts that contain primitive types**—you’ll **run into trouble trying to print a dictionary\n",
    "that contains a non-primitive data type, like a function**.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "completed-antenna",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "    \"a\": 23,\n",
      "    \"b\": 42,\n",
      "    \"c\": 12648430\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "print(json.dumps(mapping, indent=4, sort_keys=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "imported-delay",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Object of type set is not JSON serializable\n"
     ]
    }
   ],
   "source": [
    "mapping['d'] = {1, 2, 3}\n",
    "try: \n",
    "    json.dumps(mapping)\n",
    "except TypeError as err:\n",
    "    print(err)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "familiar-membrane",
   "metadata": {},
   "source": [
    "### ```pprint``` module\n",
    "\n",
    "Handles non-primitive types and prints the dictionary in a reproducible manner. However, it doesn;t represent nested structures as well as ```json```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "stretch-trinity",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 23, 'b': 42, 'c': 12648430, 'd': {1, 2, 3}}\n"
     ]
    }
   ],
   "source": [
    "import pprint\n",
    "\n",
    "pprint.pprint(mapping)"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}