Chapter4_Classes_and_OOP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "right-scotland",
   "metadata": {},
   "source": [
    "# Chapter 4 Classes & OOP\n",
    "\n",
    "## 4.1 Object Comparisons ```is``` vs ```==```\n",
    "\n",
    "### Summary\n",
    "\n",
    "* ```==``` checks for equality. Are the **contents** the same?\n",
    "* ```is``` checks for identities. Are the references **pointing to the same object**?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "massive-divorce",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,3]\n",
    "# reference b that points to a\n",
    "b = a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "happy-pepper",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "indoor-singing",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "conventional-audience",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# equality \n",
    "a == b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "neural-squad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# indentity \n",
    "# both variables point to the same object\n",
    "a is b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "rapid-webmaster",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# copy of list a\n",
    "c = list(a)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "colored-campaign",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a == c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "acknowledged-antique",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a is c"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "finite-designer",
   "metadata": {},
   "source": [
    "___\n",
    "## 4.2 String Conversion ```__repr__``` and ```__str__```\n",
    "\n",
    "### Summary\n",
    "* You can control to-string conversion in your own classes using\n",
    "the ```__str__``` and ```__repr__``` “dunder” methods.\n",
    "* The result of ```__str__``` should be readable. The result of\n",
    "```__repr__``` should be unambiguous.\n",
    "* **Always add** a ```__repr__``` to your classes. The default implementation for ```__str__``` just calls ```__repr__```.\n",
    "* Use ```__unicode__``` instead of ```__str__``` in **Python 2**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "suburban-rocket",
   "metadata": {},
   "source": [
    "### Conventional ```__repr__``` and ```__str__```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "connected-market",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, color, mileage):\n",
    "        self.color = color\n",
    "        self.mileage = mileage\n",
    "    def __repr__(self):\n",
    "        return (f'{self.__class__.__name__}('\n",
    "                f'{self.color!r}, {self.mileage!r})')\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'a {self.color} car'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "fallen-london",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = Car('red', 250000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "bulgarian-lucas",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Car('red', 250000)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "revised-coaching",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a red car\n"
     ]
    }
   ],
   "source": [
    "print(car)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "compact-station",
   "metadata": {},
   "source": [
    "### Ways to take advantage of ```__str__```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "infrared-world",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, color, mileage):\n",
    "        self.color = color \n",
    "        self.mileage = mileage\n",
    "    \n",
    "    # this is called when print is called on this object\n",
    "    def __str__(self):\n",
    "        return f'a {self.color} car with {self.mileage} miles'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "divided-afghanistan",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a red car with 37281 miles\n"
     ]
    }
   ],
   "source": [
    "my_car = Car('red', 37281)\n",
    "print(my_car)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "unlike-pendant",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a red car with 37281 miles'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(my_car)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ongoing-genre",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a red car with 37281 miles'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{}'.format(my_car)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "legal-tanzania",
   "metadata": {},
   "source": [
    "### Why do we need ```__repr__```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "detected-evidence",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Car at 0x202bb65f6d0>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# since we have no __repr__ method we get this \n",
    "my_car"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "expected-peripheral",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, color, mileage):\n",
    "        self.color = color\n",
    "        self.mileage = mileage\n",
    "    def __repr__(self):\n",
    "        return '__repr__ for Car'\n",
    "    def __str__(self):\n",
    "        return '__str__ for Car'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "interstate-chancellor",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__str__ for Car\n"
     ]
    }
   ],
   "source": [
    "my_car = Car('red', 37821)\n",
    "print(my_car)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "unsigned-october",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__repr__ for Car"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_car"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "demographic-lodging",
   "metadata": {},
   "source": [
    "#### Lists and dicts always use the ```__repr__```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "hispanic-angola",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'[__repr__ for Car]'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str([my_car])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "disciplinary-things",
   "metadata": {},
   "source": [
    "### You can choose "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "geographic-donna",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'__str__ for Car'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(my_car)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "fixed-atlanta",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'__repr__ for Car'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repr(my_car)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "usual-plant",
   "metadata": {},
   "source": [
    "### datetime and string conversion\n",
    "\n",
    "* ```__repr__``` can be used to **recreate** the object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "balanced-oliver",
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime \n",
    "\n",
    "today = datetime.date.today()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "overhead-mitchell",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2021-05-09'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(today)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "muslim-welcome",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'datetime.date(2021, 5, 9)'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# repr can be used to recreate the object\n",
    "# they are helpful for developers\n",
    "repr(today)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fiscal-engine",
   "metadata": {},
   "source": [
    "If you don't add a ```__str__``` method python falls back on the ```__repr__``` method. \n",
    "\n",
    "**You should always have a ```__repr__``` class.** \n",
    "\n",
    "This guarantees useful string conversion in most cases."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "standard-european",
   "metadata": {},
   "source": [
    "### Python 2 example\n",
    "\n",
    "Use ```__unicode__``` instead of ```__str__```.\n",
    "\n",
    "In python 3 there's one data type to represent text : ```str```. In python 2.x there are two types: \n",
    "\n",
    "* ```str``` - ASCII character set \n",
    "* ```unicode``` - which is equivalent to the python 3 ```str```\n",
    "\n",
    "In python 2 we have another dunder method ```__unicode__```. In python 2: \n",
    "\n",
    "* ```__str__``` returns *bytes*\n",
    "* ```__unicode__``` return *characters*\n",
    "\n",
    "The print statement and ```str()``` call ```__str__```. The ```unicode()``` built-in calls ```__unicode__``` if it exists, and otherwise falls back to ```__str__``` and decodes the result with the system text encoding.\n",
    "\n",
    "**Unicode is the preferred and future-proof way** of\n",
    "handling text in your Python programs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "copyrighted-annex",
   "metadata": {},
   "outputs": [],
   "source": [
    "# How to write the __str__ dunder method in python 2.x\n",
    "class Car(object):\n",
    "    def __init__(self, color, mileage):\n",
    "        self.color = color\n",
    "        self.mileage = mileage\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return '{}({!r}, {!r})'.format(\n",
    "            self.__class__.__name__,\n",
    "            self.color, self.mileage)\n",
    "    \n",
    "    def __unicode__(self):\n",
    "        return u'a {self.color} car'.format(\n",
    "            self=self)\n",
    "    \n",
    "    # stub __str__ implementation\n",
    "    def __str__(self):\n",
    "        return unicode(self).encode('utf-8')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "conventional-supplier",
   "metadata": {},
   "source": [
    "___ \n",
    "## 4.3 Defining Your Own Exception Classes\n",
    "\n",
    "### Summary \n",
    "\n",
    "* Defining your own exception types will state your code’s intent\n",
    "more clearly and make it **easier to debug**.\n",
    "* Derive your custom exceptions from Python’s built-in\n",
    "Exception class or from more specific exception classes\n",
    "like ```ValueError``` or ```KeyError```.\n",
    "* You can use inheritance to define logically grouped exception\n",
    "hierarchies.\n",
    "\n",
    "**Reference:** https://www.programiz.com/python-programming/user-defined-exception"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "constitutional-watch",
   "metadata": {},
   "source": [
    "Let's say you want to validate an input string representing a person's name in your application"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "packed-pursuit",
   "metadata": {},
   "outputs": [],
   "source": [
    "def validate(name):\n",
    "    if len(name) < 10: \n",
    "        raise ValueError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "expressed-patent",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-32-84bf9236a789>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mvalidate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'joe'\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-31-addcb2b9be35>\u001b[0m in \u001b[0;36mvalidate\u001b[1;34m(name)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mvalidate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\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[0;32m      2\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m<\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m         \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "validate('joe')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "alert-writing",
   "metadata": {},
   "source": [
    "This stack trace isn't really that helpful. **Reading code costs time**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "geographic-baking",
   "metadata": {},
   "source": [
    "### Custom Exceptions\n",
    "\n",
    "* Custom exception classes make it easier to understand what's going on when things go wrong\n",
    "* It's good practice to create a **custom exception base class** for the module you are working on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "immune-scroll",
   "metadata": {},
   "outputs": [],
   "source": [
    "class NameTooShortError(ValueError):\n",
    "    pass\n",
    "\n",
    "def validate(name):\n",
    "    if len(name) < 10: \n",
    "        raise NameTooShortError(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "headed-worry",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "err: joe\n",
      "NameTooShortError: <class '__main__.NameTooShortError'>\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    validate('joe')\n",
    "\n",
    "except NameTooShortError as err:\n",
    "    print(f'err: {err}')\n",
    "    print(f'NameTooShortError: {NameTooShortError}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "diverse-lancaster",
   "metadata": {},
   "source": [
    "### Declaring custom exceptions base class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "danish-chambers",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BaseValidationError(ValueError):\n",
    "    pass\n",
    "\n",
    "class NameTooShortError(BaseValidationError):\n",
    "    \"\"\"Raised when the input is too small\"\"\"\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.message = \"Input is too small\"\n",
    "        super().__init__(self.message)\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'{self.name} -> {self.message}'\n",
    "\n",
    "class NameTooLongError(BaseValidationError):\n",
    "    \"\"\"Raised when the input is too long\"\"\"\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.message = \"Input is too big\"\n",
    "        super().__init__(self.message)\n",
    "        \n",
    "    def __str__(self):\n",
    "        return f'{self.name} -> {self.message}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "comparable-logic",
   "metadata": {},
   "outputs": [],
   "source": [
    "def validate(name):\n",
    "    if len(name) < 5:\n",
    "        raise NameTooShortError(name)\n",
    "    if len(name) > 10:\n",
    "        raise NameTooLongError(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "addressed-october",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# handling validation errors\n",
    "def handle_validation_error_custom(err):\n",
    "    return (\n",
    "        f'Class : {err.__class__}\\n'\n",
    "        f'Input parameter that caused error : {err.name}\\n'\n",
    "        f'Exception message : {err.message}\\n'\n",
    "        f'Doc string : {err.__doc__}'\n",
    "    )\n",
    "\n",
    "def handle_err(err):\n",
    "    raise err"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "arranged-acquisition",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class : <class '__main__.NameTooShortError'>\n",
      "Input parameter that caused error : joe\n",
      "Exception message : Input is too small\n",
      "Doc string : Raised when the input is too small\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    validate('joe')\n",
    "    \n",
    "except BaseValidationError as err:\n",
    "    print(handle_validation_error_custom(err)) # customized error message with no traceback\n",
    "#     handle_err(err) # generic option that shows traceback"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "touched-wireless",
   "metadata": {},
   "source": [
    "___\n",
    "## 4.4 Cloning Objects for Fun and Profit\n",
    "\n",
    "Assignment statements in Python do not create copies of objects, they only bind names to an object. For mutable objects, you might be looking for a way to create \"real copies\" or \"clones\" of these objects. \n",
    "\n",
    "### Key Takeaways\n",
    "* Making a **shallow copy** of an object **won’t clone child objects**.\n",
    "Therefore, the copy is not fully independent of the original.\n",
    "* A **deep copy** of an object will **recursively clone child objects**. The\n",
    "clone is fully independent of the original, but creating a deep\n",
    "copy is slower.\n",
    "* You can copy arbitrary objects (including custom classes) with the ```copy``` module.\n",
    "* Objects can control how they are copied by defining dunder methods ```__copy__``` and ```__deepcopy__```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fiscal-chaos",
   "metadata": {},
   "source": [
    "Python's built-in mutable collections like lists, dicts, and sets can be copied by calling their factory functions on an existing collection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "corrected-finder",
   "metadata": {},
   "outputs": [],
   "source": [
    "original_list = [1,2,3]\n",
    "original_dict = {\n",
    "    'Name' : 'Max',\n",
    "    'age' : 40\n",
    "}\n",
    "original_set = set([1,23,23,4])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "raised-management",
   "metadata": {},
   "source": [
    "All we have to do is call their factory functions. However, this will not work for *custom objects*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "annoying-operations",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_list = list(original_list)\n",
    "new_dict = dict(original_dict)\n",
    "new_set = set(original_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "referenced-pulse",
   "metadata": {},
   "source": [
    "### Shallow vs deep copies\n",
    "\n",
    "#### SHALLOW - ONE LEVEL DEEP\n",
    "A **shallow** copy means constructing a new collection object and then populating it with **references to the child objects** found in the original.\n",
    "\n",
    "#### DEEP - RECURSIVE \n",
    "This process means constructing a new collection object and then recursively populating it with copies of the child objects found in the original. Copying an object this way walks the whole object tree to create a **fully independent clone of the original object and all of it's children**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "educational-showcase",
   "metadata": {},
   "source": [
    "### Making shallow copies "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "stainless-witch",
   "metadata": {},
   "outputs": [],
   "source": [
    "xs = [[1,2,3], [4,5,6], [7,8,9]]\n",
    "ys = list(xs) # shallow copy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "laden-conference",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xs.append(['new sublist'])\n",
    "xs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "polar-ultimate",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ys"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "executed-arrangement",
   "metadata": {},
   "source": [
    "#### The problem with shallow copies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "vital-hawaii",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], ['X', 5, 6], [7, 8, 9], ['new sublist']]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We only copied references to the children \n",
    "xs[1][0] = 'X'\n",
    "xs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "chicken-failure",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], ['X', 5, 6], [7, 8, 9]]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ys"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "pending-august",
   "metadata": {},
   "source": [
    "### Making Deep Copies\n",
    "\n",
    "We can make use of the ```copy``` module that has:\n",
    "\n",
    "* ```copy.copy()``` shallow copies (useful for explicit use) \n",
    "* ```copy.deepcopy``` deep copies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "joint-complement",
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy \n",
    "xs = [[1,2,3],[4,5,6],[7,8,9]]\n",
    "zs = copy.deepcopy(xs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "adult-diagram",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "imperial-cassette",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "comic-quarter",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we recusively copy the whole hierachy\n",
    "xs[1][0] = 'X'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "retained-evanescence",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], ['X', 5, 6], [7, 8, 9]]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "detected-bookmark",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we see the problem with the shallow copy is gone\n",
    "zs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "forced-statement",
   "metadata": {},
   "source": [
    "### Copying Arbitrary Objects\n",
    "\n",
    "The ```copy``` module comes to the rescue when copying **custom classes** and **arbitary objects**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "exact-solomon",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f'Point({self.x!r}, {self.y!r})'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "approved-explorer",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = Point(23, 42)\n",
    "# make a shallow clone\n",
    "b = copy.copy(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "unlimited-marsh",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(23, 42)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "other-deposit",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(23, 42)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "typical-eclipse",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# shallow clone as expected returns false\n",
    "a is b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "decreased-marine",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# deepcopy also returns false as it's not the same object\n",
    "c = copy.deepcopy(a)\n",
    "c is a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "russian-lawsuit",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# as expected the reference returns true\n",
    "d = a\n",
    "d is a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "serial-memorial",
   "metadata": {},
   "source": [
    "#### More complicated example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "pressed-present",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, topleft, bottomright):\n",
    "        self.topleft = topleft\n",
    "        self.bottomright = bottomright\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return (f'Rectangle({self.topleft!r}, '\n",
    "                f'{self.bottomright!r})')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "cardiovascular-silly",
   "metadata": {},
   "outputs": [],
   "source": [
    "rect = Rectangle(Point(0, 1), Point(5, 6))\n",
    "scopy_rect = copy.copy(rect)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "planned-headset",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Rectangle(Point(0, 1), Point(5, 6))"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "dense-emerald",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Rectangle(Point(0, 1), Point(5, 6))"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scopy_rect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "round-bhutan",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scopy_rect is rect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "level-private",
   "metadata": {},
   "outputs": [],
   "source": [
    "# this will change the shallow copy\n",
    "rect.topleft.x = 999"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "behavioral-dancing",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Rectangle(Point(999, 1), Point(5, 6))"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# another illustration of problems with shallow copies\n",
    "scopy_rect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "grand-shame",
   "metadata": {},
   "outputs": [],
   "source": [
    "rect = Rectangle(Point(0, 1), Point(5, 6))\n",
    "scopy_rect = copy.copy(rect)\n",
    "dcopy_rect = copy.deepcopy(rect)\n",
    "rect.topleft.x  = 222"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "stable-kentucky",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Rectangle(Point(0, 1), Point(5, 6))"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the deep copy is fully independent to scopy_rect and rect\n",
    "dcopy_rect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "excessive-transition",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Rectangle(Point(222, 1), Point(5, 6))"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "tight-clause",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Rectangle(Point(222, 1), Point(5, 6))"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scopy_rect"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "later-breathing",
   "metadata": {},
   "source": [
    "### Controlling how objects are copied\n",
    "\n",
    "#### References\n",
    "* https://pymotw.com/2/copy/ \n",
    "* https://stackoverflow.com/questions/1500718/how-to-override-the-copy-deepcopy-operations-for-a-python-object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "collect-consciousness",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "init\n",
      "[__copy__]\n",
      "Pointer to the original\n",
      "[__deepcopy__]\n",
      "Recursively copied\n"
     ]
    }
   ],
   "source": [
    "from copy import copy, deepcopy\n",
    "\n",
    "class A(object):\n",
    "    def __init__(self):\n",
    "        print('init')\n",
    "        self.number = 10\n",
    "        self.lst = [2,3,4]\n",
    "\n",
    "    def __copy__(self):\n",
    "        print('[__copy__]')\n",
    "        print('Pointer to the original')\n",
    "        \n",
    "        # get the class\n",
    "        cls = self.__class__\n",
    "        \n",
    "        # make a new class instance\n",
    "        result = cls.__new__(cls)\n",
    "        # shallow copy __dict__ from this class and update result\n",
    "        result.__dict__.update(self.__dict__)\n",
    "        return result\n",
    "\n",
    "    def __deepcopy__(self, memo):\n",
    "        print('[__deepcopy__]')\n",
    "        print('Recursively copied')\n",
    "        \n",
    "        # get the class\n",
    "        cls = self.__class__\n",
    "        \n",
    "        # essentially calling the constructor of the class\n",
    "        result = cls.__new__(cls)\n",
    "        memo[id(self)] = result\n",
    "        for k, v in self.__dict__.items():\n",
    "            setattr(result, k, deepcopy(v, memo))\n",
    "        return result\n",
    "\n",
    "a = A()\n",
    "\n",
    "shallow_copy_a, deepcopy_a = copy(a), deepcopy(a)\n",
    "\n",
    "# notice the shallow copy correctly clones the children one level deep\n",
    "a.number = 12\n",
    "a.lst.append(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "norman-drunk",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12 [2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "print(a.number, a.lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "fancy-thirty",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 [2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# b1 is a shallow copy\n",
    "print(shallow_copy_a.number, shallow_copy_a.lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "clinical-digit",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 [2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# b2 is the shallow copy so z\n",
    "print(deepcopy_a.number, deepcopy_a.lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "later-failing",
   "metadata": {},
   "source": [
    "___\n",
    "## 4.5 Abstract Base Classes Keep Inheritance in Check"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fourth-lotus",
   "metadata": {},
   "source": [
    "Abstract Base Classes (ABCs) ensure that derived classes implement particular methods from **the base class**. We make use of the ```abc``` module. Essentially this will help you adhere to the *Liskov Subsitution Principle* (LISP) and ensure you avoid interfacing problems.\n",
    "\n",
    "### Summary \n",
    "\n",
    "* Abstract Base Classes (ABCs) ensure that derived classes implement particular methods from the base class at instantiation\n",
    "time.\n",
    "* Using ABCs can help avoid bugs and make class hierarchies easier to maintain.\n",
    "* It makes the **interface explicit**\n",
    "\n",
    "Reference: https://docs.python.org/3/library/abc.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "modern-administrator",
   "metadata": {},
   "outputs": [],
   "source": [
    "# custom job\n",
    "class Base:\n",
    "    def foo(self):\n",
    "        raise NotImplementedError()\n",
    "    \n",
    "    def bar(self):\n",
    "        raise NotImplementedError()\n",
    "\n",
    "class Concrete(Base):\n",
    "    def foo(self):\n",
    "        return 'foo() called'\n",
    "    \n",
    "    # bar has not be implemented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "contrary-baking",
   "metadata": {},
   "outputs": [
    {
     "ename": "NotImplementedError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-81-63ceaf52023e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mBase\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[0mb\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfoo\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[0m",
      "\u001b[1;32m<ipython-input-80-144b838160a6>\u001b[0m in \u001b[0;36mfoo\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mclass\u001b[0m \u001b[0mBase\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mfoo\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\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----> 4\u001b[1;33m         \u001b[1;32mraise\u001b[0m \u001b[0mNotImplementedError\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[0m\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mbar\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\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;31mNotImplementedError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "b = Base()\n",
    "b.foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "intermediate-metro",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'foo() called'"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = Concrete()\n",
    "c.foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "independent-checklist",
   "metadata": {},
   "outputs": [
    {
     "ename": "NotImplementedError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-83-e96fccd89134>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mc\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbar\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[0m",
      "\u001b[1;32m<ipython-input-80-144b838160a6>\u001b[0m in \u001b[0;36mbar\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mbar\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\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----> 7\u001b[1;33m         \u001b[1;32mraise\u001b[0m \u001b[0mNotImplementedError\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[0m\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[1;32mclass\u001b[0m \u001b[0mConcrete\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mBase\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;31mNotImplementedError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "c.bar()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "robust-wrestling",
   "metadata": {},
   "source": [
    "This first implementation has some downsides which are:\n",
    "\n",
    "* instantiate ```Base``` without getting an error\n",
    "* provide incomplete subclasses - instantiating ```Concrete``` will not raise an error **until we call** the missing method ```bar()```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "upper-refund",
   "metadata": {},
   "source": [
    "### Using the ```abc``` module\n",
    "\n",
    "* Subclasses of ```Base``` raise a ```TypeError``` at **instantiation time** whenever we forget to implement any abstract methods.\n",
    "* This makes it **more difficult to write invalid subclasses** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "starting-valve",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABCMeta, abstractmethod\n",
    "\n",
    "class Base(metaclass=ABCMeta):\n",
    "    @abstractmethod\n",
    "    def foo(self):\n",
    "        pass\n",
    "    \n",
    "    @abstractmethod\n",
    "    def bar(self):\n",
    "        pass\n",
    "    \n",
    "class Concrete(Base):\n",
    "    def foo(self):\n",
    "        pass\n",
    "    \n",
    "    # bar not implemented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "several-lithuania",
   "metadata": {},
   "outputs": [],
   "source": [
    "# class hierachy is preserved\n",
    "assert issubclass(Concrete, Base)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "prescription-corruption",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Can't instantiate abstract class Concrete with abstract methods bar",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-86-42108369abf3>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# we get a TypeError on instantiation\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[0mc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mConcrete\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[0m",
      "\u001b[1;31mTypeError\u001b[0m: Can't instantiate abstract class Concrete with abstract methods bar"
     ]
    }
   ],
   "source": [
    "# we get a TypeError on instantiation\n",
    "c = Concrete()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "known-turner",
   "metadata": {},
   "source": [
    "___\n",
    "## 4.6 What Namedtuples are Good for\n",
    "\n",
    "Python comes with a specialized \"namedtuple\" container that can be a **great alternative to defining a class manually**. They can be viewed as an extension of the built-in ```tuple``` data type.\n",
    "\n",
    "They can be thought of as a **memory efficient shortcut to defining an immutable class in Python manually**.\n",
    "\n",
    "### Summary\n",
    "* ```collection.namedtuple``` is a memory-efficient shortcut to\n",
    "manually define an immutable class in Python.\n",
    "* Namedtuples can help clean up your code by enforcing an\n",
    "easier-to-understand structure on your data.\n",
    "* Namedtuples provide a few useful helper methods that all start\n",
    "with a single underscore, but are part of the public interface.\n",
    "\n",
    "### When to use them?\n",
    "\n",
    "* They can enforce better structure for your data\n",
    "* They make the data being passed around \"self-documenting\"\n",
    "* Don't use them if they make code less readable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "sufficient-credit",
   "metadata": {},
   "outputs": [],
   "source": [
    "tup = ('hello', object(), 42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "comparable-password",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('hello', <object at 0x202bb4581e0>, 42)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "declared-country",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "shaped-mortgage",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-90-0bbb7d46192a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtup\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m23\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "tup[2] = 23"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "downtown-johnson",
   "metadata": {},
   "source": [
    "One downside of plain tuples is that the data can only be pulled out by accessing it through integer indexes. You can't give names to individual properties stored in a tuple. Also it's hard to ensure tuples have the same number of fields and the same properties. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cosmetic-algeria",
   "metadata": {},
   "source": [
    "### Namedtuples are alternatives to manual classes\n",
    "\n",
    "* They are immutable containers. \"Write once, read many\" principle\n",
    "* Each object can be accessed through a unique human readable identifier similar to the ```dict``` data type.\n",
    "* However, you can still access the values by their index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "boring-armor",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import namedtuple\n",
    "\n",
    "# 'Car' is the typename\n",
    "# the second field is shorthand for ['color', 'mileage']\n",
    "Car = namedtuple('Car', 'color mileage')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "innocent-royal",
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is the equivalent \n",
    "Car = namedtuple('Car', [\n",
    "    'color',\n",
    "    'mileage'\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "typical-sociology",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'red'"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_car = Car('red', 3812.4)\n",
    "my_car.color"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "radio-frame",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3812.4"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_car.mileage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "executed-margin",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'red'"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_car[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "cooperative-celebration",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('red', 3812.4)"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# convert the namedtuple to an ordinary tuple\n",
    "tuple(my_car)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "sticky-principle",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can also make use of tuple unpacking \n",
    "color, mileage = my_car"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "changing-appraisal",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red 3812.4\n"
     ]
    }
   ],
   "source": [
    "print(color, mileage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "micro-median",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red 3812.4\n"
     ]
    }
   ],
   "source": [
    "print(*my_car)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "economic-reduction",
   "metadata": {},
   "source": [
    "Named tuples have an inbuilt ```__repr__``` method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "constant-emerald",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Car(color='red', mileage=3812.4)"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_car"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "choice-renewal",
   "metadata": {},
   "source": [
    "Note that like tuples they are **immutable**. We can't change the fields once they are set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "intellectual-copying",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "can't set attribute",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-102-ec33fc4aa0e0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# write once, read many principle\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[0mmy_car\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcolor\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'blue'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: can't set attribute"
     ]
    }
   ],
   "source": [
    "# write once, read many principle\n",
    "my_car.color = 'blue'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "convinced-smell",
   "metadata": {},
   "source": [
    "### Subclassing Namedtuples\n",
    "\n",
    "Since they are built on top of regular Python classes, you can even add methods to a namedtuple's class like any other class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "liquid-aquatic",
   "metadata": {},
   "outputs": [],
   "source": [
    "Car = namedtuple('Car', 'color mileage')\n",
    "\n",
    "# more clunky way to subclass a namedtuple\n",
    "class MyCarWithMethods(Car):\n",
    "    \n",
    "    def check_mileage(self):\n",
    "        if self.mileage <= 50000: \n",
    "            return 'relatively new, don\\'t worry about a service just yet'\n",
    "        else:\n",
    "            return 'old, consider a service'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "advance-screen",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = MyCarWithMethods('red', 1234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "backed-surveillance",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"relatively new, don't worry about a service just yet\""
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.check_mileage()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deluxe-chancellor",
   "metadata": {},
   "source": [
    "#### Succinct way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "ancient-parcel",
   "metadata": {},
   "outputs": [],
   "source": [
    "Car = namedtuple('Car', 'color mileage')\n",
    "\n",
    "# here is an extremely succinct way of defining a new subclass\n",
    "ElectricCar = namedtuple('ElectricCar', Car._fields + ('charge',))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "impressive-million",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ElectricCar(color='red', mileage=1234, charge=45.0)"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ElectricCar('red', 1234, 45.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "brave-transmission",
   "metadata": {},
   "source": [
    "### Built-in Helper Methods\n",
    "\n",
    "Besides the ```__fields__``` property each namedtuple provides a few more helper methods. Thier names all start with the ```_``` character. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "advance-projector",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'color': 'red', 'mileage': 3812.4}"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_car._asdict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "thrown-jimmy",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Car(color='blue', mileage=3812.4)"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# creates a shallow copy for replacing some fields\n",
    "my_car._replace(color='blue')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "royal-nitrogen",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Car(color='red', mileage=999)"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the _make method allows us to use iterables to create namedtuple instances\n",
    "Car._make(['red', 999])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "handled-board",
   "metadata": {},
   "source": [
    "___\n",
    "## 4.7 Class vs Instance Variable Pitfalls \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "artistic-electron",
   "metadata": {},
   "source": [
    "### Summary \n",
    "\n",
    "*  **Class variables** are for data shared by all instances of a class.\n",
    "They belong to a class, not a specific instance and are **shared among all instances of a class**.\n",
    "*  **Instance variables** are for data that is **unique to each instance**.\n",
    "They belong to individual object instances and are not shared\n",
    "among the other instances of a class. Each instance variable\n",
    "gets a unique backing store specific to the instance.\n",
    "* Because class variables can be “shadowed” by instance variables of the same name, it’s easy to (accidentally) override\n",
    "class variables in a way that introduces bugs and odd behavior."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "connected-activation",
   "metadata": {},
   "source": [
    "Python's object model distinguishes between **class and instance variables**. \n",
    "\n",
    "**Class variables** are declared inside the class definition (but outside\n",
    "of any instance methods). They’re not tied to any particular instance\n",
    "of a class. Instead, class variables store their contents on the class\n",
    "itself, and all objects created from a particular class share access to the\n",
    "same set of class variables. This means, for example, that modifying\n",
    "a class variable **affects all object instances at the same time**.\n",
    "\n",
    "**Instance variables** are always tied to a particular object instance.\n",
    "Their contents are not stored on the class, but on each individual object created from the class. Therefore, the contents of an instance variable are **completely independent from one object instance to the next**.\n",
    "And so, modifying an instance variable only affects one object instance\n",
    "at a time.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "proof-lecture",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    # typically class variables are assigned here\n",
    "    num_legs = 4\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        # typically instance variables are assigned in the constructor\n",
    "        self.name = name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "bearing-peoples",
   "metadata": {},
   "outputs": [],
   "source": [
    "jack = Dog('Jack')\n",
    "jill = Dog('Jill')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "interior-favor",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Jack', 'Jill')"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# instance variables\n",
    "jack.name, jill.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "modular-revelation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# class variables\n",
    "Dog.num_legs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "pleasant-college",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# equivalent code\n",
    "jack.__class__.num_legs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "north-valuable",
   "metadata": {},
   "source": [
    "#### The central distinction between class and instance variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "vocal-worst",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "type object 'Dog' has no attribute 'name'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-123-56c71a2454e7>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# we can't access the instance variable by querying the class object\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[0mDog\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: type object 'Dog' has no attribute 'name'"
     ]
    }
   ],
   "source": [
    "# we can't access the instance variable by querying the class object\n",
    "Dog.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "korean-dimension",
   "metadata": {},
   "outputs": [],
   "source": [
    "# update all instances\n",
    "Dog.num_legs = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "presidential-river",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6, 6)"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "jack.num_legs, jill.num_legs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "earned-beauty",
   "metadata": {},
   "source": [
    "### Instance variables that shadow class variables \n",
    "**NOTE** : this can let a lot of bugs slip into your programs.\n",
    "\n",
    "* ```jack.num_legs``` shadowed variable\n",
    "* ```jack.__class__.num_legs``` original class variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "progressive-workstation",
   "metadata": {},
   "outputs": [],
   "source": [
    "# shadowing the class variable in the jack instance\n",
    "Dog.num_legs = 4\n",
    "jack.num_legs = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "broad-winner",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6, 4)"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# here we can see a subtle mismatch which can cause hard to trace bugs in your code\n",
    "jack.num_legs, jack.__class__.num_legs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aerial-cedar",
   "metadata": {},
   "source": [
    "### A Useful application of class variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "hydraulic-sister",
   "metadata": {},
   "outputs": [],
   "source": [
    "# notice that this doesn't work when you shadow class variables like before\n",
    "class CountedObject:\n",
    "    num_instances = 0\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.__class__.num_instances += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "regional-investment",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CountedObject.num_instances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "improved-launch",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CountedObject().num_instances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "speaking-church",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CountedObject().num_instances"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "anonymous-encoding",
   "metadata": {},
   "source": [
    "### You will often see this mistake due to class variable shadowing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "pretty-campaign",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CountedObject:\n",
    "    num_instances = 0\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.num_instances += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "freelance-basic",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CountedObject().num_instances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "nuclear-sudan",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CountedObject().num_instances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "suspected-microphone",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CountedObject.num_instances"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "advisory-figure",
   "metadata": {},
   "source": [
    "___\n",
    "## 4.8 Instance, Class, and Static Methods Demystified\n",
    "\n",
    "### Summary \n",
    "* **Instance methods** need a class instance and can access the instance through ```self```.\n",
    "* **Class methods** don’t need a class instance. **They can’t access** the\n",
    "instance (```self```) but they **have access to the class** itself via ```cls```.\n",
    "* **Static methods** don't have access to ```cls``` or ```self```. They belong to the **class' namespace** and work like **regular functions**\n",
    "* Static and class methods communicate and can enforce developer intent about class design. This can have **maintenance benefits**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "assured-vegetarian",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def method(self):\n",
    "        return 'instance method called', self\n",
    "    \n",
    "    @classmethod\n",
    "    def classmethod(cls):\n",
    "        return 'class method called', cls\n",
    "    \n",
    "    @staticmethod\n",
    "    def staticmethod():\n",
    "        return 'static method called'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tamil-allowance",
   "metadata": {},
   "source": [
    "### Instance methods\n",
    "\n",
    "```method``` is a regular instance method that we use most of the time. ```self``` points to an instance of ```MyClass``` when the method is called. Through ```self``` these methods can access instance variables and other methods. They can **modify object state**, and they can access the class itself through ```self.__class__```. This means they can also **modify class state**.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "designed-jason",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('instance method called', <__main__.MyClass at 0x202bc674dc0>)"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# syntactic sugar \n",
    "obj = MyClass()\n",
    "obj.method()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "apart-helmet",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('instance method called', <__main__.MyClass at 0x202bc674dc0>)"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# equivalent is that we pass the reference to the instance to the class method\n",
    "MyClass.method(obj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "foster-inside",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "method() missing 1 required positional argument: 'self'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-142-88f17b4fa117>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mMyClass\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmethod\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[0m",
      "\u001b[1;31mTypeError\u001b[0m: method() missing 1 required positional argument: 'self'"
     ]
    }
   ],
   "source": [
    "MyClass.method()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "spoken-chicago",
   "metadata": {},
   "source": [
    "### Class Methods \n",
    "\n",
    "They take a ```cls``` parameter that points to the class and not the object instance when the method is called. It cannot modify object instance state. They **can modify class state** that applies across all instances of the class. They can be used as **alternative constructors**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "correct-forth",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('class method called', __main__.MyClass)"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# as noted it can only access the class state\n",
    "obj.classmethod()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "lucky-alliance",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('class method called', __main__.MyClass)"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we don't need to create an object it can be used as an alternative constructor\n",
    "MyClass.classmethod()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "missing-cycling",
   "metadata": {},
   "source": [
    "### Static Methods\n",
    "\n",
    "This method doesn't take a ```self``` or a ```cls``` parameter, although, it can be made to accept other parameters. As a result **they cannot modify object or class state**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "minus-blink",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'static method called'"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# these can be useful as auxiliary functions in the classes' namespace\n",
    "obj.staticmethod()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "numerous-while",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'static method called'"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# no need to create the object\n",
    "MyClass.staticmethod()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "modular-aircraft",
   "metadata": {},
   "source": [
    "### Example showing the uses of ```@classmethod```\n",
    "\n",
    "They can be used as an **alternative constructor**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "after-recipe",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pizza:\n",
    "    def __init__(self, ingredients):\n",
    "        self.ingredients = ingredients\n",
    "    def __repr__(self):\n",
    "        return f'Pizza({self.ingredients!r})'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "meaning-creature",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(['mozzarella', 'tomatoes'])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza(['mozzarella', 'tomatoes'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "furnished-painting",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(['mozzarella', 'tomatoes', 'ham', 'mushrooms'])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza(['mozzarella', 'tomatoes', 'ham', 'mushrooms'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "special-matrix",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(['mozzarella', 'mozzarella', 'mozzarella', 'mozzarella'])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza(['mozzarella'] * 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "opened-algebra",
   "metadata": {},
   "source": [
    "#### This shows the power of using ```@classmethods```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "invisible-thursday",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pizza:\n",
    "    def __init__(self, ingredients):\n",
    "        self.ingredients = ingredients\n",
    "    def __repr__(self):\n",
    "        return f'Pizza({self.ingredients!r})'\n",
    "\n",
    "    @classmethod\n",
    "    def cheezy(cls):\n",
    "        return cls(['mozzarella']*4)\n",
    "    \n",
    "    @classmethod\n",
    "    def prosciutto(cls):\n",
    "        return cls(['mozzarella', 'tomatoes', 'ham'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "vanilla-planning",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(['mozzarella', 'mozzarella', 'mozzarella', 'mozzarella'])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza.cheezy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "victorian-component",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(['mozzarella', 'tomatoes', 'ham'])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza.prosciutto()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "central-shepherd",
   "metadata": {},
   "source": [
    "### When to use static methods\n",
    "\n",
    "Since you don't need to create an object this means you can reach inside the class and use the ```@staticmethod``` like an auxiliary function. ```@staticmethods``` also **makes your code easier to test**.\n",
    "\n",
    "**It does not modify class or object state!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "static-chocolate",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "class Pizza:\n",
    "    def __init__(self, radius, ingredients):\n",
    "        self.radius = radius\n",
    "        self.ingredients = ingredients\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return (f'Pizza({self.radius!r}, '\n",
    "        f'{self.ingredients!r})')\n",
    "    \n",
    "    def area(self):\n",
    "        return self.circle_area(self.radius)\n",
    "    \n",
    "    # this means we can use it outside the class aswell\n",
    "    @staticmethod\n",
    "    def circle_area(r):\n",
    "        return r ** 2 * math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "decreased-cement",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(4, ['mozzarella', 'tomatoes'])"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = Pizza(4, ['mozzarella', 'tomatoes'])\n",
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "retired-march",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50.26548245743669"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# in this area function we pass self.radius to the static method\n",
    "p.area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "informal-consistency",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50.26548245743669"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# here we pass an arbitrary parameter\n",
    "# we don't have to create the object and we don't affect state\n",
    "\n",
    "Pizza.circle_area(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "desperate-turtle",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1256.6370614359173"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza.circle_area(20)"
   ]
  }
 ],
 "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
}