lectures/Lecture26.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "74750d32",
   "metadata": {
    "id": "74750d32",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Programming with Python\n",
    "\n",
    "## Lecture 26: OOP - Multiple inheritance and polymorphism\n",
    "\n",
    "### Armen Gabrielyan\n",
    "\n",
    "#### Yerevan State University\n",
    "#### Portmind"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "936d0f99",
   "metadata": {
    "id": "936d0f99",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Multiple inheritance\n",
    "\n",
    "Python supports a form of multiple inheritance.\n",
    "\n",
    "```python\n",
    "class DerivedClassName(Base1, Base2, Base3):\n",
    "    <statement_1>\n",
    "    .\n",
    "    .\n",
    "    .\n",
    "    <statement_N>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1c07700",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "a1c07700",
    "outputId": "d32cff3f-1a80-4ebf-c2b9-67b740ed414e",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    def speak_as_animal(self):\n",
    "        return \"I am animal\"\n",
    "    \n",
    "class Mammal:\n",
    "    def speak_as_mammal(self):\n",
    "        return \"I am mammal\"\n",
    "    \n",
    "class Cat(Animal, Mammal):\n",
    "    def speak_as_cat(self):\n",
    "        return \"I am cat\"\n",
    "    \n",
    "cat = Cat()\n",
    "print(cat.speak_as_animal())\n",
    "print(cat.speak_as_mammal())\n",
    "print(cat.speak_as_cat())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de824f81",
   "metadata": {
    "id": "de824f81",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Method resolution order (MRO)\n",
    "\n",
    "**Method resolution order (MRO)** is the order in which base classes are searched for a member during lookup. It is used to resolve a method or a property.\n",
    "\n",
    "Class MRO can be accessed by `__mro__` attribute or `mro()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e16e7827",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "e16e7827",
    "outputId": "53074bf6-554f-457e-a847-19acc6153707",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Cat.__mro__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c386c1e0",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "c386c1e0",
    "outputId": "2af0c7db-403d-4ee3-cb3c-c2d972e99e0b",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Cat.mro()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "041fb586",
   "metadata": {
    "id": "041fb586",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Mixin class\n",
    "\n",
    "A mixin is a class that provides methods to other classes but is not considered a base class. It does not care about its position in the class hierarchy and usually provides convenience methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64def4bb",
   "metadata": {
    "id": "64def4bb",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class PerimeterMixin:\n",
    "    def calculate_perimeter(self):\n",
    "        perimeter = 0\n",
    "        for side in self.sides:\n",
    "            perimeter += side\n",
    "        return perimeter\n",
    "        \n",
    "\n",
    "class Polygon:\n",
    "    def __init__(self, sides):\n",
    "        self._sides = sides\n",
    "        \n",
    "    @property\n",
    "    def sides(self):\n",
    "        return self._sides\n",
    "    \n",
    "\n",
    "class Rectangle(Polygon, PerimeterMixin):\n",
    "    def __init__(self, width, length):\n",
    "        super().__init__([width, length, width, length])\n",
    "\n",
    "class Triangle(Polygon, PerimeterMixin):\n",
    "    def __init__(self, side_1, side_2, side_3):\n",
    "        super().__init__([side_1, side_2, side_3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1510470",
   "metadata": {
    "id": "f1510470",
    "outputId": "1febf328-852f-49a0-b21c-a6c974e2d09d",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "rectangle = Rectangle(3, 4)\n",
    "rectangle.calculate_perimeter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64186c1e",
   "metadata": {
    "id": "64186c1e",
    "outputId": "55bc746a-1999-42b8-815d-81d533ccb386",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "triangle = Triangle(3, 4, 5)\n",
    "triangle.calculate_perimeter()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc903ec1",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Polymorphism\n",
    "\n",
    "**Polymorphism** is the concept of offering a unified interface or symbol that can be used to interact with entities of various types. In object-oriented programming that allows objects of different types to be treated as if they are of the same type. The idea is derived from a biological principle that states an organism or species can exist in various shapes or phases.\n",
    "\n",
    "In Python, it is usually achieved via inheritance and method / operator overloading."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa7c7ab6",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Operator polymorphism\n",
    "\n",
    "**Operator polymorphism**, also referred to as **operator overloading**, denotes the capability of using a single symbol to carry out various operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d92d813",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "10 + 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a79f33d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "\"Hello\" + \" \" + \"world!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b587bada",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "[1, 2, 3] + [4, 5, 6]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5f8549b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Function polymorphism\n",
    "\n",
    "Functions can be polymorphic, meaning that they can operate on various data types and structures, resulting in different kinds of outputs.\n",
    "\n",
    "`len()` is such an example in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7783bdc",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "len(\"Hello world!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0c55841",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "len([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2c8c1bd",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "len({\n",
    "    \"name\": \"John Doe\",\n",
    "    \"age\": 42\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59fc09f4",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Class polymorphism\n",
    "\n",
    "The following three classes, i.e. `Person`, `Square` and `Wine`, are all unrelated to each other, but they all have a method called `info()`. When the `info()` method is called on an object, the appropriate version of the method is invoked based on the actual object type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddbef250",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def info(self):\n",
    "        print(\"This is the Person class\")\n",
    "        \n",
    "        \n",
    "class Square:\n",
    "    def info(self):\n",
    "        print(\"This is the Square class\")\n",
    "        \n",
    "        \n",
    "class Wine:\n",
    "    def info(self):\n",
    "        print(\"This is the Wine class\")\n",
    "        \n",
    "\n",
    "person = Person()\n",
    "square = Square()\n",
    "wine = Wine()\n",
    "\n",
    "for obj in [person, square, wine]:\n",
    "    obj.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a344e4c7",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Inheritance class polymorphism\n",
    "\n",
    "In the following example, the `Animal` class is the base class, and the `Dog` and `Cat` classes are its subclasses. Each subclass overrides the `sound()` method of the `Animal` class with its own implementation. When the `sound()` method is called on an object, the appropriate version of the method is invoked based on the actual object type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5c17e52",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    def sound(self):\n",
    "        print(\"Animal makes a sound\")\n",
    "\n",
    "class Dog(Animal):\n",
    "    def sound(self):\n",
    "        print(\"Dog barks\")\n",
    "\n",
    "class Cat(Animal):\n",
    "    def sound(self):\n",
    "        print(\"Cat meows\")\n",
    "\n",
    "\n",
    "animal = Animal()\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "\n",
    "for obj in [animal, dog, cat]:\n",
    "    obj.sound()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5cf3d8c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Operator overloading\n",
    "\n",
    "**Operator overloading** allows you to define how operators and operations behave when applied to objects of custom classes. By overloading operators, you can provide custom implementations for operations like addition, subtraction, multiplication, comparison, and more. This enables you to make your objects behave intuitively with built-in operators.\n",
    "\n",
    "To overload an operator in Python, you need to define a special method within your class that corresponds to the operator you want to overload. These methods have predefined names and are called **magic methods**, **special methods** or **dunder methods**. They are in the following form: `__<method_name>__`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85939f13",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# `str()` and `repr()` functions\n",
    "\n",
    "- `repr()`: Returns a string containing a printable representation of an object. It is usually defined for programmers.\n",
    "- `str()`: Return a string version of object. It is usually defined for users."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afb7deb9",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "number = 42\n",
    "\n",
    "str(number), repr(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eca63429",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "seq = [1, 2, 3]\n",
    "\n",
    "str(seq), repr(seq)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e1666cb",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Vector class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "504d55e0",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    def __init__(self, x, y):\n",
    "        self._x = x\n",
    "        self._y = y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e80d6e3",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector = Vector(-1, 2)\n",
    "\n",
    "print(vector)\n",
    "print(str(vector))\n",
    "print(repr(vector))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52495cce",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    def __init__(self, x, y):\n",
    "        self._x = x\n",
    "        self._y = y\n",
    "        \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return f\"{class_name}(x={self._x!r}, y={self._y!r})\"\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"({self._x}, {self._y})\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9553ea52",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector = Vector(-1, 2)\n",
    "vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84b7cb9d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(vector)\n",
    "print(str(vector))\n",
    "print(repr(vector))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "637912bf",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Unary operators\n",
    "\n",
    "- `__neg__`: arithmetic unary negation (`-x`).\n",
    "- `__pos__`: arithmetic unary plus (`+x`).\n",
    "-  `__invert__`: bitwise not, or bitwise inverse of an integer (`~x`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33d6720b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    def __init__(self, x, y):\n",
    "        self._x = x\n",
    "        self._y = y\n",
    "    \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return f\"{class_name}(x={self._x!r}, y={self._y!r})\"\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"({self._x}, {self._y})\"\n",
    "    \n",
    "    def __pos__(self):\n",
    "        return Vector(self._x, self._y)\n",
    "    \n",
    "    def __neg__(self):\n",
    "        return Vector(-self._x, -self._y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1411eb8b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector = Vector(1, -2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e888655c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "+vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5796fa1f",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "-vector"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03d0b127",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Overloading `+` for vector addition and `-` for vector substraction\n",
    "\n",
    "- `__add__`: addition (`x + y`).\n",
    "- `__sub__`: substraction (`x - y`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4251179c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    def __init__(self, x, y):\n",
    "        self._x = x\n",
    "        self._y = y\n",
    "    \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return f\"{class_name}(x={self._x!r}, y={self._y!r})\"\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"({self._x}, {self._y})\"\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        return Vector(self._x + other._x, self._y + other._y)\n",
    "\n",
    "    def __sub__(self, other):\n",
    "        return Vector(self._x - other._x, self._y - other._y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "058a0355",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector1 = Vector(1, -2)\n",
    "vector2 = Vector(3, -4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5921ce55",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector1 + vector2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30697e6f",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector1 - vector2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b200235",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Overloading `*` for scalar multiplication\n",
    "\n",
    "- `__mul__`: multiplication (`x * scalar`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ff6c85d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    def __init__(self, x, y):\n",
    "        self._x = x\n",
    "        self._y = y\n",
    "    \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return f\"{class_name}(x={self._x!r}, y={self._y!r})\"\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"({self._x}, {self._y})\"\n",
    "    \n",
    "    def __mul__(self, scalar):\n",
    "        return Vector(self._x * scalar, self._y * scalar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dcc0dfc7",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector = Vector(1, -2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8aba5100",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d1af7ef",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "2 * vector"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7de36bf4",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Overloading `*` for reverse scalar multiplication\n",
    "\n",
    "- `__rmul__`: reverse multiplication (`scalar * x`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d895fc40",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    def __init__(self, x, y):\n",
    "        self._x = x\n",
    "        self._y = y\n",
    "    \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return f\"{class_name}(x={self._x!r}, y={self._y!r})\"\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"({self._x}, {self._y})\"\n",
    "    \n",
    "    def __mul__(self, scalar):\n",
    "        return Vector(self._x * scalar, self._y * scalar)\n",
    "    \n",
    "    def __rmul__(self, scalar):\n",
    "        return self * scalar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "280ce875",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector = Vector(1, -2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95d1e783",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "2 * vector"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba475d65",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Overloading comparison operators\n",
    "\n",
    "- `__eq__`: is equal to (`x == y`)\n",
    "- `__ne__`: is not equal to (`x != y`)\n",
    "- `__gt__`: greater than (`x > y`)\n",
    "- `__lt__`: less than (`x < y`)\n",
    "- `__ge__`: greater than or equal to (`x >= y`)\n",
    "- `__le__`: less than or equal to (`x <= y`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0ca1a66",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    def __init__(self, x, y):\n",
    "        self._x = x\n",
    "        self._y = y\n",
    "    \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return f\"{class_name}(x={self._x!r}, y={self._y!r})\"\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"({self._x}, {self._y})\"\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return self._x == other._x and self._y == other._y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0c479cc",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector1 = Vector(1, 2)\n",
    "vector2 = Vector(1, 2)\n",
    "\n",
    "vector1 == vector2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a6dacfd",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector1 = Vector(1, -2)\n",
    "vector2 = Vector(3, -4)\n",
    "\n",
    "vector1 == vector2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a037ace3",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector1 != vector2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eef79159",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Overloading `len()` and `abs()` functions\n",
    "\n",
    "- `__len__()`: implements the built-in function `len()`.\n",
    "- `__abs__()`: implements the built-in function `abs()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff4e49e7",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    def __init__(self, components):\n",
    "        self._components = components\n",
    "    \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return f\"{class_name}({self._components!r})\"\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self._components)\n",
    "    \n",
    "    def __abs__(self):\n",
    "        return sum(component ** 2for component in self._components) ** 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "314a4a0c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector = Vector([4, 2, 8, 7])\n",
    "vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "761bbbc9",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "len(vector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5738d1a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "abs(vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30fbab82",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Overloading evaluation and assignment of `self[key]`\n",
    "\n",
    "- `__getitem__(self, key)`: access element at `key` index.\n",
    "- `__setitem__(self, key, value)`: assign `value` to element at `key` index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b586992d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    def __init__(self, components):\n",
    "        self._components = components\n",
    "    \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return f\"{class_name}({self._components!r})\"\n",
    "    \n",
    "    def __getitem__(self, key):\n",
    "        return self._components[key]\n",
    "    \n",
    "    def __setitem__(self, key, value):\n",
    "        self._components[key] = value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85d960d1",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector = Vector([4, 2, 8, 7])\n",
    "vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a6fec64",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(vector[0])\n",
    "print(vector[1])\n",
    "print(vector[2])\n",
    "print(vector[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3465f486",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector[2] = -11\n",
    "\n",
    "vector"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0fb1d95",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Polynomial class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ced1820",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Polynomial:\n",
    "    def __init__(self, coefficients):\n",
    "        \"\"\"\n",
    "        Initialize a Polynomial object with a list of coefficients.\n",
    "        The coefficients should be in descending order of their degrees.\n",
    "        For example, the coefficients [2, -1, 3] represent the polynomial 2 - x + 3x^2.\n",
    "        \"\"\"\n",
    "        self._coefficients = coefficients\n",
    "\n",
    "    def degree(self):\n",
    "        \"\"\"\n",
    "        Return the degree of the polynomial.\n",
    "        \"\"\"\n",
    "        return len(self._coefficients) - 1\n",
    "\n",
    "    def __add__(self, other):\n",
    "        \"\"\"\n",
    "        Add two polynomials and return a new Polynomial object representing their sum.\n",
    "        \"\"\"\n",
    "        if self.degree() >= other.degree():\n",
    "            larger_poly = self._coefficients\n",
    "            smaller_poly = other._coefficients\n",
    "        else:\n",
    "            larger_poly = other._coefficients\n",
    "            smaller_poly = self._coefficients\n",
    "\n",
    "        sum_coefficients = []\n",
    "        for i in range(len(larger_poly)):\n",
    "            if i < len(smaller_poly):\n",
    "                sum_coefficients.append(larger_poly[i] + smaller_poly[i])\n",
    "            else:\n",
    "                sum_coefficients.append(larger_poly[i])\n",
    "\n",
    "        return Polynomial(sum_coefficients)\n",
    "\n",
    "    def __mul__(self, other):\n",
    "        \"\"\"\n",
    "        Multiply two polynomials and return a new Polynomial object representing their product.\n",
    "        \"\"\"\n",
    "        product_degree = self.degree() + other.degree()\n",
    "        product_coefficients = [0] * (product_degree + 1)\n",
    "\n",
    "        for i in range(len(self._coefficients)):\n",
    "            for j in range(len(other._coefficients)):\n",
    "                product_coefficients[i + j] += self._coefficients[i] * other._coefficients[j]\n",
    "\n",
    "        return Polynomial(product_coefficients)\n",
    "\n",
    "    def __repr__(self):\n",
    "        \"\"\"\n",
    "        Return a string representation of the polynomial.\n",
    "        \"\"\"\n",
    "        terms = []\n",
    "        for i, coefficient in enumerate(self._coefficients):\n",
    "            if coefficient != 0:\n",
    "                if i == 0:\n",
    "                    terms.append(str(coefficient))\n",
    "                elif i == 1:\n",
    "                    terms.append(f\"{coefficient}x\")\n",
    "                else:\n",
    "                    terms.append(f\"{coefficient}x^{i}\")\n",
    "        return \" + \".join(terms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9559d83",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "polynomial1 = Polynomial([2, -1, 3])\n",
    "polynomial2 = Polynomial([1, 2, -1])\n",
    "\n",
    "print(f\"p(x) = {polynomial1}\")\n",
    "print(f\"q(x) = {polynomial2}\")\n",
    "print(f\"p(x) + q(x) = {polynomial1 + polynomial2}\")\n",
    "print(f\"p(x) * q(x) = {polynomial1 * polynomial2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6aa85e5",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Reference\n",
    "\n",
    "For more special methods, see https://docs.python.org/3/reference/datamodel.html#special-method-names."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}