13_Classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Object Oriented Programming (OOP)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Object-oriented programming (OOP) is a programming paradigm based on the concept of \"**objects**\", which may contain data, in the form of fields, often known as **attributes**; and code, in the form of procedures, often known as **methods**. A feature of objects is that an object's procedures can access and often modify the data fields of the object with which they are associated (objects have a notion of \"self\"). In OOP, computer programs are designed by making them out of objects that interact with one another. There is significant diversity of OOP languages, but the most popular ones are class-based, meaning that objects are instances of classes, which typically also determine their type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Abstraction**. Abstraction is a process where you show only “relevant” data and “hide” unnecessary details of an object from the user.\n",
    "\n",
    "**Encapsulation**.\n",
    "  - Binding the data with the code that manipulates it.\n",
    "  - It keeps the data and the code safe from external interference\n",
    "  \n",
    "**Inheritance**.\n",
    "  - Inheritance is the mechanism by which an object acquires the some/all properties of another object.\n",
    "  - It supports the concept of hierarchical classification.\n",
    "  \n",
    "**Polymorphism**. Polymorphism means to process objects differently based on their data type.\n",
    "  - Method overriding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Example 1\n",
    "\n",
    "Imagine a data access layer for a school management project. We will need this two service functions in both examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def connect_db(db_connection_string):\n",
    "    return 'conn={}'.format(db_connection_string)\n",
    "\n",
    "def query_db(db, sql_query):\n",
    "    return 'result for ({}: {})'.format(db, sql_query)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result for (conn=db://server_one: SELECT * FROM schedule WHERE class=\"7a\" AND day=\"2019-08-07\")\n",
      "result for (conn=db://server_one: SELECT * FROM schedule WHERE teacher=\"Josh Smith\" AND day=\"2019-08-07\")\n",
      "result for (conn=db://server_two: SELECT * FROM pupils WHERE class=\"2b\")\n"
     ]
    }
   ],
   "source": [
    "# You may notice how intensively `db` variable is used.\n",
    "def get_class_schedule(db, class_name, date):\n",
    "    return query_db(db, 'SELECT * FROM schedule WHERE class=\"{}\" AND day=\"{}\"'.format(class_name, date))\n",
    "\n",
    "def get_teacher_schedule(db, teacher_name, date):\n",
    "    return query_db(db, 'SELECT * FROM schedule WHERE teacher=\"{}\" AND day=\"{}\"'.format(teacher_name, date))\n",
    "\n",
    "def get_class_members(db, class_name):\n",
    "    return query_db(db, 'SELECT * FROM pupils WHERE class=\"{}\"'.format(class_name))\n",
    "\n",
    "db1 = connect_db('db://server_one')\n",
    "db2 = connect_db('db://server_two')\n",
    "\n",
    "print get_class_schedule(db1, '7a', '2019-08-07')\n",
    "print get_teacher_schedule(db1, 'Josh Smith', '2019-08-07')\n",
    "print get_class_members(db2, '2b')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    " * PROS: multiple database connections supported. `get_*` functions are blackboxed.\n",
    " * CONS: `db` variable passing back and forth\n",
    " \n",
    " Let's look at slightly modified example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result for (conn=db://server_one: SELECT * FROM schedule WHERE class=\"7a\" AND day=\"2019-08-07\")\n",
      "result for (conn=db://server_one: SELECT * FROM schedule WHERE teacher=\"Josh Smith\" AND day=\"2019-08-07\")\n",
      "result for (conn=db://server_two: SELECT * FROM pupils WHERE class=\"2b\")\n"
     ]
    }
   ],
   "source": [
    "def get_class_schedule(class_name, date):\n",
    "    return query_db(db, 'SELECT * FROM schedule WHERE class=\"{}\" AND day=\"{}\"'.format(class_name, date))\n",
    "\n",
    "def get_teacher_schedule(teacher_name, date):\n",
    "    return query_db(db, 'SELECT * FROM schedule WHERE teacher=\"{}\" AND day=\"{}\"'.format(teacher_name, date))\n",
    "\n",
    "def get_class_members(class_name):\n",
    "    return query_db(db, 'SELECT * FROM pupils WHERE class=\"{}\"'.format(class_name))\n",
    "\n",
    "db = connect_db('db://server_one')\n",
    "print get_class_schedule('7a', '2019-08-07')\n",
    "print get_teacher_schedule('Josh Smith', '2019-08-07')\n",
    "\n",
    "db = connect_db('db://server_two')\n",
    "print get_class_members('2b')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* PROS: `get_*` functions now have cleaner interface\n",
    "* CONS: to query multiple databases, one can change assign `db` variable a different connection handler before calling `get_*` functions. It can be ugly, but what's worse is that function abstraction is broken because it assumes you are aware about internal structure of these functions.\n",
    "\n",
    "What OOP can help to solve this problem?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class School:\n",
    "    def __init__(self, db_connection_string):\n",
    "        self.db = self.__connect_db(db_connection_string)\n",
    "        \n",
    "    def __connect_db(self, db_connection_string):\n",
    "        return 'conn={}'.format(db_connection_string)\n",
    "\n",
    "    def __query_db(self, db, sql_query):\n",
    "        return 'result for ({}: {})'.format(db, sql_query)\n",
    "    \n",
    "    def get_class_schedule(self, class_name, date):\n",
    "        return self.__query_db(self.db, 'SELECT * FROM schedule WHERE class=\"{}\" AND day=\"{}\"'.format(class_name, date))\n",
    "\n",
    "    def get_teacher_schedule(self, teacher_name, date):\n",
    "        return self.__query_db(self.db, 'SELECT * FROM schedule WHERE teacher=\"{}\" AND day=\"{}\"'.format(teacher_name, date))\n",
    "\n",
    "    def get_class_members(self, class_name):\n",
    "        return self.__query_db(self.db, 'SELECT * FROM pupils WHERE class=\"{}\"'.format(class_name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result for (conn=db://server_one: SELECT * FROM schedule WHERE class=\"7a\" AND day=\"2019-08-07\")\n",
      "result for (conn=db://server_one: SELECT * FROM schedule WHERE teacher=\"Josh Smith\" AND day=\"2019-08-07\")\n",
      "result for (conn=db://server_two: SELECT * FROM pupils WHERE class=\"2b\")\n"
     ]
    }
   ],
   "source": [
    "school1 = School('db://server_one')\n",
    "print school1.get_class_schedule('7a', '2019-08-07')\n",
    "print school1.get_teacher_schedule('Josh Smith', '2019-08-07')\n",
    "\n",
    "school2 = School('db://server_two')\n",
    "print school2.get_class_members('2b')"
   ]
  },
  {
   "attachments": {
    "shapes.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Example 2\n",
    "\n",
    "Imagine we want to write a program that calculates volumes of different 3D shapes like: cube, rectangular solid, cylinder, pyramid etc.\n",
    "\n",
    "![shapes.png](attachment:shapes.png)\n",
    "\n",
    "We start by defining the abstract ancestor class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Abstract3dShapeWithHeight:\n",
    "    def __init__(self, h):\n",
    "        self.h = h\n",
    "        \n",
    "    def height(self):\n",
    "        return self.h\n",
    "    \n",
    "    def volume(self):\n",
    "        return self.height() * self.base_area()\n",
    "    \n",
    "    def base_area(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It makes no sense of using this class directly for calculating volume, because method `base_area()` are defined abstract. In spite of this it implements some logic: volume is defined as product of base area and height. Now let's use inheritance to share this logic between descendants."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Concrete classes given below redefine (override) abstract methods of ancestor class, thus we can call them \"implementations\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cube(Abstract3dShapeWithHeight):\n",
    "    def __init__(self, h):\n",
    "        Abstract3dShapeWithHeight.__init__(self, h)\n",
    "    \n",
    "    def base_area(self):\n",
    "        return self.height() ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "class Cylinder(Abstract3dShapeWithHeight):\n",
    "    def __init__(self, h, r):\n",
    "        Abstract3dShapeWithHeight.__init__(self, h)\n",
    "        self.r = r\n",
    "\n",
    "    def base_area(self):\n",
    "        return math.pi * (self.r ** 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mycube = Cube(10)\n",
    "mycube.volume()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Some explanations for the above code:\n",
    " * Instantiation looks like `name_of_the_class(<parameters_passed_to_constructor>)`, pretty much like calling a regular function. Nothing like `new` keyword here.\n",
    " * Instantiated object put into `mycube` variable.\n",
    " * This variable now contains object of class Cube with all the data passed during initialization.\n",
    " * `volume()` method is then called in the context of object `mycube`\n",
    " * For instance methods `self` is the required first argument (you can give it a different name, but please don't). So `self` is explicit parameter unlike implicit `this` in some other languages.\n",
    " * Methods like `__some_method__` are called **dunder-methods**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Some terminology of OOP:\n",
    " * **Class** is a template for an object\n",
    " * **Method** is a function defined for a class that acts in the context of an object\n",
    " * Object \"variables\" are called **fields**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Creating an object of given class called **instantiation**. In general, these terms usually are interchangeable:\n",
    " * Class = Type (in languages where \"everything is an object\", like Python or Ruby)\n",
    " * Object = Instance\n",
    " * Create an object = Instantiate\n",
    " * Instance variable = field\n",
    " \n",
    "Now let's make use of our toy classes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8000"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's create another instance of Cube\n",
    "mycube20 = Cube(20)\n",
    "mycube20.volume()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly create an instance of Cylinder. It's constructor requires two arguments: radius and height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "314.1592653589793"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mycyl = Cylinder(1, 10)\n",
    "mycyl.volume()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can call other public methods as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mycyl.height()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "What if we wanted to define a class for pyramid? Volume of a pyramid shape not equal to just `base * height`. This is not a problem, because we can override `volume()` (which is concrete, e.g. not abstract), like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13.333333333333334"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Pyramid(Abstract3dShapeWithHeight):\n",
    "    def __init__(self, h, side):\n",
    "        Abstract3dShapeWithHeight.__init__(self, h)\n",
    "        self.side = side\n",
    "    \n",
    "    def base_area(self):\n",
    "        return self.side ** 2\n",
    "    \n",
    "    def volume(self):\n",
    "        return self.base_area() * self.height() / 3.0\n",
    "    \n",
    "pyr = Pyramid(10, 2)\n",
    "pyr.volume()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "OOP in simple words:\n",
    " * **Encapsulation** is another fancy word describing the **black box** paradigm.\n",
    " * **Inheritance** can be used to partially define and share logic among implementations.\n",
    " * **Polymorphism** allows to change some parts of behaviour defined in ancestor classes without reimplementing the whole algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Classic or pure OOP\n",
    "\n",
    " * Class defines \"behaviour\", e.g. methods that manipulate data (internal state) of the object.\n",
    " * Intenal state is not exposed. No way to examine internal state of the object, except using public methods that may return some information about it. \n",
    " * Interface is defined by public methods only.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**OOP in Python is a joke**:\n",
    " * Internal state is exposed and you have access to object's fields\n",
    " * Private methods can be called from outside"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Class definition\n",
    "\n",
    "```\n",
    "class <name>:\n",
    "    [body]\n",
    "```\n",
    "\n",
    "or\n",
    "\n",
    "```\n",
    "class <name>(Base1[, Base2 ... BaseN]):\n",
    "    [body]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Object instantiation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DoesNothing:\n",
    "    pass\n",
    "\n",
    "nothing_instance = DoesNothing()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice: object instantiation looks like function call (no \"new\" keyword or smth similar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "instance"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(nothing_instance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<class __main__.DoesNothing at 0x112165808>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nothing_instance.__class__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'DoesNothing'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nothing_instance.__class__.__name__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Everything is an object in Python, because it has a class. Even classes are objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'int'"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1\n",
    "x.__class__.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.__class__.__class__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A note about default object implementation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = DoesNothing()\n",
    "d2 = DoesNothing()\n",
    "\n",
    "d1 == d2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default object's \"==\" compares id's. For user defined types a programmer must override rich comparison and all necessary dunder methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "In Python a method with special name ```__init__``` called after object instantiation. First argument (by convention called ```self```) stores the referrence of the created object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "From consturctor <__main__.ClassWithConstructor instance at 0x112174d88>\n",
      "From outer scope <__main__.ClassWithConstructor instance at 0x112174d88>\n"
     ]
    }
   ],
   "source": [
    "class ClassWithConstructor:\n",
    "    def __init__(self):\n",
    "        print \"From consturctor\", self\n",
    "\n",
    "my_object = ClassWithConstructor()\n",
    "print \"From outer scope\", my_object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Instance variables & methods\n",
    "\n",
    "Usually ```__init__``` is used to define and initalize instance variables. Instance methods must always have ```self``` as first argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n",
      "300\n"
     ]
    }
   ],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "        \n",
    "    def square(self):\n",
    "        return self.width * self.height\n",
    "    \n",
    "rect_10x20 = Rectangle(10, 20)\n",
    "print rect_10x20.square()\n",
    "\n",
    "rect_30x10 = Rectangle(30, 10)\n",
    "print rect_30x10.square()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Class variables & methods\n",
    "\n",
    "Notice ```@classmethod``` and ```cls``` instead of ```self```. Also notice that class variable ```density``` is defined and initialized right in class body. ```cls``` in class body references class object so ```density``` can be accessed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Al mass = 2700.0 grams\n",
      "Fe mass = 7874.0 grams\n"
     ]
    }
   ],
   "source": [
    "class ChemicalElement():\n",
    "    @classmethod\n",
    "    def mass(cls, length, width, height):\n",
    "        volume = length * width * height # in cm\n",
    "        return cls.density * volume\n",
    "    \n",
    "class Aluminium(ChemicalElement):\n",
    "    density = 2.70 # g / cm^3\n",
    "    \n",
    "class Ferrum(ChemicalElement):\n",
    "    density = 7.874 # g / cm^3\n",
    "    \n",
    "print(\"Al mass = {} grams\".format(Aluminium.mass(10, 10, 10)))\n",
    "print(\"Fe mass = {} grams\".format(Ferrum.mass(10, 10, 10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Static methods\n",
    "\n",
    "Usually you use them to hide your functions under a namespace (but this is what modules are for).\n",
    "\n",
    "Notice ```@staticmethod``` and no first required argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "62.800000000000004"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class SquareCalculator:\n",
    "    @staticmethod\n",
    "    def rectangle(width, height):\n",
    "        return width * height\n",
    "    \n",
    "    @staticmethod\n",
    "    def circle(radius):\n",
    "        return 2 * 3.14 * radius\n",
    "    \n",
    "SquareCalculator.circle(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "314.0"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class BowlingBall:\n",
    "    DENSITY = 0.1\n",
    "    \n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "        \n",
    "    def weight(self):\n",
    "        return self.sphere_volume(self.radius) * self.DENSITY \n",
    "        \n",
    "    @classmethod\n",
    "    def sphere_volume(cls, r):\n",
    "        return (4 / 3) * 3.14 * (r ** 3)\n",
    "    \n",
    "my_ball = BowlingBall(10)\n",
    "my_ball.weight()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Classes as structures\n",
    "\n",
    "Class/instance variables/methods can be dynamically assigned. Sometimes people use classes in place of structures (this is what dictionaries are for)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'x': 62, 'y': 'Mama'}"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyContainer:\n",
    "    pass\n",
    "\n",
    "cont1 = MyContainer()\n",
    "\n",
    "cont1.x = 62\n",
    "cont1.y = 'Mama'\n",
    "\n",
    "cont1.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attributes of the class-level can be checked with method `__dict__()` too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'__doc__': None,\n",
       " '__module__': '__main__',\n",
       " 'my_class_attribute': 'this is class attribute'}"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MyContainer.my_class_attribute = \"this is class attribute\"\n",
    "\n",
    "MyContainer.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "This is possible due to default ```__getattribute__()``` implementation, which first searches in instance and then in class variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is class attribute\n"
     ]
    }
   ],
   "source": [
    "print(cont1.my_class_attribute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is class attribute\n"
     ]
    }
   ],
   "source": [
    "cont2 = MyContainer()\n",
    "print(cont2.my_class_attribute)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Btw one more way to access instance attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "62"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getattr(cont1, 'x')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is class attribute'"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getattr(cont1, 'my_class_attribute')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [setattr()](https://docs.python.org/3/library/functions.html#setattr)\n",
    "* [hasattr()](https://docs.python.org/3/library/functions.html#hasattr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Looks like a prototype-based OOP (Javascript)?\n",
    "\n",
    "Docs on [staticmethod()](https://docs.python.org/3/library/functions.html#staticmethod) see also [classmethod()](https://docs.python.org/3/library/functions.html#classmethod)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello MyContainer\n",
      "Hello static\n"
     ]
    }
   ],
   "source": [
    "def my_instance_print_hello(self):\n",
    "    print(\"Hello \" + self.__class__.__name__)\n",
    "    \n",
    "def my_static_print_hello():\n",
    "    print(\"Hello static\")\n",
    "\n",
    "MyContainer.print_instance = my_instance_print_hello\n",
    "MyContainer.print_static = staticmethod(my_static_print_hello)\n",
    "\n",
    "cont2.print_instance()\n",
    "cont2.print_static()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Inheritance and polymorphism\n",
    "\n",
    "No surprises: methods can be overriden by superclasses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "1000\n"
     ]
    }
   ],
   "source": [
    "class Box2D(object):\n",
    "    def __init__(self, side):\n",
    "        self.side = side\n",
    "        \n",
    "    def square(self):\n",
    "        return self.side * self.side\n",
    "    \n",
    "class Box3D(Box2D):\n",
    "    def square(self):\n",
    "        return self.side * super(Box3D, self).square()\n",
    "    \n",
    "box2d = Box2D(10)\n",
    "print box2d.square()\n",
    "\n",
    "box3d = Box3D(10)\n",
    "print box3d.square()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Multiple inheritance and the \"deadly diamond of death\"\n",
    "\n",
    "![](https://www.python-course.eu/images/multiple_inheritance_diamond.png)\n",
    "\n",
    "[Read more](https://www.python-course.eu/python3_multiple_inheritance.php)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Because B goes first in the list of parents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m of B called\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def m(self):\n",
    "        print(\"m of A called\")\n",
    "\n",
    "class B(A):\n",
    "    def m(self):\n",
    "        print(\"m of B called\")\n",
    "    \n",
    "class C(A):\n",
    "    def m(self):\n",
    "        print(\"m of C called\")\n",
    "\n",
    "class D(B, C):\n",
    "    pass\n",
    "\n",
    "x = D()\n",
    "x.m()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Because C is the closest parent who overrides m()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m of A called\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def m(self):\n",
    "        print(\"m of A called\")\n",
    "\n",
    "class B(A):\n",
    "    pass\n",
    "    \n",
    "class C(A):\n",
    "    def m(self):\n",
    "        print(\"m of C called\")\n",
    "\n",
    "class D(B, C):\n",
    "    pass\n",
    "\n",
    "x = D()\n",
    "x.m()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Try to avoid multiple inheritance. But it's good for [Mixins](https://en.wikipedia.org/wiki/Mixin):\n",
    "\n",
    "> In object-oriented programming languages, a Mixin is a class that contains methods for use by other classes without having to be the parent class of those other classes. ... Mixins are sometimes described as being \"included\" rather than \"inherited\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Usefull built-in methods\n",
    "\n",
    "* [isinstance()](https://docs.python.org/2/library/functions.html#isinstance)\n",
    "* [issubclass()](https://docs.python.org/2/library/functions.html#issubclass)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(x, D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "issubclass(D, C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Calling parents\n",
    "\n",
    "* [super()](https://docs.python.org/2/library/functions.html#super)\n",
    "\n",
    "Here's the demo of what an mixin is. Notice that AdminMixin's and ProgrammerMixin's ```__init__``` are not called. This is why typically mixins have no constructors.\n",
    "\n",
    "Notice: Person is inherited from `object`. This is Python 2 issue, to read more click [NewClassVsClassicClass](https://wiki.python.org/moin/NewClassVsClassicClass)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Person.__init__() called\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'George'"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Person(object):\n",
    "    def __init__(self, name):\n",
    "        self.name = name        \n",
    "        print(\"Person.__init__() called\")\n",
    "        \n",
    "class AdminMixin:\n",
    "    def __init__(self):\n",
    "        self.servers = []\n",
    "        print(\"AdminMixin.__init__() called\")\n",
    "        \n",
    "    def controls(self, servers):\n",
    "        self.servers = servers[:]\n",
    "\n",
    "class ProgrammerMixin:\n",
    "    def __init__(self):\n",
    "        self.languages = ['Python']\n",
    "        print(\"ProgrammerMixin.__init__() called\")\n",
    "\n",
    "    def knows(self, languages):\n",
    "        self.languages = languages[:]\n",
    "\n",
    "class Employee(Person, AdminMixin, ProgrammerMixin):\n",
    "    def __init__(self, name):\n",
    "        super(Employee, self).__init__(name)\n",
    "        \n",
    "vasya = Employee('George')\n",
    "vasya.name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Another option is to specify parents explicitly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Person.__init__() called\n",
      "AdminMixin.__init__() called\n",
      "ProgrammerMixin.__init__() called\n"
     ]
    }
   ],
   "source": [
    "class OmniscientEmployee(Person, AdminMixin, ProgrammerMixin):\n",
    "    def __init__(self, name):\n",
    "        Person.__init__(self, name)\n",
    "        AdminMixin.__init__(self)\n",
    "        ProgrammerMixin.__init__(self)\n",
    "        \n",
    "petya = OmniscientEmployee('Peter')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But multiple inheritance this way is also bad because you have to follow the correct order of calling methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Sometimes in others' code you'll find this way of calling super:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Person.__init__() called\n"
     ]
    }
   ],
   "source": [
    "class OlderEmployee(Person):\n",
    "    def __init__(self, name):\n",
    "        super(self.__class__, self).__init__(name)\n",
    "        \n",
    "masha = OlderEmployee('Maria')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is Python2 style where super() required an argument. In Python3 super() without any arguments understands the calling context."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "At least now we see that there're several ways of calling object methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof-woof!\n",
      "Moo-moo!\n",
      "Meow-meow!\n"
     ]
    }
   ],
   "source": [
    "class MyPrinter:\n",
    "    def echo(self, message):\n",
    "        print message\n",
    "        \n",
    "    def woofwoof(self):\n",
    "        self.echo('Woof-woof!')\n",
    "        \n",
    "    def moomoo(self):\n",
    "        MyPrinter.echo(self, 'Moo-moo!')\n",
    "        \n",
    "my_printer = MyPrinter()\n",
    "\n",
    "my_printer.woofwoof()\n",
    "my_printer.moomoo()\n",
    "\n",
    "# MyPrinter.print is \"bound\" method (it requires an object in \"self\" argument)\n",
    "MyPrinter.echo(my_printer, 'Meow-meow!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### A note about abstract classes\n",
    "\n",
    "How it's usually done:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyAbstractClass:\n",
    "    def do_the_thing(self):\n",
    "        raise NotImplementedError() # or just pass\n",
    "        \n",
    "class MyRealDoer(MyAbstractClass):\n",
    "    def do_the_thing(self):\n",
    "        print(\"Thing is done\")\n",
    "        \n",
    "my_abstract = MyAbstractClass()\n",
    "my_real = MyRealDoer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thing is done\n"
     ]
    }
   ],
   "source": [
    "my_real.do_the_thing()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "ename": "NotImplementedError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-88-bad03664c659>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmy_abstract\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdo_the_thing\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-86-b4951c4cf3d5>\u001b[0m in \u001b[0;36mdo_the_thing\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mMyAbstractClass\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[0mdo_the_thing\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[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)\u001b[0m \u001b[0;31m# or just pass\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[0mMyRealDoer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mMyAbstractClass\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: "
     ]
    }
   ],
   "source": [
    "my_abstract.do_the_thing()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also see [abc module](https://docs.python.org/3/library/abc.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Public and private access modifiers\n",
    "\n",
    "A good [explainer post](http://radek.io/2011/07/21/private-protected-and-public-in-python/)\n",
    "\n",
    "Python doesn’t have any mechanisms, that would effectively restrict you from accessing a variable or calling a member method. All of this is a matter of culture and **convention**.\n",
    "\n",
    "* All member variables and methods are public by default in Python.\n",
    "* The ```_``` prefix means **stay away even if you're not technically prevented from doing so**. This also marks a **protected** member\n",
    "* The ```__``` prefix means **private**, e.g. nobody should be able to access it from outside the class.\n",
    "\n",
    "Pros: since all members are publicly accessible, no need for boilerplate getter/setter code (but still possible using @property)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Python supports a technique called name mangling (obfuscation). This feature turns every member name prefixed with at least two underscores and suffixed with at most one underscore into ```_<className><memberName>```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'_PublicProtectedPrivateDemo__private': 'private',\n",
       " '_protected': 'protected',\n",
       " 'public': 'public'}"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class PublicProtectedPrivateDemo:\n",
    "    def __init__(self):\n",
    "        self.public     = 'public'\n",
    "        self._protected = 'protected'\n",
    "        self.__private  = 'private'\n",
    "        \n",
    "pppd = PublicProtectedPrivateDemo()\n",
    "pppd.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can still access ```__private``` member by refererring ```_PublicProtectedPrivateDemo__private```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'private'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pppd._PublicProtectedPrivateDemo__private"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## How to make a property\n",
    "\n",
    "See [property()](https://docs.python.org/2/library/functions.html#property)\n",
    "\n",
    "To fully understand this example, we have to learn about decorators. But don't worry, we'll do it in the next workshop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'John Smith'"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self, name, surname):\n",
    "        self.name = name\n",
    "        self.surname = surname\n",
    "\n",
    "    @property\n",
    "    def fullname(self):\n",
    "        return self.name + ' ' + self.surname\n",
    "    \n",
    "    @fullname.setter\n",
    "    def fullname(self, value):\n",
    "        self.name, self.surname = value.split()\n",
    "        \n",
    "student = Student('John', 'Smith')\n",
    "student.fullname"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('John', 'Smith')"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "student.fullname = 'Ivan Sidorov'\n",
    "student.name, student.surname"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Properties are useful for:\n",
    "* Calculated variables (like in example above)\n",
    "* Read-only or write-only variables\n",
    "* Getter/setter replacement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Special method names\n",
    "\n",
    "See [Data model](https://docs.python.org/3/reference/datamodel.html#special-method-names)\n",
    "\n",
    "> A class can implement certain operations that are invoked by special syntax (such as arithmetic operations or subscripting and slicing) by defining methods with special names. This is Python’s approach to operator overloading, allowing classes to define their own behavior with respect to language operators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Let's learn by example. Imagine we want a class that is a human language representation of number from 0 to 9 and acts like an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"Humanumba('one')\""
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Humanumba:\n",
    "    words = 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'\n",
    "    \n",
    "    def __new__(cls, word):\n",
    "        if word not in cls.words:\n",
    "            raise Exception('Not in vocabulary')\n",
    "            \n",
    "        obj = super().__new__(cls)\n",
    "        \n",
    "        return obj\n",
    "    \n",
    "    def __init__(self, word):\n",
    "        self.index = self.words.index(word)\n",
    "    \n",
    "    def __str__(self):\n",
    "        return self.words[self.index]\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return \"{cls}('{word}')\".format(\n",
    "            cls=self.__class__.__name__,\n",
    "            word=self.words[self.index]\n",
    "        )\n",
    "    \n",
    "one = Humanumba('one')\n",
    "\n",
    "print(one)\n",
    "repr(one)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Let's now try some basic operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "another_one = Humanumba('one')\n",
    "\n",
    "one == another_one"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "But ```one``` and ```another_one``` represent the same entity. Let's fix that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Humanumba2(Humanumba):\n",
    "    def __eq__(self, other):\n",
    "        return self.index == other.index\n",
    "    \n",
    "one = Humanumba2('one')\n",
    "another_one = Humanumba2('one')\n",
    "\n",
    "one == another_one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zero = Humanumba2('zero')\n",
    "\n",
    "zero < one"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's fix that too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Humanumba3(Humanumba2):\n",
    "    def __lt__(self, other):\n",
    "        return self.index < other.index\n",
    "    \n",
    "    def __le__(self, other):\n",
    "        return self.index <= other.index    \n",
    "    \n",
    "    def __gt__(self, other):\n",
    "        return self.index > other.index\n",
    "    \n",
    "    def __ge__(self, other):\n",
    "        return self.index >= other.index\n",
    "\n",
    "zero = Humanumba3('zero')\n",
    "one = Humanumba3('one')\n",
    "two = Humanumba3('two')\n",
    "\n",
    "zero < one < two"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Humanumba is actually a number in it's core, let's allow to compare to numeric types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Humanumba4('one')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Humanumba4(Humanumba3):\n",
    "    def __lt__(self, other):\n",
    "        index = other if isinstance(other, (int, float)) else other.index    \n",
    "        return self.index < index\n",
    "    \n",
    "    def __le__(self, other):\n",
    "        index = other if isinstance(other, (int, float)) else other.index\n",
    "        return self.index <= index    \n",
    "    \n",
    "    def __gt__(self, other):\n",
    "        index = other if isinstance(other, (int, float)) else other.index\n",
    "        return self.index > index\n",
    "    \n",
    "    def __ge__(self, other):\n",
    "        index = other if isinstance(other, (int, float)) else other.index        \n",
    "        return self.index >= index\n",
    "    \n",
    "one = Humanumba4('one')\n",
    "one"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.16"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}