WhenObjectsAreAlike.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e45ba936",
   "metadata": {},
   "source": [
    "# When Objects are Alike\n",
    "\n",
    "- in programming, duplicate code is considered evil\n",
    "    - difficult to debug and maintain code\n",
    "- there are many ways to merge pieces of code or objects that have similar funtionalities\n",
    "- the concept of inheritance introduced in Chapter 1 is an important one that allows us to create **is-a** relationship between two or more classes\n",
    "    - abstract common login into base or superclass and extend the superclass with specific details in each subclass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dfa4db5",
   "metadata": {},
   "source": [
    "## Basic inhertiance\n",
    "\n",
    "- technically every class inherits from built-in *object* class\n",
    "- generally we extend base/parent/super class and customize/add more functionalites to the derived/child class\n",
    "- child class inherits methods and attributes defined in parent classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0bbfb66d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MySubClass(object):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9448ee10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class MySubClass in module __main__:\n",
      "\n",
      "class MySubClass(builtins.object)\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(MySubClass)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "980bf000",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "\n",
    "class Contact:\n",
    "    all_contacts: List[\"Contact\"] = [] # class variable\n",
    "    \n",
    "    def __init__(self, name: str, email: str) -> None:\n",
    "        self.name = name\n",
    "        self.email = email\n",
    "        Contact.all_contacts.append(self)\n",
    "        \n",
    "    def __repr__(self) -> str:\n",
    "        \"\"\"\n",
    "        :param: None\n",
    "        :return: str representation of class\n",
    "        \"\"\"\n",
    "        return (f'{self.__class__.__name__}'\n",
    "                f'({self.name!r}, {self.email!r})'\n",
    "               )\n",
    "       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b613796c",
   "metadata": {},
   "outputs": [],
   "source": [
    "c_1 = Contact(\"Dusty\", \"dusty@example.com\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "74462641",
   "metadata": {},
   "outputs": [],
   "source": [
    "c_2 = Contact(\"Steve\", \"steve@itmaybehack.com\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "68a24abe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Contact('Dusty', 'dusty@example.com'),\n",
       " Contact('Steve', 'steve@itmaybehack.com')]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Contact.all_contacts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c08c2ccd",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Supplier(Contact):\n",
    "    def order(self, order: \"Order\") -> None:\n",
    "        print(\n",
    "            \"If this were a real system we would send \"\n",
    "            f\"'{order}' to '{self.name}'\"\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "58be0ead",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = Contact(\"Some Body\", \"somebody@example.net\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "f7bcdcc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = Supplier(\"Sup Plier\", \"supplier@example.net\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7841f2b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pprint import pprint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "83aad84b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Contact('Dusty', 'dusty@example.com'),\n",
      " Contact('Steve', 'steve@itmaybehack.com'),\n",
      " Contact('Some Body', 'somebody@example.net'),\n",
      " Supplier('Sup Plier', 'supplier@example.net')]\n"
     ]
    }
   ],
   "source": [
    "pprint(c.all_contacts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "5a75e918",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Contact' object has no attribute 'order'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[27], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# contact objects don't have order\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[43mc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43morder\u001b[49m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mI need pliers\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'Contact' object has no attribute 'order'"
     ]
    }
   ],
   "source": [
    "# contact objects don't have order\n",
    "c.order(\"I need pliers\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f69068a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "If this were a real system we would send 'I need pliers' to 'Sup Plier'\n"
     ]
    }
   ],
   "source": [
    "s.order(\"I need pliers\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73215886",
   "metadata": {},
   "source": [
    "## Extending built-ins\n",
    "- inheritance allows us to extend the functionalities of built-in classes\n",
    "- in Contact class, we're adding contacts to a list of Contact\n",
    "- what if we wanted to search the conact list by name?\n",
    "- we could add a method in Contact class to search the list, but the better yet we could add search method to **Contact List** itself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba985064",
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import annotations\n",
    "# this will let us use user-defined types in Python 3.9 or lower as type annotations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "16446740",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ContactList(list[\"Contact\"]):\n",
    "    def search(self, name:str) -> list[\"Contact\"]:\n",
    "        matching_contacts: list[\"Contact\"] = []\n",
    "        matching_contacts = [contact for contact in self if name in contact.name]\n",
    "        return matching_contacts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "09f6b963",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = Contact(\"John A\",  \"john@example.net\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "67006b2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "c1 = Contact(\"John B\", \"john@B.com\")\n",
    "c2 = Contact(\"Jenna C\", \"cutty@C.org\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "00803387",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Contact('John A', 'john@example.net'), Contact('John B', 'john@B.com')]\n"
     ]
    }
   ],
   "source": [
    "print(Contact.all_contacts.search('John'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7995308c",
   "metadata": {},
   "source": [
    "### Extending dict class\n",
    "- create a dictionary class that extends the built-in dict to trackt the longest key it has seen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "68173787",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Optional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "573e2312",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LongKeyDict(dict[str, int]):\n",
    "    def longest_key(self) -> Optional[str]:\n",
    "        \"\"\"In effect, max(self, key=len) but less obscure\"\"\"\n",
    "        \n",
    "        longest = None\n",
    "        for key in self:\n",
    "            if longest is None or len(key) > len(longest):\n",
    "                longest = key\n",
    "        return longest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "5ea6ff37",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test the LongKeyDict\n",
    "# perhaps key is username and value is the number of articles they read\n",
    "articles_read = LongKeyDict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "6c58fa35",
   "metadata": {},
   "outputs": [],
   "source": [
    "articles_read['lucy'] = 42\n",
    "articles_read['philips'] = 10\n",
    "articles_read['steve'] = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "dfef4b7d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'philips'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "articles_read.longest_key()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "c0b2f52b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'philips'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same as\n",
    "max(articles_read, key=len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c8ccba63",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {\"a\": 42, \"a\": 3.14}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "94eb2722",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 3.14}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "22ae28c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 'true'}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1: \"one\", True: \"true\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "48752bcf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# extending Dict to not allow duplicate key insert/update\n",
    "\n",
    "from __future__ import annotations\n",
    "from typing import cast, Any, Union, Tuple, Dict, Iterable, Mapping\n",
    "from collections.abc import Hashable\n",
    "\n",
    "DictInit = Union[Iterable[Tuple[Hashable, Any]], Mapping[Hashable, Any], None]\n",
    "\n",
    "class NoDupDict(Dict[Hashable, Any]):\n",
    "    def __setitem__(self, key: Hashable, value: Any) -> None:\n",
    "        if key in self:\n",
    "            raise ValueError(f\"duplicate {key!r}\")\n",
    "        super().__setitem__(key, value)\n",
    "\n",
    "    def __init__(self, init: DictInit = None, **kwargs: Any) -> None:\n",
    "        if isinstance(init, Mapping):\n",
    "            super().__init__(init, **kwargs)\n",
    "        elif isinstance(init, Iterable):\n",
    "            for k, v in cast(Iterable[Tuple[Hashable, Any]], init):\n",
    "                self[k] = v\n",
    "        elif init is None:\n",
    "            super().__init__(**kwargs)\n",
    "        else:\n",
    "            super().__init__(init, **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a71edd4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = NoDupDict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e62a6961",
   "metadata": {},
   "outputs": [],
   "source": [
    "d[1] = 'a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6b4acd20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 'a'}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9c2b7a3a",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "duplicate 1",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[12], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m d[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m'\u001b[39m\n",
      "Cell \u001b[0;32mIn[8], line 12\u001b[0m, in \u001b[0;36mNoDupDict.__setitem__\u001b[0;34m(self, key, value)\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__setitem__\u001b[39m(\u001b[38;5;28mself\u001b[39m, key: Hashable, value: Any) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m     11\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m key \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m---> 12\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mduplicate \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mkey\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m     13\u001b[0m     \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__setitem__\u001b[39m(key, value)\n",
      "\u001b[0;31mValueError\u001b[0m: duplicate 1"
     ]
    }
   ],
   "source": [
    "d[1] = 'b'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87fbda20",
   "metadata": {},
   "source": [
    "### Multiple types for type hint\n",
    "- say you want to store either **int** or **str** as value or key\n",
    "- See details for type hints: https://docs.python.org/3.10/library/typing.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "0c3ee620",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Union"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "7d4fc924",
   "metadata": {},
   "outputs": [],
   "source": [
    "myDict: dict[str, Union[int, str]] = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "77129b0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "myDict['uno'] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "e2d3fc1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "myDict['uno'] = 'one'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "666cb1f5",
   "metadata": {},
   "source": [
    "## Overriding and super\n",
    "- inheritance not only allows for adding new behaviors, but also overriding/chaning existing behaviors\n",
    "- any method can be overridden including `__special__` built-ins\n",
    "    - such as `__init__`, `__str__`, `__repr__`, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "dc27b26a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Friend(Contact):\n",
    "    \n",
    "    # overrides Contact.__init__\n",
    "    def __init__(self, name: str, email: str, phone: str) -> None:\n",
    "        self.name = name # duplicate member\n",
    "        self.email = email # duplicate member\n",
    "        self.phone = phone\n",
    "        \n",
    "        # members of Contact are not inherited; \n",
    "        # so if Contact is updated, Friend will not benefit the updates\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "0bf0c01f",
   "metadata": {},
   "outputs": [],
   "source": [
    "f = Friend('James', \"james@email.com\", '123-4567')\n",
    "# f object will not be added to all_contacts list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "d7e1ae66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Contact('John A', 'john@example.net'),\n",
      " Contact('John B', 'john@B.com'),\n",
      " Contact('Jenna C', 'cutty@C.org')]\n"
     ]
    }
   ],
   "source": [
    "pprint(f.all_contacts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "3c390a87",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Contact('John A', 'john@example.net'),\n",
       " Contact('John B', 'john@B.com'),\n",
       " Contact('Jenna C', 'cutty@C.org')]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Contact.all_contacts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "04d490e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# better approach is to use super() function\n",
    "class Friend(Contact):\n",
    "    \n",
    "    # overrides Contact.__init__\n",
    "    def __init__(self, name: str, email: str, phone: str) -> None:\n",
    "        #super().__init__(name, email)\n",
    "        # alternatively; useful in multiple inheritance\n",
    "        Contact.__init__(self, name, email)\n",
    "        # first bind the isntance to the parent class\n",
    "        self.phone = phone"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "17fe3f93",
   "metadata": {},
   "outputs": [],
   "source": [
    "f1 = Friend('Jake', 'jake@jake.com', '234-5678')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "55859d65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Contact('John A', 'john@example.net'),\n",
      " Contact('John B', 'john@B.com'),\n",
      " Contact('Jenna C', 'cutty@C.org'),\n",
      " Friend('Jake', 'jake@jake.com')]\n"
     ]
    }
   ],
   "source": [
    "pprint(f1.all_contacts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "a6f08eec",
   "metadata": {},
   "outputs": [],
   "source": [
    "f2 = Friend('Joker', 'joker@joker.com', '234-5678')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "fd3d449a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Contact('John A', 'john@example.net'),\n",
      " Contact('John B', 'john@B.com'),\n",
      " Contact('Jenna C', 'cutty@C.org'),\n",
      " Friend('Jake', 'jake@jake.com'),\n",
      " Friend('Joker', 'joker@joker.com')]\n"
     ]
    }
   ],
   "source": [
    "pprint(f1.all_contacts)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4c4a7b2",
   "metadata": {},
   "source": [
    "## Use inhertitance or not...\n",
    "\n",
    "- inheritance is a \"Is A\" relationship\n",
    "- it hould be only used to model \"is-a\" relationship\n",
    "- Liskov's substitution principle says that an object of type *Derived*, which inherits from *Base*, can replace an object of type *Base* without altering the desirable properties of a program.\n",
    "- a simple test to use to make sure inheritance is the right design:\n",
    "    1. Evaluate B is an A: think about the relationship and justify it\n",
    "    2. Evaluate A is an B: Reverse the relationship and justify it. Does it also make sense?\n",
    "    \n",
    "- if you justify both the relationships, then you should NEVER inherit those classes from one another\n",
    "    - meaning, if A is B then B is not A should hold or vice-versa\n",
    "    \n",
    "- e.g., when designing Rectangle and Square classes should you use inheritance?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "978b6431",
   "metadata": {},
   "source": [
    "## Multiple inheritance\n",
    "- tricky and touchy concept!\n",
    "- conceptually simple - a child class inheirts from multiple parent classes\n",
    "- avoid multiple inheritance if you can!\n",
    "    - if you think you need multiple inheritance, you might be wrong\n",
    "    - if you know you need multiple inheritance, you might be right\n",
    "    \n",
    "- let's look at this toy example to understand multiple inheritance    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "59fcb61d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# by dafault all python class implicitly inherit from object base class\n",
    "class A(object):\n",
    "    def __init__(self):\n",
    "        self.a = \"A\"\n",
    "        \n",
    "    def printMe(self):\n",
    "        print(\"A's printMe called!\")\n",
    "        print(f'a = {self.a}')\n",
    "    \n",
    "    def sayHi(self):\n",
    "        print(f'{self.a} says HI!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "63d76af1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A's printMe called!\n",
      "a = A\n",
      "A says HI!\n"
     ]
    }
   ],
   "source": [
    "obja = A()\n",
    "obja.printMe()\n",
    "obja.sayHi()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "9733ce8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class B(object):\n",
    "    def __init__(self):\n",
    "        self.b = 'B'\n",
    "        \n",
    "    def printMe(self):\n",
    "        print(\"B's printMe called\")\n",
    "        print(f'b = {self.b}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9de6167d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B's printMe called\n",
      "b = B\n"
     ]
    }
   ],
   "source": [
    "objb = B()\n",
    "objb.printMe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "ab9228f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# class C inherits from classes A and B\n",
    "# order of inheritance matters!\n",
    "class C(B, A):\n",
    "    def __init__(self):\n",
    "        # the order in which the super initializers are called matters!\n",
    "        # same attributes of proior initializer are \n",
    "        # overridden by later initializer\n",
    "        A.__init__(self)\n",
    "        B.__init__(self)\n",
    "        #super().__init__()\n",
    "        self.c = 'C'\n",
    "    \n",
    "    def printMe(self):\n",
    "        print(\"C's printMe called:\")\n",
    "        print(f\"Attributes are {self.a}, {self.b}, {self.c}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "a25f0ee0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C's printMe called:\n",
      "Attributes are A, B, C\n"
     ]
    }
   ],
   "source": [
    "c = C()\n",
    "c.printMe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "23410fc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "class D(C):\n",
    "    # D inherits from C\n",
    "    def printMe(self):\n",
    "        print(f\"Attributes are {self.a}, {self.b}, {self.c}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "1f80eec9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attributes are A, B, C\n"
     ]
    }
   ],
   "source": [
    "d = D()\n",
    "d.printMe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15f99abf",
   "metadata": {},
   "source": [
    "## Diamond problem\n",
    "- diamond inheritance is a problem!\n",
    "- superclass may be called multiple times by base classes because of the organization of the class hierarchy\n",
    "- or the superclass's initializer may never be called\n",
    "\n",
    "![](resources/ch-2_fig_2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cb11f908",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BaseClass:\n",
    "    num_base_calls = 0\n",
    "    def call_me(self) -> None:\n",
    "        print(\"Calling method on BaseClass\")\n",
    "        self.num_base_calls += 1 \n",
    "        # uses class variable num_base_calls the first time\n",
    "        # not great; but quick way to avoid __init__ function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6285e40f",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = BaseClass()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f98a215c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling method on BaseClass\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.call_me()\n",
    "b.num_base_calls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "cb72de1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BaseClass:\n",
    "    num_base_calls = 0\n",
    "    def call_me(self) -> None:\n",
    "        print(\"Calling method on BaseClass\")\n",
    "        self.num_base_calls += 1\n",
    "\n",
    "class LeftSubclass(BaseClass):\n",
    "    num_left_calls = 0\n",
    "    def call_me(self) -> None:\n",
    "        BaseClass.call_me(self)\n",
    "        print(\"Calling method on LeftSubclass\")\n",
    "        self.num_left_calls += 1\n",
    "        \n",
    "class RightSubclass(BaseClass):\n",
    "    num_right_calls = 0 \n",
    "    def call_me(self) -> None:\n",
    "        BaseClass.call_me(self)\n",
    "        print(\"Calling method on RightSubclass\")\n",
    "        self.num_right_calls += 1\n",
    "        \n",
    "class Subclass(LeftSubclass, RightSubclass):\n",
    "    num_sub_calls = 0\n",
    "    def call_me(self) -> None:\n",
    "        LeftSubclass.call_me(self)\n",
    "        RightSubclass.call_me(self)\n",
    "        print(\"Calling method on Subclass\")\n",
    "        self.num_sub_calls += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "652387cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling method on BaseClass\n",
      "Calling method on LeftSubclass\n",
      "Calling method on BaseClass\n",
      "Calling method on RightSubclass\n",
      "Calling method on Subclass\n"
     ]
    }
   ],
   "source": [
    "s = Subclass()\n",
    "s.call_me()\n",
    "# notice the BaseClass called twice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "86ef7003",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 1 2\n"
     ]
    }
   ],
   "source": [
    "print(s.num_sub_calls, s.num_left_calls, \n",
    "      s.num_right_calls, s.num_base_calls)\n",
    "# this may result into buggy logic, e.g., depositing money into \n",
    "# bank account twice"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28ae1628",
   "metadata": {},
   "source": [
    "### use super( )\n",
    "- `super()` function was originally developed to make complicated forms of multiple inheritance possible for method resolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "8be64c14",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BaseClass:\n",
    "    num_base_calls = 0\n",
    "    def call_me(self) -> None:\n",
    "        print(\"Calling method on BaseClass\")\n",
    "        self.num_base_calls += 1\n",
    "\n",
    "class LeftSubclass_S(BaseClass):\n",
    "    num_left_calls = 0\n",
    "    def call_me(self) -> None:\n",
    "        super().call_me()\n",
    "        print(\"Calling method on LeftSubclass\")\n",
    "        self.num_left_calls += 1\n",
    "        \n",
    "class RightSubclass_S(BaseClass):\n",
    "    num_right_calls = 0 \n",
    "    def call_me(self) -> None:\n",
    "        super().call_me()\n",
    "        print(\"Calling method on RightSubclass\")\n",
    "        self.num_right_calls += 1\n",
    "        \n",
    "class Subclass_S(RightSubclass_S, LeftSubclass_S):\n",
    "    num_sub_calls = 0\n",
    "    def call_me(self) -> None:\n",
    "        super().call_me()\n",
    "        print(\"Calling method on Subclass\")\n",
    "        self.num_sub_calls += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "ee517faa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling method on BaseClass\n",
      "Calling method on LeftSubclass\n",
      "Calling method on RightSubclass\n",
      "Calling method on Subclass\n"
     ]
    }
   ],
   "source": [
    "ss = Subclass_S()\n",
    "ss.call_me()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "74dce83f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 1 1\n"
     ]
    }
   ],
   "source": [
    "print(ss.num_sub_calls, ss.num_left_calls, \n",
    "      ss.num_right_calls, ss.num_base_calls)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91c09625",
   "metadata": {},
   "source": [
    "### Python's Method Resolution Order (MRO)\n",
    "- python provides `__mro__` attribute as a tuple to see how the method calls are resolved (similar to stacktrace) from various superclasses\n",
    "- it's a tuple with the last member will always be 'object'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "a7271b87",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pprint import pprint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "d1381eba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<class '__main__.Subclass'>,\n",
      " <class '__main__.LeftSubclass'>,\n",
      " <class '__main__.RightSubclass'>,\n",
      " <class '__main__.BaseClass'>,\n",
      " <class 'object'>)\n"
     ]
    }
   ],
   "source": [
    "pprint(Subclass.__mro__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "98b3a4c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<class '__main__.Subclass_S'>,\n",
      " <class '__main__.RightSubclass_S'>,\n",
      " <class '__main__.LeftSubclass_S'>,\n",
      " <class '__main__.BaseClass'>,\n",
      " <class 'object'>)\n"
     ]
    }
   ],
   "source": [
    "pprint(Subclass_S.__mro__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40314e19",
   "metadata": {},
   "source": [
    "## Polymorphism\n",
    "- different behaviors happend depending on which subclass is being used, without having to explictly know what the actually subclass is\n",
    "- also called Liskov Substitution Principle - honoring Barbara Liskov\n",
    "    - we should be able to subtitute any subclass for its superclass\n",
    "- polymorphism is one of the most important reasons to use inheritance in many OOD\n",
    "- let's look at an example of media player to demonstrate how polymorphims can be used\n",
    "- different types of media file that requires different decompression and decoding techniques\n",
    "- simplify design by using a public API `play()` method on an audio_file object to play various files (.wav, .mp3, .ogg, .wma, etc.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "b4c9555f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "class AudioFile:\n",
    "    ext: str # just for mypy; not an actual class variable\n",
    "        \n",
    "    def __init__(self, filepath: Path) -> None:\n",
    "        if not filepath.suffix == self.ext:\n",
    "            raise ValueError(\"Invalid file format\")\n",
    "        self.filepath = filepath\n",
    "# Note how AudioFile can access the ext class \n",
    "# variable from different subclasses (polymorphism at work!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "85933dfd",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MP3File(AudioFile):\n",
    "    ext = '.mp3'\n",
    "    \n",
    "    def play(self) -> None:\n",
    "        # implement mp3 play\n",
    "        print(f'playing {self.filepath} as MP3')\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "951829c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "class WavFile(AudioFile):\n",
    "    ext = '.wav'\n",
    "    \n",
    "    def play(self) -> None:\n",
    "        # implement wav play\n",
    "        print(f'playing {self.filepath} as WAV')\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "1a76bf4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class OggFile(AudioFile):\n",
    "    ext = '.ogg'\n",
    "    \n",
    "    def play(self) -> None:\n",
    "        # implement ogg play\n",
    "        print(f'playing {self.filepath} as OGG')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "8a652eaa",
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = MP3File(Path('Heart of the sunrise.mp3'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "c021a829",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "playing Heart of the sunrise.mp3 as MP3\n"
     ]
    }
   ],
   "source": [
    "p1.play()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "d9146aca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "playing Roundabout.wav as WAV\n"
     ]
    }
   ],
   "source": [
    "p2 = WavFile(Path(\"Roundabout.wav\"))\n",
    "p2.play()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "e30e3899",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "playing Roundabout.ogg as OGG\n"
     ]
    }
   ],
   "source": [
    "p3 = OggFile(Path(\"Roundabout.ogg\"))\n",
    "p3.play()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "4a776a8f",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Invalid file format",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[66], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m p4 \u001b[38;5;241m=\u001b[39m \u001b[43mMP3File\u001b[49m\u001b[43m(\u001b[49m\u001b[43mPath\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mRocky Mountain.mov\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[58], line 8\u001b[0m, in \u001b[0;36mAudioFile.__init__\u001b[0;34m(self, filepath)\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, filepath: Path) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m      7\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m filepath\u001b[38;5;241m.\u001b[39msuffix \u001b[38;5;241m==\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mext:\n\u001b[0;32m----> 8\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInvalid file format\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m      9\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfilepath \u001b[38;5;241m=\u001b[39m filepath\n",
      "\u001b[0;31mValueError\u001b[0m: Invalid file format"
     ]
    }
   ],
   "source": [
    "p4 = MP3File(Path(\"Rocky Mountain.mov\"))\n",
    "# .mov is not a valid extension for MP3File"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c16720ae",
   "metadata": {},
   "source": [
    "## Duck typing\n",
    "- polymorphism is one of the collest things about OOP; makes some programming designs obvious that were not possible in earlier paradigms\n",
    "- However, Python makes polymosphism less awesome because of duck typing.\n",
    "- Python uses duck test rule to bind operations to data\n",
    "- duck test: \"If it walks like a duck and it quacks like a duck, then it must be a duck\"\n",
    "- to determine whether a function can be applied to a new type, we apply Python's fundamental rule of polymorphism, called duck typing rule: if all of the operations inside the function can be applied to the type, the function can be applied to the type\n",
    "- it allows us to use *any* object that provides the required behavior without forcing it to be a subclass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "8022e859",
   "metadata": {},
   "outputs": [],
   "source": [
    "class FlacFile:\n",
    "    def __init__(self, filepath: Path) -> None:\n",
    "        if not filepath.suffix == '.flac':\n",
    "            raise ValueError('Not a .flac file')\n",
    "        self.filepath = filepath\n",
    "        \n",
    "    def play(self) -> None:\n",
    "        # implement of .flac play\n",
    "        print(f'playing {self.filepath} as FLAC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "160137ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "playing NeverGiveup.flac as FLAC\n"
     ]
    }
   ],
   "source": [
    "f = FlacFile(Path('NeverGiveup.flac'))\n",
    "f.play()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f65d1a3",
   "metadata": {},
   "source": [
    "## Mixin design pattern\n",
    "\n",
    "- **Minin** is the simplest and most useful form of multiple inheritance\n",
    "- a mixin class definition class definition is not intended to exist on its own, but is meant to be inherited by some other class\n",
    "- goal is to entend/provide extra functionality without the worring about the correctness of \"is-a\" relationship\n",
    "- mixins are sometimes described as being \"including\" rather than \"inherited\"\n",
    "- mixins encourage code reuse and can be used to avoid the inheritance ambiguity that multiple inheritance can cause (**diamond problem**)\n",
    "- a mixin can also be viewed as an interface with implemented methods\n",
    "- the following AsDictionaryMixin exposes to_dict() interface that returns the representsion of itself as a dictionary\n",
    "- using dictionary comprehension, the function “creates a dictionary mapping prop to value for each item in self.__dict__.items() if the prop is not internal.”\n",
    "- Employee and Address are not AsDictionaryMixin, but both of them \"use\" AsDictionaryMixin mixin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "eb6b3f9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class AsDictionaryMixin:\n",
    "    def to_dict(self):\n",
    "        return {\n",
    "            prop: self._represent(value)\n",
    "            for prop, value in self.__dict__.items()\n",
    "            if not self._is_internal(prop)\n",
    "        }\n",
    "\n",
    "    def _represent(self, value):\n",
    "        if isinstance(value, object):\n",
    "            if hasattr(value, 'to_dict'):\n",
    "                return value.to_dict()\n",
    "            else:\n",
    "                return str(value)\n",
    "        else:\n",
    "            return value\n",
    "\n",
    "    def _is_internal(self, prop):\n",
    "        return prop.startswith('_')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "19648719",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee(AsDictionaryMixin):\n",
    "    def __init__(self, id, name, address, role):\n",
    "        self.id = id\n",
    "        self.name = name\n",
    "        self.address = address\n",
    "        self.role = role\n",
    "\n",
    "class Address(AsDictionaryMixin):\n",
    "    def __init__(self, street, city, state, zipcode, street2=''):\n",
    "        self.street = street\n",
    "        self.street2 = street2\n",
    "        self.city = city\n",
    "        self.state = state\n",
    "        self.zipcode = zipcode\n",
    "\n",
    "    def __str__(self):\n",
    "        lines = [self.street]\n",
    "        if self.street2:\n",
    "            lines.append(self.street2)\n",
    "        lines.append(f'{self.city}, {self.state} {self.zipcode}')\n",
    "        return '\\n'.join(lines)\n",
    "    \n",
    "class EmployeeDatabase:\n",
    "    def __init__(self):\n",
    "        self._employees = [\n",
    "            {\n",
    "                'id': 1,\n",
    "                'name': 'Mary Poppins',\n",
    "                'role': 'manager'\n",
    "            },\n",
    "            {\n",
    "                'id': 2,\n",
    "                'name': 'John Smith',\n",
    "                'role': 'secretary'\n",
    "            },\n",
    "            {\n",
    "                'id': 3,\n",
    "                'name': 'Kevin Bacon',\n",
    "                'role': 'sales'\n",
    "            },\n",
    "            {\n",
    "                'id': 4,\n",
    "                'name': 'Jane Doe',\n",
    "                'role': 'factory'\n",
    "            },\n",
    "            {\n",
    "                'id': 5,\n",
    "                'name': 'Robin Williams',\n",
    "                'role': 'secretary'\n",
    "            },\n",
    "        ]\n",
    "        self.employee_addresses = AddressBook()\n",
    "\n",
    "    @property\n",
    "    def employees(self):\n",
    "        return [self._create_employee(**data) for data in self._employees]\n",
    "\n",
    "    def _create_employee(self, id, name, role):\n",
    "        address = self.employee_addresses.get_employee_address(id)\n",
    "        employee_role = self.get_role(id)\n",
    "        return Employee(id, name, address, employee_role)\n",
    "    \n",
    "    def get_role(self, emp_id):\n",
    "        for emp in self._employees:\n",
    "            if emp['id'] == emp_id:\n",
    "                return emp['role']\n",
    "        raise ValueErorr(f'Employee id: {emp_id} not found in database!')\n",
    "        \n",
    "\n",
    "class AddressBook:\n",
    "    def __init__(self):\n",
    "        self._employee_addresses = {\n",
    "            1: Address('121 Admin Rd.', 'Concord', 'NH', '03301'),\n",
    "            2: Address('67 Paperwork Ave', 'Manchester', 'NH', '03101'),\n",
    "            3: Address('15 Rose St', 'Concord', 'NH', '03301', 'Apt. B-1'),\n",
    "            4: Address('39 Sole St.', 'Concord', 'NH', '03301'),\n",
    "            5: Address('99 Mountain Rd.', 'Concord', 'NH', '03301'),\n",
    "        }\n",
    "\n",
    "    def get_employee_address(self, employee_id):\n",
    "        address = self._employee_addresses.get(employee_id)\n",
    "        if not address:\n",
    "            raise ValueError(f'Employee_id: {employee_id}')\n",
    "        return address"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "66449661",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"id\": \"1\",\n",
      "  \"name\": \"Mary Poppins\",\n",
      "  \"address\": {\n",
      "    \"street\": \"121 Admin Rd.\",\n",
      "    \"street2\": \"\",\n",
      "    \"city\": \"Concord\",\n",
      "    \"state\": \"NH\",\n",
      "    \"zipcode\": \"03301\"\n",
      "  },\n",
      "  \"role\": \"manager\"\n",
      "}\n",
      "{\n",
      "  \"id\": \"2\",\n",
      "  \"name\": \"John Smith\",\n",
      "  \"address\": {\n",
      "    \"street\": \"67 Paperwork Ave\",\n",
      "    \"street2\": \"\",\n",
      "    \"city\": \"Manchester\",\n",
      "    \"state\": \"NH\",\n",
      "    \"zipcode\": \"03101\"\n",
      "  },\n",
      "  \"role\": \"secretary\"\n",
      "}\n",
      "{\n",
      "  \"id\": \"3\",\n",
      "  \"name\": \"Kevin Bacon\",\n",
      "  \"address\": {\n",
      "    \"street\": \"15 Rose St\",\n",
      "    \"street2\": \"Apt. B-1\",\n",
      "    \"city\": \"Concord\",\n",
      "    \"state\": \"NH\",\n",
      "    \"zipcode\": \"03301\"\n",
      "  },\n",
      "  \"role\": \"sales\"\n",
      "}\n",
      "{\n",
      "  \"id\": \"4\",\n",
      "  \"name\": \"Jane Doe\",\n",
      "  \"address\": {\n",
      "    \"street\": \"39 Sole St.\",\n",
      "    \"street2\": \"\",\n",
      "    \"city\": \"Concord\",\n",
      "    \"state\": \"NH\",\n",
      "    \"zipcode\": \"03301\"\n",
      "  },\n",
      "  \"role\": \"factory\"\n",
      "}\n",
      "{\n",
      "  \"id\": \"5\",\n",
      "  \"name\": \"Robin Williams\",\n",
      "  \"address\": {\n",
      "    \"street\": \"99 Mountain Rd.\",\n",
      "    \"street2\": \"\",\n",
      "    \"city\": \"Concord\",\n",
      "    \"state\": \"NH\",\n",
      "    \"zipcode\": \"03301\"\n",
      "  },\n",
      "  \"role\": \"secretary\"\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "def print_dict(d):\n",
    "    print(json.dumps(d, indent=2))\n",
    "\n",
    "for employee in EmployeeDatabase().employees:\n",
    "    print_dict(employee.to_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80057b78",
   "metadata": {},
   "source": [
    "## SOLID principle\n",
    "- a popular software design principle using OOP\n",
    "\n",
    "### S: Single Responsibility Principle\n",
    "- a class should have one responsibility\n",
    "- one reason to change when the requirments change\n",
    "\n",
    "### O: Open/Closed\n",
    "- a class should be open to extension but closed to modification\n",
    "\n",
    "### L: Liskov Substitution\n",
    "- named after Barbara Liskov creator of CLU programming language\n",
    "- any subclass can be subtituted for its superclass\n",
    "- essence of polymorphism\n",
    "\n",
    "### I: Interface Segregation\n",
    "- a class should have the smallest interface possible\n",
    "- classes should be relatively small and isolated\n",
    "\n",
    "### D: Dependency Inversion\n",
    "- convert bad dependency relationships into good ones"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86ab0315",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "- solve the following Kattis problems using OOD\n",
    "- must use inheritance (inheritance from object doesn't count)\n",
    "\n",
    "1. Statistics -  https://open.kattis.com/problems/statistics\n",
    "2. Datum - https://open.kattis.com/problems/datum\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d4f3b58",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.1 (main, Dec 23 2022, 09:40:27) [Clang 14.0.0 (clang-1400.0.29.202)]"
  },
  "vscode": {
   "interpreter": {
    "hash": "1a1af0ee75eeea9e2e1ee996c87e7a2b11a0bebd85af04bb136d915cefc0abce"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}