Notebooks/09_Classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python  \n",
    "\n",
    "## [Classes](https://docs.python.org/3/tutorial/classes.html) and OOP\n",
    "\n",
    "\n",
    "+ Classes provide means of bundling data and functionality together.  \n",
    "+ Creating a new class is equivalent to creating a new type of object, allowing new instances of that type to be made.  \n",
    "+ Each class instance can have attributes attached to it for maintaining its state.  \n",
    "+ Class instances can also have methods for modifying its state.  \n",
    "\n",
    "#### The class signature is:\n",
    "\n",
    "    class ClassName(Superclass - optional):\n",
    "        <statement-1>\n",
    "        .\n",
    "        .\n",
    "        .\n",
    "        <statement-N>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's start with an example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    \"\"\"\n",
    "    class documentation string\n",
    "    \"\"\"\n",
    "    \n",
    "    class_attribute1 = 1234\n",
    "    class_attribute2 = 5678\n",
    "    \n",
    "    def class_method(self):\n",
    "        return 'Hello!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'type'>\n"
     ]
    }
   ],
   "source": [
    "print(type(MyClass))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = MyClass()\n",
    "y = MyClass()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.MyClass'>\n"
     ]
    }
   ],
   "source": [
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.MyClass'>\n"
     ]
    }
   ],
   "source": [
    "print(type(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'class_attribute1',\n",
       " 'class_attribute2',\n",
       " 'class_method']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8754036884727\n",
      "8754036884538\n"
     ]
    }
   ],
   "source": [
    "print(x.__hash__())\n",
    "print(y.__hash__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1234"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.class_attribute1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5678"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.class_attribute2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello!'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.class_method()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.class_attribute1 = 4321"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4321"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.class_attribute1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1234"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.class_attribute1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.new_attribute = \"any new attribute\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = [1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'class_attribute1',\n",
       " 'class_attribute2',\n",
       " 'class_method',\n",
       " 'new_attribute']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'class_attribute1',\n",
       " 'class_attribute2',\n",
       " 'class_method']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Another example, with __init__() method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyComplex:\n",
    "    def __init__(self, realpart, imagpart):\n",
    "        self.r = realpart\n",
    "        self.i = imagpart\n",
    "        print(\"__init__ has run\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__init__ has run\n"
     ]
    }
   ],
   "source": [
    "z = MyComplex(2,-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__init__ has run\n"
     ]
    }
   ],
   "source": [
    "j = MyComplex(13,12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'i',\n",
       " 'r']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "        self.area = width * height\n",
    "        self.perimeter = 2 * (width+height)\n",
    "        if width < height:\n",
    "            self.invert_sides()\n",
    "            \n",
    "    def invert_sides(self):\n",
    "        self.width, self.height = self.height, self.width\n",
    "        print('inverted height and width')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_rectangle = Rectangle(50,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "print(my_rectangle.width)\n",
    "print(my_rectangle.height)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "500\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "print(my_rectangle.area)\n",
    "print(my_rectangle.perimeter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inverted height and width\n"
     ]
    }
   ],
   "source": [
    "my_rectangle.invert_sides()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "print(my_rectangle.width)\n",
    "print(my_rectangle.height)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'area',\n",
       " 'height',\n",
       " 'invert_sides',\n",
       " 'perimeter',\n",
       " 'width']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(my_rectangle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What is printed when we call the \"print\" primitive in an object?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<__main__.Rectangle object at 0x7fc39c6df990>'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_rectangle.__repr__()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### _print()_ calls the internal __repr__() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Rectangle object at 0x7f6354250bb0>\n"
     ]
    }
   ],
   "source": [
    "print(my_rectangle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Another class example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Triangle:\n",
    "    def __init__(self, side1, side2, side3):\n",
    "        self.side1 = side1\n",
    "        self.side2 = side2\n",
    "        self.side3 = side3\n",
    "        print('running __init__\\n')\n",
    "        self.type_of_triangle()\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f\"I am a Triangle with sides {self.side1}, {self.side2} and {self.side3}\"\n",
    "        \n",
    "    #def __repr__(self):\n",
    "    #    return \"42\"\n",
    "        \n",
    "    def type_of_triangle(self):\n",
    "        if self.side1 == self.side2 and self.side1 == self.side3:\n",
    "            print('I am equilateral')\n",
    "            self.mytype = 'equilateral'\n",
    "        elif self.side1 == self.side2 or \\\n",
    "             self.side1 == self.side3 or \\\n",
    "             self.side2 == self.side3:\n",
    "            print('I am isosceles')\n",
    "            self.mytype = 'isosceles'\n",
    "        else:\n",
    "            print('I am scalene')\n",
    "            self.mytype = 'scalene'\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running __init__\n",
      "\n",
      "I am equilateral\n"
     ]
    }
   ],
   "source": [
    "tri = Triangle(5,5,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running __init__\n",
      "\n",
      "I am isosceles\n"
     ]
    }
   ],
   "source": [
    "tri.__init__(5,4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "isosceles\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "print(tri.mytype)\n",
    "print(tri.side1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am isosceles\n"
     ]
    }
   ],
   "source": [
    "tri.type_of_triangle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a Triangle with sides 5, 4 and 5\n"
     ]
    }
   ],
   "source": [
    "print(tri)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'mytype',\n",
       " 'side1',\n",
       " 'side2',\n",
       " 'side3',\n",
       " 'type_of_triangle']"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(tri)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Special Methods for Classes](https://docs.python.org/3/reference/datamodel.html#special-method-names)  \n",
    "\n",
    "[examples](https://www.pythonlikeyoumeanit.com/Module4_OOP/Special_Methods.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "x[key] = item<table class=\"docutils align-default\">\n",
    "<colgroup>\n",
    "<col style=\"width: 33%\">\n",
    "<col style=\"width: 33%\">\n",
    "<col style=\"width: 33%\">\n",
    "</colgroup>\n",
    "<thead>\n",
    "<tr class=\"row-odd\"><th class=\"head\"><p>Method</p></th>\n",
    "<th class=\"head\"><p>Signature</p></th>\n",
    "<th class=\"head\"><p>Explanation</p></th>\n",
    "</tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "<tr class=\"row-even\"><td><p>Returns string for a printable representation of object</p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">__repr__(self)</span></code></p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">repr(x)</span></code> invokes <code class=\"docutils literal notranslate\"><span class=\"pre\">x.__repr__()</span></code>, this is also invoked when an object is returned by a console</p></td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><p>Returns string representation of an object</p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">__str__(self)</span></code></p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">str(x)</span></code> invokes <code class=\"docutils literal notranslate\"><span class=\"pre\">x.__str__()</span></code></p></td>\n",
    "</tr>\n",
    "</tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table class=\"docutils align-default\">\n",
    "<colgroup>\n",
    "<col style=\"width: 13%\">\n",
    "<col style=\"width: 38%\">\n",
    "<col style=\"width: 50%\">\n",
    "</colgroup>\n",
    "<thead>\n",
    "<tr class=\"row-odd\"><th class=\"head\"><p>Method</p></th>\n",
    "<th class=\"head\"><p>Signature</p></th>\n",
    "<th class=\"head\"><p>Explanation</p></th>\n",
    "</tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "<tr class=\"row-even\"><td><p>Add</p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">__add__(self,</span> <span class=\"pre\">other)</span></code></p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">x</span> <span class=\"pre\">+</span> <span class=\"pre\">y</span></code> invokes <code class=\"docutils literal notranslate\"><span class=\"pre\">x.__add__(y)</span></code></p></td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><p>Subtract</p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">__sub__(self,</span> <span class=\"pre\">other)</span></code></p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">x</span> <span class=\"pre\">-</span> <span class=\"pre\">y</span></code> invokes <code class=\"docutils literal notranslate\"><span class=\"pre\">x.__sub__(y)</span></code></p></td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td><p>Multiply</p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">__mul__(self,</span> <span class=\"pre\">other)</span></code></p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">x</span> <span class=\"pre\">*</span> <span class=\"pre\">y</span></code> invokes <code class=\"docutils literal notranslate\"><span class=\"pre\">x.__mul__(y)</span></code></p></td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><p>Divide</p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">__truediv__(self,</span> <span class=\"pre\">other)</span></code></p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">x</span> <span class=\"pre\">/</span> <span class=\"pre\">y</span></code> invokes <code class=\"docutils literal notranslate\"><span class=\"pre\">x.__truediv__(y)</span></code></p></td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td><p>Power</p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">__pow__(self,</span> <span class=\"pre\">other)</span></code></p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">x</span> <span class=\"pre\">**</span> <span class=\"pre\">y</span></code> invokes <code class=\"docutils literal notranslate\"><span class=\"pre\">x.__pow__(y)</span></code></p></td>\n",
    "</tr>\n",
    "</tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table class=\"docutils align-default\">\n",
    "<colgroup>\n",
    "<col style=\"width: 33%\">\n",
    "<col style=\"width: 33%\">\n",
    "<col style=\"width: 33%\">\n",
    "</colgroup>\n",
    "<thead>\n",
    "<tr class=\"row-odd\"><th class=\"head\"><p>Method</p></th>\n",
    "<th class=\"head\"><p>Signature</p></th>\n",
    "<th class=\"head\"><p>Explanation</p></th>\n",
    "</tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "<tr class=\"row-even\"><td><p>Length</p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">__len__(self)</span></code></p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">len(x)</span></code> invokes <code class=\"docutils literal notranslate\"><span class=\"pre\">x.__len__()</span></code></p></td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><p>Get Item</p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">__getitem__(self,</span> <span class=\"pre\">key)</span></code></p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">x[key]</span></code> invokes <code class=\"docutils literal notranslate\"><span class=\"pre\">x.__getitem__(key)</span></code></p></td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td><p>Set Item</p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">__setitem__(self,</span> <span class=\"pre\">key,</span> <span class=\"pre\">item)</span></code></p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">x[key]</span> <span class=\"pre\">=</span> <span class=\"pre\">item</span></code> invokes <code class=\"docutils literal notranslate\"><span class=\"pre\">x.__setitem__(key,</span> <span class=\"pre\">item)</span></code></p></td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><p>Contains</p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">__contains__(self,</span> <span class=\"pre\">item)</span></code></p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">item</span> <span class=\"pre\">in</span> <span class=\"pre\">x</span></code> invokes <code class=\"docutils literal notranslate\"><span class=\"pre\">x.__contains__(item)</span></code></p></td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td><p>Iterator</p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">__iter__(self)</span></code></p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">iter(x)</span></code> invokes <code class=\"docutils literal notranslate\"><span class=\"pre\">x.__iter__()</span></code></p></td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td><p>Next</p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">__next__(self)</span></code></p></td>\n",
    "<td><p><code class=\"docutils literal notranslate\"><span class=\"pre\">next(x)</span></code> invokes <code class=\"docutils literal notranslate\"><span class=\"pre\">x.__next__()</span></code></p></td>\n",
    "</tr>\n",
    "</tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operator overloading __gt__ (>) and __lt__ (<)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Thing:\n",
    "    def __init__(self, value):\n",
    "        self.__value = value\n",
    "        \n",
    "    def __gt__(self, other):\n",
    "        return self.__value > other.__value\n",
    "    \n",
    "    def __lt__(self, other):\n",
    "        return self.__value < other.__value\n",
    "    \n",
    "something = Thing(100)\n",
    "nothing = Thing(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "something > nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "something < nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'Thing' and 'Thing'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-43-5fbac983769e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msomething\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnothing\u001b[0m \u001b[0;31m# erro\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'Thing' and 'Thing'"
     ]
    }
   ],
   "source": [
    "something + nothing # erro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Thing:\n",
    "    def __init__(self, value):\n",
    "        self.__value = value\n",
    "        \n",
    "    def __gt__(self, other):\n",
    "        return self.__value > other.__value\n",
    "    \n",
    "    def __lt__(self, other):\n",
    "        return self.__value < other.__value\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        return self.__value + other.__value\n",
    "    \n",
    "something = Thing(100)\n",
    "nothing = Thing(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "something + nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nothing + something"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Class inheritance](https://medium.com/swlh/classes-subclasses-in-python-12b6013d9f3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    def __init__(self, name, race='Royal Street Dog'):\n",
    "        self.name = name\n",
    "        self.race = race\n",
    "        self.tricks = []\n",
    "\n",
    "    def add_trick(self, trick):\n",
    "        if not trick in self.tricks:\n",
    "            self.tricks.append(trick.title())\n",
    "        else:\n",
    "            print('I have learnt that already!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = Dog('Fido','German Shepherd')\n",
    "e = Dog('Buddy','Cocker')\n",
    "f = Dog('Rex')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fido\n",
      "German Shepherd\n",
      "Buddy\n",
      "Cocker\n",
      "Rex\n",
      "Royal Street Dog\n"
     ]
    }
   ],
   "source": [
    "print(d.name)\n",
    "print(d.race)\n",
    "print(e.name)\n",
    "print(e.race)\n",
    "print(f.name)\n",
    "print(f.race)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.add_trick('Roll')\n",
    "d.add_trick('Pretending dead')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Roll', 'Pretending Dead']"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.tricks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.add_trick('Ask for food')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Roll', 'Pretending Dead', 'Ask For Food']"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.tricks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e.tricks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Bark']"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.add_trick('Bark')\n",
    "f.tricks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a subclass using inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "class SuperDog(Dog):\n",
    "    \n",
    "    def __init__(self, name, race):\n",
    "        Dog.__init__(self, name, race)\n",
    "        self.food = False\n",
    "        self.trained = False\n",
    "        self.last_meal = time.time()\n",
    "        \n",
    "    def is_hungry(self):\n",
    "        if time.time() - self.last_meal < 20:\n",
    "            print('Not hungry')\n",
    "        else:\n",
    "            print(f'Yes, my last meal was {(time.time() - self.last_meal)/60:.2f} min. ago')\n",
    "    \n",
    "    def train(self):\n",
    "        self.trained = True\n",
    "    \n",
    "    def feed(self):\n",
    "        self.last_meal = time.time()\n",
    "        print('The food was delicious. Thanks!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = SuperDog('Raghu','Labrador')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not hungry\n"
     ]
    }
   ],
   "source": [
    "f.is_hungry()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, my last meal was 0.77 min. ago\n"
     ]
    }
   ],
   "source": [
    "f.is_hungry() #calling after some time..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The food was delicious. Thanks!\n"
     ]
    }
   ],
   "source": [
    "f.feed()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not hungry\n"
     ]
    }
   ],
   "source": [
    "f.is_hungry()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.tricks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.add_trick('Give Five')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Give Five']"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.tricks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.trained"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.trained"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Multiple inheritance](https://www.techbeamers.com/python-multiple-inheritance/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " In class B\n"
     ]
    }
   ],
   "source": [
    "class A: \n",
    "    def rk(self): \n",
    "        print(\" In class A\") \n",
    "        \n",
    "class B(A): \n",
    "    def rk(self): \n",
    "        print(\" In class B\") \n",
    "        \n",
    "class C(A): \n",
    "    def rk(self): \n",
    "        print(\"In class C\") \n",
    "  \n",
    "# classes ordering \n",
    "class D(B, C): \n",
    "    pass\n",
    "     \n",
    "r = D() \n",
    "r.rk() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    def __init__(self, weight=0, height=0):\n",
    "        self.weight = weight\n",
    "        self.height = height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Carnivore(Animal):\n",
    "    def __init__(self, weight=0, height=0):\n",
    "        super().__init__(weight, height)\n",
    "\n",
    "    def say(self):\n",
    "        raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2000"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TRex = Carnivore(2000)\n",
    "TRex.weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Wolf(Carnivore):\n",
    "    def __init__(self, weight, height):\n",
    "        super().__init__(weight, height)\n",
    "        \n",
    "    def say(self):\n",
    "        print(\"Bark! Bark!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "45\n",
      "Bark! Bark!\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "Jack = Wolf(8, 45)\n",
    "print(Jack.weight)\n",
    "print(Jack.height)\n",
    "print(Jack.say())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pet(Animal):\n",
    "    def __init__(self, tutor, weight=0, height=0):\n",
    "        super().__init__(weight, height)\n",
    "        self.tutor = tutor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John\n",
      "35\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "fish = Pet('John', 35)\n",
    "\n",
    "print(fish.tutor)\n",
    "print(fish.weight)\n",
    "print(fish.height)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cat(Carnivore, Pet):\n",
    "    def __init__(self, weight, height, tutor):\n",
    "        super(Carnivore, self).__init__(self, weight, height)\n",
    "        print(self.weight)\n",
    "        print(self.height)\n",
    "        Pet.__init__(self, tutor, self.weight, self.height)\n",
    "        print(self.tutor)\n",
    "        \n",
    "    def say(self):\n",
    "        print(\"Meaw!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[C3 & MRO](https://en.wikipedia.org/wiki/C3_linearization)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(__main__.Cat, __main__.Carnivore, __main__.Pet, __main__.Animal, object)"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Cat.__mro__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "25\n",
      "John\n"
     ]
    }
   ],
   "source": [
    "Garfield = Cat(4, 25, 'John')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weight: 4\n",
      "Height: 25\n",
      "Tutor: John\n",
      "Meaw!\n"
     ]
    }
   ],
   "source": [
    "print(f\"Weight: {Garfield.weight}\\nHeight: {Garfield.height}\\nTutor: {Garfield.tutor}\")\n",
    "Garfield.say()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifying an existing class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyInteger(int):\n",
    "    def __init__(self,number):\n",
    "        super().__init__() \n",
    "    \n",
    "    def __add__(self,other):\n",
    "        return self * other\n",
    "    \n",
    "    def __sub__(self,other):\n",
    "        return self + other\n",
    "    \n",
    "    def square(self):\n",
    "        return self * self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = MyInteger(2)\n",
    "b = MyInteger(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__abs__',\n",
       " '__add__',\n",
       " '__and__',\n",
       " '__bool__',\n",
       " '__ceil__',\n",
       " '__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__divmod__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__float__',\n",
       " '__floor__',\n",
       " '__floordiv__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__index__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__int__',\n",
       " '__invert__',\n",
       " '__le__',\n",
       " '__lshift__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__module__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__neg__',\n",
       " '__new__',\n",
       " '__or__',\n",
       " '__pos__',\n",
       " '__pow__',\n",
       " '__radd__',\n",
       " '__rand__',\n",
       " '__rdivmod__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rfloordiv__',\n",
       " '__rlshift__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__ror__',\n",
       " '__round__',\n",
       " '__rpow__',\n",
       " '__rrshift__',\n",
       " '__rshift__',\n",
       " '__rsub__',\n",
       " '__rtruediv__',\n",
       " '__rxor__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__sub__',\n",
       " '__subclasshook__',\n",
       " '__truediv__',\n",
       " '__trunc__',\n",
       " '__xor__',\n",
       " 'bit_length',\n",
       " 'conjugate',\n",
       " 'denominator',\n",
       " 'from_bytes',\n",
       " 'imag',\n",
       " 'numerator',\n",
       " 'real',\n",
       " 'square',\n",
       " 'to_bytes']"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + b  #?????"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a - b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.square()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on wrapper_descriptor:\n",
      "\n",
      "__mul__(self, value, /)\n",
      "    Return self*value.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(MyInteger.__mul__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on wrapper_descriptor:\n",
      "\n",
      "__str__(self, /)\n",
      "    Return str(self).\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(MyInteger.__str__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A more complete example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [],
   "source": [
    "def strike(text):\n",
    "    \"\"\" Renders string with strike-through characters through it.\n",
    "\n",
    "        `strike('hello world')` -> '̶h̶e̶l̶l̶o̶ ̶w̶o̶r̶l̶d'\n",
    "\n",
    "        Notes\n",
    "        -----\n",
    "        \\u0336 is a special strike-through unicode character; it\n",
    "        is not unique to Python.\"\"\"\n",
    "    return ''.join('\\u0336{}'.format(c) for c in text)\n",
    "\n",
    "class ShoppingList:\n",
    "    def __init__(self, items):\n",
    "        self._needed = set(items)\n",
    "        self._purchased = set()\n",
    "\n",
    "    def __repr__(self):\n",
    "        \"\"\" Returns formatted shopping list as a string with\n",
    "            purchased items being crossed out.\n",
    "\n",
    "            Returns\n",
    "            -------\n",
    "            str\"\"\"\n",
    "        if self._needed or self._purchased:\n",
    "            remaining_items = [str(i) for i in self._needed]\n",
    "            purchased_items = [strike(str(i)) for i in self._purchased]\n",
    "            # You wont find the • character on your keyboard. I simply\n",
    "            # googled \"unicode bullet point\" and copied/pasted it here.\n",
    "            return \"• \" + \"\\n• \".join(remaining_items + purchased_items)\n",
    "\n",
    "    def add_new_items(self, items):\n",
    "        self._needed.update(items)\n",
    "\n",
    "    def mark_purchased_items(self, items):\n",
    "        self._purchased.update(set(items) & self._needed)\n",
    "        self._needed.difference_update(self._purchased)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "• milk\n",
      "• flour\n",
      "• salt\n",
      "• eggs\n"
     ]
    }
   ],
   "source": [
    "food = ShoppingList([\"milk\", \"flour\", \"salt\", \"eggs\"])\n",
    "print(food)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "• milk\n",
      "• eggs\n",
      "• ̶f̶l̶o̶u̶r\n",
      "• ̶s̶a̶l̶t\n"
     ]
    }
   ],
   "source": [
    "food.mark_purchased_items([\"flour\", \"salt\"])\n",
    "print(food)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [],
   "source": [
    "def __add__(self, other):\n",
    "    \"\"\" Add the unpurchased and purchased items from another shopping\n",
    "        list to the present one.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        other : ShoppingList\n",
    "            The shopping list whose items we will add to the present one.\n",
    "        Returns\n",
    "        -------\n",
    "        ShoppingList\n",
    "            The present shopping list, with items added to it.\"\"\"\n",
    "    new_list = ShoppingList([])\n",
    "    # populate new_list with items from `self` and `other`\n",
    "    for l in [self, other]:\n",
    "        new_list.add_new_items(l._needed)\n",
    "\n",
    "        # add purchased items to list, then mark as purchased\n",
    "        new_list.add_new_items(l._purchased)\n",
    "        new_list.mark_purchased_items(l._purchased)\n",
    "    return new_list\n",
    "\n",
    "# set `__add__` as a method of `ShoppingList`\n",
    "setattr(ShoppingList, \"__add__\", __add__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "• milk\n",
       "• staples\n",
       "• eggs\n",
       "• t-shirts\n",
       "• socks\n",
       "• pens\n",
       "• ̶f̶l̶o̶u̶r\n",
       "• ̶s̶a̶l̶t\n",
       "• ̶p̶e̶n̶c̶i̶l̶s"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "food = ShoppingList([\"milk\", \"flour\", \"salt\", \"eggs\"])\n",
    "food.mark_purchased_items([\"flour\", \"salt\"])\n",
    "\n",
    "office_supplies = ShoppingList([\"staples\", \"pens\", \"pencils\"])\n",
    "office_supplies.mark_purchased_items([\"pencils\"])\n",
    "\n",
    "clothes = ShoppingList([\"t-shirts\", \"socks\"])\n",
    "\n",
    "# combine all three shopping lists\n",
    "food + office_supplies + clothes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyList:\n",
    "    def __init__(self, *args):\n",
    "        if len(args) == 1 and hasattr(args[0], '__iter__'):\n",
    "            # handles `MyList([1, 2, 3])\n",
    "            self._data = list(args[0])\n",
    "        else:\n",
    "            # handles `MyList(1, 2, 3)`\n",
    "            self._data = list(args)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        out = self._data[index]\n",
    "        # slicing should return a `MyList` instance\n",
    "        # otherwise, the individual element should be returned as-is\n",
    "        return MyList(out) if isinstance(index, slice) else out\n",
    "\n",
    "    def __setitem__(self, key, value):\n",
    "        self._data[key] = value\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self._data)\n",
    "\n",
    "    def __repr__(self):\n",
    "        \"\"\" Use the character | as the delimiter for our list\"\"\"\n",
    "        # `self._data.__repr__()` returns '[ ... ]',\n",
    "        # thus we can slice to get the contents of the string\n",
    "        # and exclude the square-brackets, and add our own\n",
    "        # delimiters in their place\n",
    "        return \"|\" + self._data.__repr__()[1:-1] + \"|\"\n",
    "\n",
    "    def __contains__(self, item):\n",
    "        return item in self._data\n",
    "\n",
    "    def append(self, item):\n",
    "        self._data.append(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "|'h', 'e', 'l', 'l', 'o'|"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# MyList can accept any iterable as its\n",
    "# first (and only) input argument\n",
    "x = MyList(\"hello\")\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "|1, 2, 3, 4, 5|"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# MyList accepts an arbitrary number of arguments\n",
    "x = MyList(1, 2, 3, 4, 5)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(len(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# getting an item\n",
    "x[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "|3, 4|"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slicing returns a MyList instance\n",
    "x[2:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "|-1, 2, 3, 4, 5|"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# setting an item\n",
    "x[0] = -1\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# checking membership\n",
    "10 in x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "||"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MyList()"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}