lectures/03_Object_oriented_programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction to Python and Natural Language Technologies\n",
    "\n",
    "__Lecture 03, Object oriented programming__\n",
    "\n",
    "__February 23, 2020__\n",
    "\n",
    "__Judit Ács__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction\n",
    "\n",
    "- Python has been object oriented since its first version\n",
    "- Borrows much of its design from [Smalltalk](https://en.wikipedia.org/wiki/Smalltalk), a 1980 object oriented programming language\n",
    "- Basically everything is an object including\n",
    "  - class definitions\n",
    "  - functions\n",
    "  - modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Defining classes\n",
    "\n",
    "- `class` keyword\n",
    "- Instance explicitly bound to the first parameter of each method\n",
    "  - Named `self` by convention\n",
    "- `__init__` is called after the instance is created\n",
    "  - Not exactly a constructor because the instance already exists\n",
    "  - Not mandatory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClassWithInit:\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    \n",
    "class ClassWithoutInit:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Attributes and methods\n",
    "\n",
    "1. __Data attributes__: these correspond to data members in C++\n",
    "1. __Methods__: these correspond to methods in C++\n",
    "\n",
    "## Data attributes\n",
    "\n",
    "Attributes are created upon assignment which can happen anywhere not just in `__init__`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n",
      "43\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def __init__(self):\n",
    "        self.attr1 = 42\n",
    "        \n",
    "    def method(self):\n",
    "        self.attr2 = 43\n",
    "        \n",
    "a = A()\n",
    "print(a.attr1)\n",
    "# print(a.attr2)  # raises AttributeError\n",
    "a.method()\n",
    "print(a.attr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Attributes can be added to instances:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "a.attr3 = 11\n",
    "print(a.attr3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This will not affect other instances:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({'attr1': 42}, {'attr1': 42, 'attr2': 43, 'attr3': 11})"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a2 = A()\n",
    "#a2.attr3  # raises AttributeError\n",
    "a2.__dict__, a.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`__init__` may have arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class InitWithArguments:\n",
    "    def __init__(self, value, value_with_default=42):\n",
    "        self.attr = value\n",
    "        self.solution_of_the_world = value_with_default\n",
    "        \n",
    "class InitWithVariableNumberOfArguments:\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        self.val1 = args[0]\n",
    "        self.val2 = kwargs.get('important_param', 42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "41 42 1 23\n"
     ]
    }
   ],
   "source": [
    "obj1 = InitWithArguments(41)\n",
    "obj2 = InitWithVariableNumberOfArguments(\n",
    "    1, 2, 3, param4=\"apple\", important_param=23)\n",
    "\n",
    "print(obj1.attr, obj1.solution_of_the_world,\n",
    "      obj2.val1, obj2.val2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Method attributes\n",
    "\n",
    "Functions inside the class definition.\n",
    "\n",
    "They explicitly take the instance as first parameter named `self` by convention:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo called\n",
      "bar called with parameter 42\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def foo(self):\n",
    "        print(\"foo called\")\n",
    "    \n",
    "    def bar(self, param):\n",
    "        print(\"bar called with parameter {}\".format(param))\n",
    "        \n",
    "a = A()\n",
    "a.foo()\n",
    "a.bar(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "__Calling methods__\n",
    "\n",
    "1. `instance.method(param)`\n",
    "2. `class.method(instance, param)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo called\n",
      "foo called\n",
      "bar called with parameter 42\n",
      "bar called with parameter 43\n"
     ]
    }
   ],
   "source": [
    "c = A()\n",
    "\n",
    "c.foo()\n",
    "A.foo(c)\n",
    "\n",
    "c.bar(42)\n",
    "A.bar(c, 43)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Special attributes\n",
    "\n",
    "- Every object has a number of special attributes.\n",
    "- They follow the **double underscore or dunder** notation: `__attribute__`.\n",
    "- Most of them are automatically created.\n",
    "- Advanced OOP features are implemented using these.\n",
    "- **dunder** should be avoided when naming an attribute.\n",
    "\n",
    "\n",
    "**`__dict__`**: implements a class' (module's) namespace:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mappingproxy({'__module__': '__main__',\n",
       "              'foo': <function __main__.A.foo(self)>,\n",
       "              'bar': <function __main__.A.bar(self, param)>,\n",
       "              '__dict__': <attribute '__dict__' of 'A' objects>,\n",
       "              '__weakref__': <attribute '__weakref__' of 'A' objects>,\n",
       "              '__doc__': None})"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'attr1': 42}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a2.__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mappingproxy({'__module__': '__main__',\n",
       "              '__init__': <function __main__.A.__init__(self)>,\n",
       "              'method': <function __main__.A.method(self)>,\n",
       "              '__dict__': <attribute '__dict__' of 'A' objects>,\n",
       "              '__weakref__': <attribute '__weakref__' of 'A' objects>,\n",
       "              '__doc__': None})"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a2.__class__.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Data hiding with name mangling\n",
    "\n",
    "- Every attribute is public by default.\n",
    "- Private attributes can be defined through name mangling.\n",
    "  - Every attribute with at least two leading underscores and at most one trailing underscore is replaced with a mangled attribute.\n",
    "  - Emulates private behavior.\n",
    "  - Mangled name: `__classname_attrname`.\n",
    "- Attributes with one leading underscore should be treated as private."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'_A__private_attr': 43, '_private': 12}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class A:\n",
    "    def __init__(self):\n",
    "        self.__private_attr = 42\n",
    "        # This should be treated as a private variable.\n",
    "        self._private = 12\n",
    "        \n",
    "    def foo(self):\n",
    "        self.__private_attr += 1\n",
    "        \n",
    "a = A()\n",
    "a.foo()\n",
    "#a.__private_attr  # raises AttributeError\n",
    "# a._private = 13  # Considered private\n",
    "a.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not supposed to do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a._A__private_attr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Class attributes\n",
    "\n",
    "- Class attributes are class-global attributes.\n",
    "- Roughly the same as static attributes in C++"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    class_attr = 42"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Accessing class attributes via instances:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1 = A()\n",
    "a1.class_attr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Accessing class attributes via the class object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.class_attr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Setting the class object via the class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42 42\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(43, 43)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1 = A()\n",
    "a2 = A()\n",
    "\n",
    "print(a1.class_attr, a2.class_attr)\n",
    "A.class_attr = 43\n",
    "a1.class_attr, a2.class_attr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "They cannot be set via an instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1 = A()\n",
    "a2 = A()\n",
    "a1.class_attr = 11\n",
    "a2.class_attr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because this assignment creates a new attribute in the *instance's namespace*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'class_attr': 11}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1.__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a2.__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.A"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a2.__class__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mappingproxy({'__module__': '__main__',\n",
       "              'class_attr': 43,\n",
       "              '__dict__': <attribute '__dict__' of 'A' objects>,\n",
       "              '__weakref__': <attribute '__weakref__' of 'A' objects>,\n",
       "              '__doc__': None})"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A.__dict__\n",
    "a2.__class__.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reflection\n",
    "\n",
    "__`getattr`__ gets an attribute by name:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class A:\n",
    "    def __init__(self, value):\n",
    "        self.attr1 = value\n",
    "        \n",
    "getattr(A(12), 'attr1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Missing attributes raise `AttributeError`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# getattr(A(12), 'attr2')  # raises AttributeError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A default can be specified:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'attr2_default'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getattr(A(12), 'attr2', \"attr2_default\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Not found'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# attr_name = input()\n",
    "attr_name = 'attr4'\n",
    "\n",
    "getattr(A(11), attr_name, \"Not found\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__`setattr`__ sets an attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "getattr(a, attr_name) = 15\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'apple': 15}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class A:\n",
    "    pass\n",
    "\n",
    "# attr_name = input(\"Attribute name = \")\n",
    "# attr_value = input(f\"{attr_name} = \")\n",
    "attr_name = 'apple'\n",
    "attr_value = 15\n",
    "\n",
    "a = A()\n",
    "setattr(a, attr_name, attr_value)\n",
    "print(f\"{getattr(a, attr_name) = }\")\n",
    "#print(f\"{a.apple = }\")\n",
    "a.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__`delattr`__ deletes an attribute from the namespace:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'attr1': 1, 'attr2': 2}\n",
      "{'attr2': 2}\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def __init__(self):\n",
    "        self.attr1 = 1\n",
    "        self.attr2 = 2\n",
    "        \n",
    "a = A()\n",
    "print(a.__dict__)\n",
    "\n",
    "delattr(a, 'attr1')\n",
    "print(a.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__`hasattr`__ checks if an attribute is present in the parameter's namespace:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hasattr(a, 'attr1'), hasattr(a, 'attr2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Inheritance\n",
    "\n",
    "Python supports inheritance and multiple inheritance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    pass\n",
    "\n",
    "class B(A):\n",
    "    pass\n",
    "\n",
    "a = A()\n",
    "b = B()\n",
    "print(isinstance(a, B))\n",
    "print(isinstance(b, A))\n",
    "print(issubclass(B, A))\n",
    "print(issubclass(A, B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False, False, True)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(3, int), isinstance(3, float), isinstance(3.0, int), isinstance(3.0, float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python 3 implicitly subclasses `object`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "class A: pass\n",
    "class B(object): pass\n",
    "\n",
    "print(issubclass(A, object))\n",
    "print(issubclass(B, object))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Method inheritance__\n",
    "\n",
    "Methods are inherited and overridden in the usual way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B.foo was called\n",
      "A.bar was called\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def foo(self):\n",
    "        print(\"A.foo was called\")\n",
    "        \n",
    "    def bar(self):\n",
    "        print(\"A.bar was called\")\n",
    "        \n",
    "class B(A):\n",
    "    def foo(self):\n",
    "        print(\"B.foo was called\")\n",
    "        \n",
    "b = B()\n",
    "b.foo()\n",
    "b.bar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Since data attributes can be created anywhere, they are only inherited if the code in the base class' method is called."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n",
      "{}\n",
      "a.__dict__ = {'value': 42}\n",
      "b.__dict__ = {'value': 42}\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    \n",
    "    def foo(self):\n",
    "        self.value = 42\n",
    "        \n",
    "class B(A):\n",
    "    pass\n",
    "\n",
    "b = B()\n",
    "print(b.__dict__)\n",
    "a = A()\n",
    "print(a.__dict__)\n",
    "a.foo()\n",
    "print(f\"{a.__dict__ = }\")\n",
    "\n",
    "b.foo()\n",
    "print(f\"{b.__dict__ = }\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Calling the base class's `init`__\n",
    "\n",
    "Since `__init__` is not a constructor, the base class' init is not called automatically, if the subclass overrides it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B.__init__ called\n",
      "Creating c\n",
      "A.__init__ called\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def __init__(self):\n",
    "        print(\"A.__init__ called\")\n",
    "        \n",
    "class B(A):\n",
    "    def __init__(self):\n",
    "        print(\"B.__init__ called\")\n",
    "        \n",
    "class C(A):\n",
    "    pass\n",
    "        \n",
    "b = B()\n",
    "print(\"Creating c\")\n",
    "c = C()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The base class's methods can be called in at least two ways:\n",
    "1. Explicitely via the class name\n",
    "1. Using the **super** function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Instantiating B\n",
      "A.__init__ called\n",
      "B.__init__ called\n",
      "\n",
      "Instantiating C\n",
      "A.__init__ called\n",
      "C.__init__ called\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def __init__(self):\n",
    "        print(\"A.__init__ called\")\n",
    "        \n",
    "class B(A):\n",
    "    def __init__(self):\n",
    "        A.__init__(self)\n",
    "        print(\"B.__init__ called\")\n",
    "        \n",
    "class C(A):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        print(\"C.__init__ called\")\n",
    "        \n",
    "print(\"Instantiating B\")\n",
    "b = B()\n",
    "print(\"\\nInstantiating C\")\n",
    "c = C()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A complete example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jakab Gipsz, age 33, position: manager, salary: 450000\n",
      "Jakab Gipsz, age 33\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    \n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        \n",
    "    def __str__(self):\n",
    "        return f\"{self.name}, age {self.age}\"\n",
    "        \n",
    "class Employee(Person):\n",
    "    \n",
    "    def __init__(self, name, age, position, salary):\n",
    "        self.position = position\n",
    "        self.salary = salary\n",
    "        super().__init__(name, age)\n",
    "        \n",
    "    def __str__(self):\n",
    "        return f\"{super().__str__()}, position: {self.position}, salary: {self.salary}\"\n",
    "    \n",
    "    \n",
    "e = Employee(\"Jakab Gipsz\", 33, \"manager\", 450000)\n",
    "print(e)\n",
    "print(Person(e.name, e.age))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Duck typing and interfaces\n",
    "\n",
    "- No built-in mechanism for interfacing.\n",
    "- The Abstract Base Classes (`abc`) module implements interface-like features.\n",
    "- Not used extensively in Python in favor of duck typing.\n",
    "\n",
    "\"In computer programming, duck typing is an application of the duck test in type safety. It requires that type checking be deferred to runtime, and is implemented by means of dynamic typing or reflection.\" -- [Wikipedia](https://en.wikipedia.org/wiki/Duck_typing)\n",
    "\n",
    "\"If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.\" -- [Wikipedia](https://en.wikipedia.org/wiki/Duck_test)\n",
    "\n",
    "Allows polymorphism without abstract base classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mieuw\n",
      "Vau\n"
     ]
    }
   ],
   "source": [
    "class Cat:\n",
    "    \n",
    "    def make_sound(self):\n",
    "        self.mieuw()\n",
    "        \n",
    "    def mieuw(self):\n",
    "        print(\"Mieuw\")\n",
    "        \n",
    "        \n",
    "class Dog:\n",
    "    \n",
    "    def make_sound(self):\n",
    "        self.bark()\n",
    "        \n",
    "    def bark(self):\n",
    "        print(\"Vau\")\n",
    "        \n",
    "\n",
    "animals = [Cat(), Dog()]\n",
    "for animal in animals:\n",
    "    # animal must have a make_sound method\n",
    "    animal.make_sound()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "__`NotImplementedError`__\n",
    "\n",
    "Emulating C++'s pure virtual function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vau.\n"
     ]
    },
    {
     "ename": "NotImplementedError",
     "evalue": "Animal subclass must implement make_sound.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-39-e6ec50274be6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0mdog\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmake_sound\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m \u001b[0mfox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmake_sound\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-39-e6ec50274be6>\u001b[0m in \u001b[0;36mmake_sound\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mAnimal\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mmake_sound\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Animal subclass must implement make_sound.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mDog\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mAnimal\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNotImplementedError\u001b[0m: Animal subclass must implement make_sound."
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def make_sound(self):\n",
    "        raise NotImplementedError(\"Animal subclass must implement make_sound.\")\n",
    "        \n",
    "class Dog(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Vau.\")\n",
    "        \n",
    "class Fox(Animal):\n",
    "    pass\n",
    "        \n",
    "dog = Dog()\n",
    "\n",
    "# Fox can be instantiated\n",
    "fox = Fox()\n",
    "\n",
    "dog.make_sound()\n",
    "fox.make_sound()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__abc module__\n",
    "\n",
    "More options in the [Abstract Base Classes module](https://docs.python.org/3/library/abc.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Magic methods\n",
    "\n",
    "Mechanism that allows implementing advanced OO features.\n",
    "\n",
    "**dunder** methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`__str__` __method__\n",
    "\n",
    "Returns the string representation of the object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    def __init__(self, value=42):\n",
    "        self.param = value\n",
    "        \n",
    "    def __str__(self):\n",
    "        return f\"My id is {id(self)} and my parameter is {self.param}.\"\n",
    "    \n",
    "str(A(345))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Operator overloading\n",
    "\n",
    "- Operators are mapped to magic functions.\n",
    "- Defining these functions defines/overrides operators.\n",
    "- Comprehensive list of operator functions are [here](https://docs.python.org/3/library/operator.html).\n",
    "- Many built-in functions are included as well:\n",
    "  - `__len__`: defines the behavior of `len(obj)`\n",
    "  - `__abs__`: defines the behavior of `abs(obj)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Complex:\n",
    "    def __init__(self, real=0.0, imag=0.0):\n",
    "        self.real = real\n",
    "        self.imag = imag\n",
    "        \n",
    "    def __abs__(self):\n",
    "        return (self.real**2 + self.imag**2) ** 0.5\n",
    "    \n",
    "    def __eq__(self, other):  # right hand side\n",
    "        return self.real == other.real and self.imag == other.imag\n",
    "    \n",
    "    def __gt__(self, other):\n",
    "        return abs(self) > abs(other)\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        return Complex(self.real+other.real, self.imag+other.imag)\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"{self.real}+j{self.imag}\"\n",
    "    \n",
    "c1 = Complex()\n",
    "c2 = Complex(1, 1)\n",
    "print(f\"{c1 == c1 = }\")\n",
    "print(f\"{c1 > c2 = }\")\n",
    "print(f\"{abs(c2) = }\")\n",
    "print(f\"{c1 + c2 + c2 = }\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Assignment operator, shallow copy and deep copy\n",
    "\n",
    "\n",
    "There are 3 types of assignment and copying:\n",
    "\n",
    "1. the assignment operator (=) creates a new reference to the same object,\n",
    "1. `copy` performs shallow copy,\n",
    "1. `deepcopy` recursively deepcopies everything.\n",
    "\n",
    "\n",
    "__Assignment operator__:\n",
    "- It **cannot** be overridden.\n",
    "- It performs name binding instead of copying.\n",
    "- Tightly bound to the garbage collector.\n",
    "\n",
    "The difference between shallow and deep copy is only relevant for compound objects (objects that contain other objects)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = [[1, 2], [3, 4, 5]]\n",
    "l2 = l1\n",
    "print(f\"{(l1 is l2) = }\")\n",
    "print(f\"{(l1[0] is l2[0]) = }\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1[0][0] = 10\n",
    "l2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "__Shallow copy__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import copy\n",
    "\n",
    "l1 = [[1, 2], [3, 4, 5]]\n",
    "l2 = copy(l1)\n",
    "\n",
    "print(f\"{(l1 is l2) = }\")\n",
    "print(f\"{(l1[0] is l2[0]) = }\")\n",
    "l1[0][0] = 10\n",
    "l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = [[1, 2], [3, 4, 5]]\n",
    "l2 = copy(l1)\n",
    "print(f\"{(l1 is l2) = }\")\n",
    "print(f\"{(l1[0] is l2[0]) = }\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 == l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = [[1, 2], [3, 4, 5]]\n",
    "l2 = copy(l1)\n",
    "l2[0][0] = 11\n",
    "l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'copy' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-40-dff4b3de2b74>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ml1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0ml2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ml1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0ml1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m9\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"{l1 = }\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"{l2 = }\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'copy' is not defined"
     ]
    }
   ],
   "source": [
    "l1 = [[1, 2], [3, 4, 5]]\n",
    "l2 = copy(l1)\n",
    "l1[0] = [7, 8, 9]\n",
    "print(f\"{l1 = }\")\n",
    "print(f\"{l2 = }\")\n",
    "print(f\"{(l1[0] is l2[0]) = }\")\n",
    "print(f\"{(l1[1] is l2[1]) = }\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "__Deep copy__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "\n",
    "l1 = [[1, 2], [3, 4, 5]]\n",
    "l2 = deepcopy(l1)\n",
    "print(f\"{(l1 is l2) = }\")\n",
    "print(f\"{(l1[0] is l2[0]) = }\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1[0][0] = 10\n",
    "l2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Both can be defined via magic methods\n",
    "\n",
    "*note that these implementations do not check for infinite loops*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from copy import copy, deepcopy\n",
    "\n",
    "class ListOfLists:\n",
    "    def __init__(self, lists):\n",
    "        self.lists = lists\n",
    "        self.list_lengths = [len(l) for l in self.lists]\n",
    "        \n",
    "    def __copy__(self):\n",
    "        print(\"ListOfLists copy called\")\n",
    "        return ListOfLists(copy(self.lists))\n",
    "        \n",
    "    def __deepcopy__(self, memo):\n",
    "        print(\"ListOfLists deepcopy called\")\n",
    "        return ListOfLists(deepcopy(self.lists))\n",
    "        \n",
    "l1 = ListOfLists([[1, 2], [3, 4, 5]])\n",
    "l2 = copy(l1)\n",
    "l1.lists[0][0] = 12\n",
    "print(l2.lists)\n",
    "l3 = deepcopy(l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "However, these are very far from complete implementations. We need to take care of preventing infinite loops and support for pickling (serialization module)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Object creation and destruction: the `__new__` and the `__del__` method\n",
    "\n",
    "The `__new__` method is called to create a new instance of a class. `__new__` is a static method that takes the class object as a first parameter.\n",
    "\n",
    "Typical implementations create a new instance of the class by invoking the superclass’s `__new__()` method using `super(currentclass, cls).__new__(cls[, ...])` with appropriate arguments and then modifying the newly-created instance as necessary before returning it.\n",
    "\n",
    "`__new__` has to return an instance of `cls`, on which `__init__` is called.\n",
    "\n",
    "The `__del__` method is called when an object is about to be destroyed.\n",
    "Although technically a destructor, it is handled by the garbage collector.\n",
    "It is not guaranteed that `__del__()` methods are called for objects that still exist when the interpreter exits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "class A:\n",
    "    \n",
    "    @classmethod\n",
    "    def __new__(cls, *args, **kwargs):\n",
    "        instance = super().__new__(cls)\n",
    "        print(\"A.__new__ called\")\n",
    "        return instance\n",
    "    \n",
    "    def __init__(self):\n",
    "        print(\"A.__init__ called\")\n",
    "        \n",
    "    def __del__(self):\n",
    "        print(\"A.__del__ called\")\n",
    "        try:\n",
    "            super(A, self).__del__()\n",
    "        except AttributeError:\n",
    "            print(\"parent class does not have a __del__ method\")\n",
    "        \n",
    "        \n",
    "a = A()\n",
    "print(\"a created\")\n",
    "del a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Object introspection\n",
    "\n",
    "- Python has full object introspection.\n",
    "- **`dir`** lists every attribute of an object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    var = 12\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "        \n",
    "    def foo(self):\n",
    "        print(\"bar\")\n",
    "  \n",
    "\", \".join(dir(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Class `A` does not have a value attribute, since it is bounded to an instance. However, it does have the class global var attribute."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "An instance of A has both:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\", \".join(dir(A(12)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "`__code__`\n",
    "\n",
    "Every object has a `__code__` attribute, which contains everything needed to call the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def evaluate(x):\n",
    "    a = 12\n",
    "    b = 3\n",
    "    return a*x + b\n",
    "    \n",
    "print(evaluate.__code__)\n",
    "#dir(evaluate.__code__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "evaluate.__code__.co_varnames, evaluate.__code__.co_freevars, evaluate.__code__.co_stacksize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "The **inspect** module provides further code introspection tools, including the **getsourcelines** function, which returns the source code itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from inspect import getsourcelines\n",
    "\n",
    "print(\"\".join(getsourcelines(evaluate)[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Class decorators\n",
    "\n",
    "Many OO features are achieved via a syntax sugar called decorators. We will talk about decorators in detail later.\n",
    "\n",
    "The most common features are:\n",
    "\n",
    "1. staticmethod,\n",
    "1. classmethod,\n",
    "1. property."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Static methods\n",
    "\n",
    "- Defined inside a class but not bound to an instance (no self parameter).\n",
    "- Analogous to C++'s static methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    instance_count = 0\n",
    "    \n",
    "    def __init__(self, value=42):\n",
    "        self.value = value\n",
    "        A.increase_instance_count()\n",
    "        \n",
    "    @staticmethod\n",
    "    def increase_instance_count():\n",
    "        A.instance_count += 1\n",
    "        \n",
    "        \n",
    "a1 = A()\n",
    "print(A.instance_count)\n",
    "a2 = A()\n",
    "A()\n",
    "A()\n",
    "A()\n",
    "A()\n",
    "A()\n",
    "print(A.instance_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Class methods\n",
    "\n",
    "- Bound to the class instead of an instance of the class.\n",
    "- Its first argument is a class instance called `cls` by convention.\n",
    "- Typical usage: factory methods for the class.\n",
    "\n",
    "Let's create a Complex class that can be initialized with either a string such as \"5+j6\" or with two numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Complex:\n",
    "    def __init__(self, real, imag):\n",
    "        self.real = real\n",
    "        self.imag = imag\n",
    "        \n",
    "    def __str__(self):\n",
    "        return f\"{self.real}+j{self.imag}\"\n",
    "    \n",
    "    @classmethod\n",
    "    def from_str(cls, complex_str):\n",
    "        print(f\"{cls.__name__}.from_str\")\n",
    "        real, imag = complex_str.split('+')\n",
    "        imag = imag.lstrip('ij')\n",
    "        return cls(float(real), float(imag))\n",
    "    \n",
    "class SuperComplex(Complex):\n",
    "    pass\n",
    "    \n",
    "c1 = Complex.from_str(\"3.45+j2\")\n",
    "print(c1)\n",
    "c2 = Complex(3, 4)\n",
    "print(c2)\n",
    "\n",
    "s = SuperComplex.from_str(\"3+i0\")\n",
    "type(s), type(c1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Properties\n",
    "\n",
    "- Properties are attributes with getters, setters and deleters.\n",
    "- Property works as both a built-in function and as separate decorators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self._age = None\n",
    "        self.age = age\n",
    "        \n",
    "    @property\n",
    "    def age(self):\n",
    "        return self._age\n",
    "    \n",
    "    @age.setter\n",
    "    def age(self, age):\n",
    "        try:\n",
    "            if 0 <= age <= 150:\n",
    "                self._age = age\n",
    "        except TypeError:\n",
    "            pass\n",
    "        \n",
    "    @age.deleter\n",
    "    def age(self):\n",
    "        print(\"Del\")\n",
    "        self._age = None\n",
    "            \n",
    "    def __str__(self):\n",
    "        return f\"Name: {self.name}, age: {self.age}\"\n",
    "            \n",
    "\n",
    "p = Person(\"John\", 12)\n",
    "print(p)\n",
    "p.age = \"abc\"\n",
    "print(p)\n",
    "p.age = 85\n",
    "print(p)\n",
    "p.age = 850\n",
    "print(p)\n",
    "del p.age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Multiple inheritance\n",
    "\n",
    "- No interface inheritance in Python.\n",
    "- Since every class subclasses `object`, the diamond problem is present.\n",
    "- Method resolution order (MRO) defines the way methods are inherited"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class A(object):\n",
    "    def __init__(self, value):\n",
    "        print(\"A init called\")\n",
    "        self.value = value\n",
    "        \n",
    "class B(object):\n",
    "    def __init__(self):\n",
    "        print(\"B init called\")\n",
    "\n",
    "class C(A, B):\n",
    "    def __init__(self, value1, value2):\n",
    "        print(\"C init called\")\n",
    "        self.value2 = value2\n",
    "        super().__init__(value1)\n",
    "        \n",
    "class D(A, B): pass\n",
    "        \n",
    "print(\"Instantiating C\")\n",
    "c = C(1, 2)\n",
    "print(\"Instantiating D\")\n",
    "d = D(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# See also\n",
    "\n",
    "* [Classes (official documentation)](https://docs.python.org/3/tutorial/classes.html)\n",
    "* [Data model (official documentation)](https://docs.python.org/3/reference/datamodel.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Your questions\n",
    "\n",
    "## Which base method is called when there are multiple options?\n",
    "\n",
    "In this simple examples the leftmost one is called:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A.foo\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def foo(self):\n",
    "        print(\"A.foo\")\n",
    "        \n",
    "class B:\n",
    "    def foo(self):\n",
    "        print(\"B.foo\")\n",
    "        \n",
    "class C(A, B):\n",
    "    pass\n",
    "\n",
    "C().foo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Switching the order of the base classes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B.foo\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def foo(self):\n",
    "        print(\"A.foo\")\n",
    "        \n",
    "class B:\n",
    "    def foo(self):\n",
    "        print(\"B.foo\")\n",
    "        \n",
    "class C(B, A):\n",
    "    pass\n",
    "\n",
    "C().foo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is the type of `super`?\n",
    "\n",
    "It does not simply return the base class. It implements a sophisticated method resolution order described [here](https://www.python.org/download/releases/2.3/mro/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'super'>\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def foo(self):\n",
    "        print(\"A.foo\")\n",
    "        \n",
    "class B:\n",
    "    def foo(self):\n",
    "        print(\"B.foo\")\n",
    "        \n",
    "class C(A, B):\n",
    "    def bar(self):\n",
    "        print(super().__class__)\n",
    "\n",
    "C().bar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Can we make methods private?\n",
    "\n",
    "Name mangling works for method as well. The class where the 'private' method is defined is used for mangling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A.foo\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def __foo(self):\n",
    "        print(\"A.foo\")\n",
    "        \n",
    "class B(A):\n",
    "    pass\n",
    "        \n",
    "class C(B):\n",
    "    pass\n",
    "\n",
    "# Don't do this\n",
    "B()._A__foo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Can we make classmethods outside the class definition?\n",
    "\n",
    "Yes, we can explicitly decorate a method as a classmethod but it's not used very often. We will talk about decorators in detail later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo called\n",
      "foo's parameter: 12\n",
      "\n",
      "Making it a classmethod\n",
      "foo called\n",
      "foo's parameter: <class '__main__.A'>\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def foo(cls):\n",
    "        print(\"foo called\")\n",
    "        print(\"foo's parameter:\", cls)\n",
    "\n",
    "A.foo(12)\n",
    "print(\"\\nMaking it a classmethod\")\n",
    "A.foo = classmethod(A.foo)\n",
    "A.foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}