code/18-oop-concepts.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "📝 **Author:** Amirhossein Heydari - 📧 **Email:** <amirhosseinheydari78@gmail.com> - 📍 **Origin:** [mr-pylin/python-workshop](https://github.com/mr-pylin/python-workshop)\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Table of contents**<a id='toc0_'></a>    \n",
    "- [OOP Concepts](#toc1_)    \n",
    "  - [Inheritance](#toc1_1_)    \n",
    "    - [Overriding Methods](#toc1_1_1_)    \n",
    "    - [Method Resolution Order (MRO)](#toc1_1_2_)    \n",
    "    - [Composition and Aggregation](#toc1_1_3_)    \n",
    "    - [Types of Inheritance](#toc1_1_4_)    \n",
    "      - [Single Inheritance](#toc1_1_4_1_)    \n",
    "      - [Multilevel Inheritance](#toc1_1_4_2_)    \n",
    "      - [Multiple Inheritance](#toc1_1_4_3_)    \n",
    "        - [Mixins](#toc1_1_4_3_1_)    \n",
    "        - [Diamond Problem](#toc1_1_4_3_2_)    \n",
    "      - [Hierarchical Inheritance](#toc1_1_4_4_)    \n",
    "      - [Hybrid Inheritance](#toc1_1_4_5_)    \n",
    "  - [Encapsulation](#toc1_2_)    \n",
    "    - [Types of Modifiers](#toc1_2_1_)    \n",
    "    - [Access Controllers](#toc1_2_2_)    \n",
    "    - [Descriptors](#toc1_2_3_)    \n",
    "  - [Abstraction](#toc1_3_)    \n",
    "  - [Polymorphism](#toc1_4_)    \n",
    "    - [Polymorphism with Functions](#toc1_4_1_)    \n",
    "    - [Polymorphism with Classes (Method Overriding)](#toc1_4_2_)    \n",
    "    - [Polymorphism with Abstract Base Classes](#toc1_4_3_)    \n",
    "    - [Duck Typing in Python](#toc1_4_4_)    \n",
    "\n",
    "<!-- vscode-jupyter-toc-config\n",
    "\tnumbering=false\n",
    "\tanchor=true\n",
    "\tflat=false\n",
    "\tminLevel=1\n",
    "\tmaxLevel=6\n",
    "\t/vscode-jupyter-toc-config -->\n",
    "<!-- THIS CELL WILL BE REPLACED ON TOC UPDATE. DO NOT WRITE YOUR TEXT IN THIS CELL -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc1_'></a>[OOP Concepts](#toc0_)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_1_'></a>[Inheritance](#toc0_)\n",
    "\n",
    "- It allows a class **(subclass / child class)** to inherit *attributes* and *methods* from another class **(superclass / parent class)**.\n",
    "- Inheritance provides a way to reuse code, extend functionality, and improve the organization of complex programs.\n",
    "\n",
    "✍️ **Key Concepts**:\n",
    "\n",
    "- **Superclass/Parent Class**: The class whose properties and methods are inherited by another class.\n",
    "- **Subclass/Child Class**: The class that inherits the properties and methods from the superclass.\n",
    "- **Method Overriding**: The ability to redefine methods in the subclass that were inherited from the superclass.\n",
    "- **`super()`**: A function that allows you to call methods from the superclass inside the subclass.\n",
    "\n",
    "🆚 **Other Concepts**:\n",
    "\n",
    "- Composition\n",
    "  - Strong \"Has-A\" Relationship\n",
    "  - The lifecycle of the contained object (the part) depends on the lifecycle of the containing object (the whole).\n",
    "  - In other words, If the container object is destroyed, the part object is also destroyed.\n",
    "  - The contained object cannot exist independently of the container.\n",
    "- Aggregation\n",
    "  - Weak \"Has-A\" Relationship\n",
    "  - The lifecycle of the contained object (the part) is independent of the lifecycle of the containing object (the whole).\n",
    "  - In other words, the contained object can exist on its own even if the container object is destroyed.\n",
    "\n",
    "😲 **Special class called `object`**:\n",
    "\n",
    "- `object` is a special class that serves as the **base class** for all classes.\n",
    "- This means that every class in Python implicitly inherits from `object`.\n",
    "- More details are in [Special Methods]() notebook.\n",
    "\n",
    "<figure style=\"text-align: center;\">\n",
    "  <img src=\"../assets/images/svgs/oop-composition-aggregation-inheritance.svg\" alt=\"oop-composition-aggregation-inheritance.svg\" style=\"width: 75%;\">\n",
    "  <figcaption style=\"text-align:center;\">Inheritance vs. Composition vs. Aggregation</figcaption>\n",
    "</figure>\n",
    "\n",
    "📝 **Docs**:\n",
    "\n",
    "- Inheritance: [docs.python.org/3/tutorial/classes.html#inheritance](https://docs.python.org/3/tutorial/classes.html#inheritance)\n",
    "- Private Variables: [docs.python.org/3/tutorial/classes.html#private-variables](https://docs.python.org/3/tutorial/classes.html#private-variables)\n",
    "- Descriptor Guide: [docs.python.org/3/howto/descriptor.html](https://docs.python.org/3/howto/descriptor.html)\n",
    "- `type.mro()`: [docs.python.org/3/reference/datamodel.html#type.mro](https://docs.python.org/3/reference/datamodel.html#type.mro)\n",
    "- class `super`: [docs.python.org/3.12/library/functions.html#super](https://docs.python.org/3.12/library/functions.html#super)\n",
    "- `isinstance()`: [docs.python.org/3/library/functions.html#isinstance](https://docs.python.org/3/library/functions.html#isinstance)\n",
    "- `issubclass()`: [docs.python.org/3/library/functions.html#issubclass](https://docs.python.org/3/library/functions.html#issubclass)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_1_'></a>[Overriding Methods](#toc0_)\n",
    "\n",
    "- A subclass can override a method from its superclass to provide a specific implementation.\n",
    "- This is one of the most important features of inheritance.\n",
    "\n",
    "✍️ **Notes**:\n",
    "\n",
    "- If you still want to access the parent class’s method, you can use `super()`.\n",
    "- `super()` is used to call a method from the parent class.\n",
    "- In multiple inheritance, `super()` follows the **MRO**, allowing you to call the next method in the hierarchy rather than referencing the immediate parent.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal sound\n"
     ]
    }
   ],
   "source": [
    "# parent class\n",
    "class Animal:\n",
    "    def speak(self) -> str:\n",
    "        return \"Animal sound\"\n",
    "\n",
    "\n",
    "# initialization\n",
    "animal_1 = Animal()\n",
    "\n",
    "# log\n",
    "print(animal_1.speak())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bark!\n"
     ]
    }
   ],
   "source": [
    "# child class (inherited from Animal class)\n",
    "class Dog(Animal):\n",
    "\n",
    "    # override <speak> method\n",
    "    def speak(self) -> str:\n",
    "        return \"Bark!\"\n",
    "\n",
    "\n",
    "# initialization\n",
    "dog_1 = Dog()\n",
    "\n",
    "# log\n",
    "print(dog_1.speak())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal sound , Bark!\n"
     ]
    }
   ],
   "source": [
    "# using super() to call the overridden method of the parent class\n",
    "class Dog(Animal):\n",
    "\n",
    "    # override <speak> method\n",
    "    def speak(self) -> str:\n",
    "        return f\"{super().speak()} , Bark!\"\n",
    "\n",
    "\n",
    "# initialization\n",
    "dog_1 = Dog()\n",
    "\n",
    "# log\n",
    "print(dog_1.speak())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_2_'></a>[Method Resolution Order (MRO)](#toc0_)\n",
    "\n",
    "- In cases where multiple inheritance is used, Python uses **MRO** to determine the order in which parent classes are searched when executing a method.\n",
    "- Python uses the [C3 Linearization Algorithm](https://en.wikipedia.org/wiki/C3_linearization) to decide the MRO, which ensures a consistent and predictable order.\n",
    "- The `mro()` method or the `__mro__` attribute shows the order in which methods are resolved.\n",
    "\n",
    "✍️ **Notes**:\n",
    "\n",
    "- A chain of inheritance has a linear order.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A.mro() : [<class '__main__.A'>, <class 'object'>]\n",
      "B.mro() : [<class '__main__.B'>, <class '__main__.A'>, <class 'object'>]\n",
      "C.mro() : [<class '__main__.C'>, <class '__main__.A'>, <class 'object'>]\n"
     ]
    }
   ],
   "source": [
    "# parent class\n",
    "class A:\n",
    "    pass\n",
    "\n",
    "\n",
    "# child class\n",
    "class B(A):\n",
    "    pass\n",
    "\n",
    "\n",
    "# child class\n",
    "class C(A):\n",
    "    pass\n",
    "\n",
    "\n",
    "# log\n",
    "print(f\"A.mro() : {A.mro()}\")\n",
    "print(f\"B.mro() : {B.mro()}\")\n",
    "print(f\"C.mro() : {C.mro()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_3_'></a>[Composition and Aggregation](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Salary:\n",
    "    def __init__(self, pay: int):\n",
    "        self.pay = pay\n",
    "\n",
    "    def get_total(self) -> int:\n",
    "        return self.pay * 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Salary: 12100'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# composition: Salary is a part of Employee\n",
    "class Employee:\n",
    "    def __init__(self, pay: int, bonus: int):\n",
    "        self.pay = pay\n",
    "        self.bonus = bonus\n",
    "        self.obj_salary = Salary(self.pay)\n",
    "\n",
    "    def annual_salary(self) -> str:\n",
    "        return f\"Salary: {self.obj_salary.get_total() + self.bonus}\"\n",
    "\n",
    "\n",
    "# initialization\n",
    "obj_emp = Employee(1000, 100)\n",
    "\n",
    "# log\n",
    "obj_emp.annual_salary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Salary: 12100'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# aggregation: Salary is NOT a part of Employee\n",
    "class Employee:\n",
    "    def __init__(self, pay: int, bonus: int):\n",
    "        self.pay = pay\n",
    "        self.bonus = bonus\n",
    "\n",
    "    def annual_salary(self) -> str:\n",
    "        return f\"Salary: {self.pay.get_total() + self.bonus}\"\n",
    "\n",
    "\n",
    "# initialization\n",
    "salary = Salary(1000)\n",
    "emp1 = Employee(salary, 100)\n",
    "\n",
    "# log\n",
    "emp1.annual_salary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_4_'></a>[Types of Inheritance](#toc0_)\n",
    "\n",
    "<figure style=\"text-align: center;\">\n",
    "  <img src=\"../assets/images/svgs/oop-inheritance-types.svg\" alt=\"oop-inheritance-types.svg\" style=\"width: 75%;\">\n",
    "  <figcaption style=\"text-align:center;\">Types of Inheritance</figcaption>\n",
    "</figure>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <a id='toc1_1_4_1_'></a>[Single Inheritance](#toc0_)\n",
    "\n",
    "- A subclass inherits from only one superclass.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jack\n",
      "Mack\n",
      "Jack - Mack\n"
     ]
    }
   ],
   "source": [
    "# parent class\n",
    "class Person:\n",
    "    def __init__(self, first: str, last: str):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "\n",
    "    def get_info(self) -> str:\n",
    "        return f\"{self.first} - {self.last}\"\n",
    "\n",
    "\n",
    "# initialization\n",
    "person_1 = Person(\"Jack\", \"Mack\")\n",
    "\n",
    "# log\n",
    "print(person_1.first)\n",
    "print(person_1.last)\n",
    "print(person_1.get_info())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Morty - Smith'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# child class [not recommended]\n",
    "class Student(Person):\n",
    "    def __init__(self, first: str, last: str, age: int):\n",
    "        self.first = first  # ❌\n",
    "        self.last = last  # ❌\n",
    "        self.age = age\n",
    "\n",
    "\n",
    "# initialization\n",
    "student_1 = Student(\"Morty\", \"Smith\", 14)\n",
    "\n",
    "# log\n",
    "student_1.get_info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Morty - Smith'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# child class [not recommended]\n",
    "class Student(Person):\n",
    "    def __init__(self, first: str, last: str, age: int):\n",
    "        Person.__init__(self, first, last)  # directly calling the parent class is a kind of hard coding ❌\n",
    "        self.age = age\n",
    "\n",
    "\n",
    "# initialization\n",
    "student_1 = Student(\"Morty\", \"Smith\", 14)\n",
    "\n",
    "# log\n",
    "student_1.get_info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Morty - Smith'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# child class [recommended]\n",
    "class Student(Person):\n",
    "    def __init__(self, first: str, last: str, age: int):\n",
    "        super().__init__(first, last)  # compatible, cleaner, maintainable and flexible ✅\n",
    "        self.age = age\n",
    "\n",
    "\n",
    "# initialization\n",
    "student_2 = Student(\"Morty\", \"Smith\", 14)\n",
    "\n",
    "# log\n",
    "student_2.get_info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "polygon_1.sides         : (3, 3, 3, 3, 3, 3)\n",
      "polygon_1.who_am_i()    : Regular Polygon\n",
      "polygon_1.area()        : 4.164789146964769\n",
      "polygon_1.perimeter()   : 18\n",
      "\n",
      "rectangle_1.sides       : (4, 4, 7, 7)\n",
      "rectangle_1.who_am_i()  : Irregular Quadrilateral\n",
      "rectangle_1.area()      : 28\n",
      "rectangle_1.perimeter() : 22\n",
      "\n",
      "square_1.sides          : (3, 3, 3, 3)\n",
      "square_1.who_am_i()     : Regular Quadrilateral\n",
      "square_1.area()         : 9\n",
      "square_1.perimeter()    : 12\n",
      "\n",
      "square_2.sides          : (3, 3, 3, 3)\n",
      "square_2.who_am_i()     : Regular Quadrilateral\n",
      "square_2.area()         : 9.0\n",
      "square_2.perimeter()    : 12\n"
     ]
    }
   ],
   "source": [
    "# a comprehensive example\n",
    "from math import sin\n",
    "\n",
    "\n",
    "class Polygon:\n",
    "    def __init__(self, *sides: float):\n",
    "        self.sides = sides\n",
    "        self.total_sides = len(sides)\n",
    "\n",
    "        if len(set(sides)) == 1:\n",
    "            self.type = \"Regular\"\n",
    "        else:\n",
    "            self.type = \"Irregular\"\n",
    "\n",
    "        if len(sides) < 3:\n",
    "            raise ValueError(f\"{self.total_sides} < 3\")\n",
    "\n",
    "    def who_am_i(self) -> str:\n",
    "        match self.total_sides:\n",
    "            case 3:\n",
    "                return f\"{self.type} Triangle\"\n",
    "            case 4:\n",
    "                return f\"{self.type} Quadrilateral\"\n",
    "            case _:\n",
    "                return f\"{self.type} Polygon\"\n",
    "\n",
    "    def area(self) -> float | str:\n",
    "        if self.type == \"Regular\":\n",
    "            base = self.sides[0]\n",
    "            deg = 360 / self.total_sides / 2\n",
    "            deg_2 = 180 - 90 - deg\n",
    "            apothem = (base * sin(deg_2)) / (sin(deg) * 2)\n",
    "            return (apothem * self.perimeter()) / 2\n",
    "        else:\n",
    "            return \"ERROR: area cannot be calculated.\"\n",
    "\n",
    "    def perimeter(self) -> int:\n",
    "        return sum(self.sides)\n",
    "\n",
    "\n",
    "class Rectangle(Polygon):\n",
    "    def __init__(self, length: int, width: int):\n",
    "        super().__init__(length, length, width, width)\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "\n",
    "    def area(self) -> int:\n",
    "        return self.length * self.width\n",
    "\n",
    "\n",
    "class Square(Rectangle):\n",
    "    def __init__(self, side: float):\n",
    "        super().__init__(side, side)\n",
    "\n",
    "\n",
    "# initialization\n",
    "polygon_1 = Polygon(3, 3, 3, 3, 3, 3)\n",
    "rectangle_1 = Rectangle(4, 7)\n",
    "square_1 = Square(3)\n",
    "square_2 = Polygon(3, 3, 3, 3)\n",
    "\n",
    "# log\n",
    "print(f\"polygon_1.sides         : {polygon_1.sides}\")\n",
    "print(f\"polygon_1.who_am_i()    : {polygon_1.who_am_i()}\")\n",
    "print(f\"polygon_1.area()        : {polygon_1.area()}\")\n",
    "print(f\"polygon_1.perimeter()   : {polygon_1.perimeter()}\\n\")\n",
    "\n",
    "print(f\"rectangle_1.sides       : {rectangle_1.sides}\")\n",
    "print(f\"rectangle_1.who_am_i()  : {rectangle_1.who_am_i()}\")\n",
    "print(f\"rectangle_1.area()      : {rectangle_1.area()}\")\n",
    "print(f\"rectangle_1.perimeter() : {rectangle_1.perimeter()}\\n\")\n",
    "\n",
    "print(f\"square_1.sides          : {square_1.sides}\")\n",
    "print(f\"square_1.who_am_i()     : {square_1.who_am_i()}\")\n",
    "print(f\"square_1.area()         : {square_1.area()}\")\n",
    "print(f\"square_1.perimeter()    : {square_1.perimeter()}\\n\")\n",
    "\n",
    "print(f\"square_2.sides          : {square_2.sides}\")\n",
    "print(f\"square_2.who_am_i()     : {square_2.who_am_i()}\")\n",
    "print(f\"square_2.area()         : {square_2.area()}\")\n",
    "print(f\"square_2.perimeter()    : {square_2.perimeter()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <a id='toc1_1_4_2_'></a>[Multilevel Inheritance](#toc0_)\n",
    "\n",
    "- A subclass inherits from another subclass, creating a chain of inheritance.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# base class (grandparent)\n",
    "class LivingBeing:\n",
    "    def __init__(self, name: str):\n",
    "        self.name = name\n",
    "\n",
    "    def breathe(self) -> str:\n",
    "        return f\"{self.name} is breathing.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Derived class (parent) inherits from LivingBeing\n",
    "class Animal(LivingBeing):\n",
    "    def __init__(self, name: str, species: str):\n",
    "        super().__init__(name)  # call the parent class (LivingBeing) constructor\n",
    "        self.species = species\n",
    "\n",
    "    def move(self) -> str:\n",
    "        return f\"{self.name}, the {self.species}, is moving.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# further derived class (child) inherits from Animal\n",
    "class Dog(Animal):\n",
    "    def __init__(self, name: str, breed: str):\n",
    "        super().__init__(name, \"Dog\")  # call the parent class (Animal) constructor\n",
    "        self.breed = breed\n",
    "\n",
    "    def bark(self) -> str:\n",
    "        return f\"{self.name}, the {self.breed}, is barking.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dog.breathe() : Buddy is breathing.\n",
      "dog.move()    : Buddy, the Dog, is moving.\n",
      "dog.bark()    : Buddy, the Golden Retriever, is barking.\n"
     ]
    }
   ],
   "source": [
    "# creating an instance of the Dog class\n",
    "dog = Dog(\"Buddy\", \"Golden Retriever\")\n",
    "\n",
    "# log\n",
    "print(f\"dog.breathe() : {dog.breathe()}\")\n",
    "print(f\"dog.move()    : {dog.move()}\")\n",
    "print(f\"dog.bark()    : {dog.bark()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <a id='toc1_1_4_3_'></a>[Multiple Inheritance](#toc0_)\n",
    "\n",
    "- A subclass can inherit from more than one superclass.\n",
    "\n",
    "⚠️ **Potential Issues**:\n",
    "\n",
    "- In multiple inheritance, determining the order in which classes are searched when a method or attribute is accessed can be complicated (MRO).\n",
    "- Deadly diamond of death (diamond problem)\n",
    "  - This occurs when a class inherits from two classes that both inherit from the same base class.\n",
    "  - The ambiguity arises when both parent classes define a method with the same name.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# grandparent class\n",
    "class Person:\n",
    "    def __init__(self, name: str, age: int):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def introduce(self) -> str:\n",
    "        return f\"Hi, I'm {self.name}, and I'm {self.age} years old.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# parent class 1\n",
    "class Employee(Person):\n",
    "    def __init__(self, name: str, age: int, employee_id: str, position: str):\n",
    "        Person.__init__(self, name, age)  # call the constructor of Person\n",
    "        self.employee_id = employee_id\n",
    "        self.position = position\n",
    "\n",
    "    def work(self) -> str:\n",
    "        return f\"{self.name} is working as a {self.position}.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# parent class 2\n",
    "class Student(Person):\n",
    "    def __init__(self, name: str, age: int, student_id: str, major: str):\n",
    "        Person.__init__(self, name, age)  # call the constructor of Person\n",
    "        self.student_id = student_id\n",
    "        self.major = major\n",
    "\n",
    "    def study(self) -> str:\n",
    "        return f\"{self.name} is studying {self.major}.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# subclass (inherits from both parents)\n",
    "class Intern(Employee, Student):\n",
    "    def __init__(self, name: str, age: int, employee_id: str, position: str, student_id: str, major: str):\n",
    "        Employee.__init__(self, name, age, employee_id, position)  # initialize Employee (which calls Person internally)\n",
    "        Student.__init__(self, name, age, student_id, major)  # initialize Student  (which also calls Person internally)\n",
    "\n",
    "    def intern_details(self) -> str:\n",
    "        return f\"Intern {self.name} is a {self.major} student and works as a {self.position}.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "intern.introduce()      : Hi, I'm John, and I'm 21 years old.\n",
      "intern.work()           : John is working as a Software Engineer.\n",
      "intern.study()          : John is studying Computer Science.\n",
      "intern.intern_details() : Intern John is a Computer Science student and works as a Software Engineer.\n",
      "Intern.mro()            : [<class '__main__.Intern'>, <class '__main__.Employee'>, <class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>]\n"
     ]
    }
   ],
   "source": [
    "# creating an instance of Intern\n",
    "intern = Intern(\"John\", 21, \"E123\", \"Software Engineer\", \"S456\", \"Computer Science\")\n",
    "\n",
    "# log\n",
    "print(f\"intern.introduce()      : {intern.introduce()}\")\n",
    "print(f\"intern.work()           : {intern.work()}\")\n",
    "print(f\"intern.study()          : {intern.study()}\")\n",
    "print(f\"intern.intern_details() : {intern.intern_details()}\")\n",
    "print(f\"Intern.mro()            : {Intern.mro()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### <a id='toc1_1_4_3_1_'></a>[Mixins](#toc0_)\n",
    "\n",
    "- Mixins are lightweight, reusable classes that provide methods and functionality to other classes but are not intended to **stand alone**.\n",
    "- It is intended to be mixed into other classes to add specific functionality without modifying or deeply coupling with the base class.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# base class\n",
    "class Person:\n",
    "    def __init__(self, name: str, age: int):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def introduce(self) -> str:\n",
    "        return f\"Hi, I'm {self.name}, and I'm {self.age} years old.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mixin for work behavior\n",
    "class WorkMixin:\n",
    "    def __init__(self, employee_id: str, position: str):\n",
    "        self.employee_id = employee_id\n",
    "        self.position = position\n",
    "\n",
    "    def work(self) -> str:\n",
    "        return f\"{self.name} is working as a {self.position}.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mixin for study behavior\n",
    "class StudyMixin:\n",
    "    def __init__(self, student_id: str, major: str):\n",
    "        self.student_id = student_id\n",
    "        self.major = major\n",
    "\n",
    "    def study(self) -> str:\n",
    "        return f\"{self.name} is studying {self.major}.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# subclass combining Person with mixins\n",
    "class Intern(Person, WorkMixin, StudyMixin):\n",
    "    def __init__(self, name: str, age: int, employee_id: str, position: str, student_id: str, major: str):\n",
    "        Person.__init__(self, name, age)  # initialize Person\n",
    "        WorkMixin.__init__(self, employee_id, position)  # initialize WorkMixin\n",
    "        StudyMixin.__init__(self, student_id, major)  # initialize StudyMixin\n",
    "\n",
    "    def intern_details(self) -> str:\n",
    "        return f\"Intern {self.name} is a {self.major} student and works as a {self.position}.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "intern.introduce()      : Hi, I'm John, and I'm 21 years old.\n",
      "intern.work()           : John is working as a Software Engineer.\n",
      "intern.study()          : John is studying Computer Science.\n",
      "intern.intern_details() : Intern John is a Computer Science student and works as a Software Engineer.\n"
     ]
    }
   ],
   "source": [
    "# initialization\n",
    "intern = Intern(\"John\", 21, \"E123\", \"Software Engineer\", \"S456\", \"Computer Science\")\n",
    "\n",
    "# log\n",
    "print(f\"intern.introduce()      : {intern.introduce()}\")\n",
    "print(f\"intern.work()           : {intern.work()}\")\n",
    "print(f\"intern.study()          : {intern.study()}\")\n",
    "print(f\"intern.intern_details() : {intern.intern_details()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### <a id='toc1_1_4_3_2_'></a>[Diamond Problem](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# base class\n",
    "class Animal:\n",
    "    def speak(self) -> str:\n",
    "        return \"Animal speaks\"\n",
    "\n",
    "\n",
    "# first derived class\n",
    "class Dog(Animal):\n",
    "    def speak(self) -> str:\n",
    "        return \"Bark\"\n",
    "\n",
    "\n",
    "# second derived class\n",
    "class Cat(Animal):\n",
    "    def speak(self) -> str:\n",
    "        return \"Meow\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bark\n"
     ]
    }
   ],
   "source": [
    "# diamond problem ⚠️\n",
    "class Hybrid(Dog, Cat):\n",
    "    pass\n",
    "\n",
    "\n",
    "# creating an instance of Hybrid\n",
    "hybrid = Hybrid()\n",
    "\n",
    "# log\n",
    "print(hybrid.speak())  # which method will be called?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bark and Meow\n"
     ]
    }
   ],
   "source": [
    "# solution for diamond problem\n",
    "class Hybrid(Dog, Cat):\n",
    "    def speak(self) -> str:\n",
    "        # explicitly call the method from the desired superclass\n",
    "        dog_sound = Dog.speak(self)\n",
    "        cat_sound = Cat.speak(self)\n",
    "        return f\"{dog_sound} and {cat_sound}\"\n",
    "\n",
    "\n",
    "# creating an instance of Hybrid\n",
    "hybrid = Hybrid()\n",
    "\n",
    "# log\n",
    "print(hybrid.speak())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <a id='toc1_1_4_4_'></a>[Hierarchical Inheritance](#toc0_)\n",
    "\n",
    "- Multiple subclasses inherit from the same superclass.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# base class (parent)\n",
    "class Vehicle:\n",
    "    def __init__(self, brand: str, model: str):\n",
    "        self.brand = brand\n",
    "        self.model = model\n",
    "\n",
    "    def start(self) -> str:\n",
    "        return f\"{self.brand} {self.model} is starting.\"\n",
    "\n",
    "    def stop(self) -> str:\n",
    "        return f\"{self.brand} {self.model} is stopping.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# derived class 1 (child) inherits from Vehicle\n",
    "class Car(Vehicle):\n",
    "    def __init__(self, brand: str, model: str, doors: int):\n",
    "        super().__init__(brand, model)  # call parent constructor (Vehicle)\n",
    "        self.doors = doors\n",
    "\n",
    "    def honk(self) -> str:\n",
    "        return f\"{self.brand} {self.model} is honking. It has {self.doors} doors.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# derived class 2 (child) inherits from Vehicle\n",
    "class Bike(Vehicle):\n",
    "    def __init__(self, brand: str, model: str, type_of_bike: str):\n",
    "        super().__init__(brand, model)  # call parent constructor (Vehicle)\n",
    "        self.type_of_bike = type_of_bike\n",
    "\n",
    "    def ring_bell(self) -> str:\n",
    "        return f\"{self.brand} {self.model} is ringing its bell. It's a {self.type_of_bike} bike.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "car.start()      : Toyota Corolla is starting.\n",
      "car.honk()       : Toyota Corolla is honking. It has 4 doors.\n",
      "car.stop()       : Toyota Corolla is stopping.\n",
      "\n",
      "bike.start()     : Giant Escape 3 is starting.\n",
      "bike.ring_bell() : Giant Escape 3 is ringing its bell. It's a Mountain bike.\n",
      "bike.stop()      : Giant Escape 3 is stopping.\n"
     ]
    }
   ],
   "source": [
    "# initializing\n",
    "car = Car(\"Toyota\", \"Corolla\", 4)\n",
    "bike = Bike(\"Giant\", \"Escape 3\", \"Mountain\")\n",
    "\n",
    "# log\n",
    "print(f\"car.start()      : {car.start()}\")\n",
    "print(f\"car.honk()       : {car.honk()}\")\n",
    "print(f\"car.stop()       : {car.stop()}\\n\")\n",
    "\n",
    "print(f\"bike.start()     : {bike.start()}\")\n",
    "print(f\"bike.ring_bell() : {bike.ring_bell()}\")\n",
    "print(f\"bike.stop()      : {bike.stop()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <a id='toc1_1_4_5_'></a>[Hybrid Inheritance](#toc0_)\n",
    "\n",
    "- A combination of two or more types of inheritance (e.g., multiple and multilevel).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# base class\n",
    "class Animal:\n",
    "    def __init__(self, species: str):\n",
    "        self.species = species\n",
    "\n",
    "    def eat(self) -> str:\n",
    "        return f\"{self.species} is eating.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# derived class (single Inheritance)\n",
    "class Mammal(Animal):\n",
    "    def __init__(self, species: str, habitat: str):\n",
    "        super().__init__(species)  # call the constructor of Animal\n",
    "        self.habitat = habitat\n",
    "\n",
    "    def give_birth(self) -> str:\n",
    "        return f\"{self.species} gives live birth.\"\n",
    "\n",
    "\n",
    "# derived class (single Inheritance)\n",
    "class Bird(Animal):\n",
    "    def __init__(self, species: str, wing_span: str):\n",
    "        super().__init__(species)  # call the constructor of Animal\n",
    "        self.wing_span = wing_span\n",
    "\n",
    "    def lay_eggs(self) -> str:\n",
    "        return f\"{self.species} lays eggs.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mixins for additional functionality\n",
    "class FlyingMixin:\n",
    "    def fly(self) -> str:\n",
    "        return f\"{self.species} is flying.\"\n",
    "\n",
    "\n",
    "class SwimmingMixin:\n",
    "    def swim(self) -> str:\n",
    "        return f\"{self.species} is swimming.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# derived class using multiple inheritance\n",
    "class Bat(Mammal, FlyingMixin):\n",
    "    def __init__(self, species: str, habitat: str, wing_span: str):\n",
    "        Mammal.__init__(self, species, habitat)  # call Mammal constructor\n",
    "        self.wing_span = wing_span  # additional attribute specific to Bat\n",
    "\n",
    "\n",
    "# derived class using multiple inheritance\n",
    "class Penguin(Bird, SwimmingMixin):\n",
    "    def __init__(self, species: str, wing_span: str, habitat: str):\n",
    "        Bird.__init__(self, species, wing_span)  # call Bird constructor\n",
    "        self.habitat = habitat  # additional attribute specific to Penguin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bat is eating.\n",
      "Bat gives live birth.\n",
      "Bat is flying.\n",
      "Bat lives in a Cave.\n",
      "\n",
      "Penguin is eating.\n",
      "Penguin lays eggs.\n",
      "Penguin is swimming.\n",
      "Penguin lives in Antarctica.\n",
      "\n",
      "Bat.mro()     : [<class '__main__.Bat'>, <class '__main__.Mammal'>, <class '__main__.Animal'>, <class '__main__.FlyingMixin'>, <class 'object'>]\n",
      "Penguin.mro() : [<class '__main__.Penguin'>, <class '__main__.Bird'>, <class '__main__.Animal'>, <class '__main__.SwimmingMixin'>, <class 'object'>]\n"
     ]
    }
   ],
   "source": [
    "# creating instances\n",
    "bat = Bat(\"Bat\", \"Cave\", \"1 meter\")\n",
    "penguin = Penguin(\"Penguin\", \"0.5 meters\", \"Antarctica\")\n",
    "\n",
    "# log\n",
    "print(bat.eat())\n",
    "print(bat.give_birth())\n",
    "print(bat.fly())\n",
    "print(f\"{bat.species} lives in a {bat.habitat}.\\n\")\n",
    "print(penguin.eat())\n",
    "print(penguin.lay_eggs())\n",
    "print(penguin.swim())\n",
    "print(f\"{penguin.species} lives in {penguin.habitat}.\\n\")\n",
    "print(f\"Bat.mro()     : {Bat.mro()}\")\n",
    "print(f\"Penguin.mro() : {Penguin.mro()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_2_'></a>[Encapsulation](#toc0_)\n",
    "\n",
    "- Encapsulation is the concept of wrapping data (variables) and methods (functions) together into a single unit, i.e., a class.\n",
    "- It helps to restrict access to certain details of an object and only expose the necessary parts.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_2_1_'></a>[Types of Modifiers](#toc0_)\n",
    "\n",
    "- **Public**\n",
    "  - Public members are accessible from anywhere (inside the class, subclasses, and even outside the class).\n",
    "  - By default, all attributes and methods in Python are public unless explicitly stated otherwise.\n",
    "  - Syntax: No leading underscores.\n",
    "- **Protected**\n",
    "  - Protected members are accessible within the class and its subclasses\n",
    "  - It’s not recommended to access them from outside the class.\n",
    "  - This is more of a convention than strict enforcement.\n",
    "  - Syntax: Single leading underscore (`_`).\n",
    "- **Private**\n",
    "  - Private members can only be accessed within the class where they are defined and not in subclasses or from outside.\n",
    "  - Python achieves this using **name mangling** (used to make class attributes and methods private).\n",
    "  - The attribute name is altered to include the class name as a prefix (e.g., __attribute becomes _ClassName__attribute).\n",
    "  - Syntax: Double leading underscore (`__`).\n",
    "\n",
    "✍️ **Notes**:\n",
    "\n",
    "- Python doesn’t have **strict** access control like languages such as `Java` or `C++`, it follows certain **conventions** using modifiers.\n",
    "\n",
    "📝 **Docs**:\n",
    "\n",
    "- Private variables: [docs.python.org/3/tutorial/classes.html#private-variables](https://docs.python.org/3/tutorial/classes.html#private-variables)\n",
    "- Private name mangling: [docs.python.org/3/reference/expressions.html#index-5](https://docs.python.org/3/reference/expressions.html#index-5)\n",
    "- Customizing attribute access: [docs.python.org/3.12/reference/datamodel.html#customizing-attribute-access](https://docs.python.org/3.12/reference/datamodel.html#customizing-attribute-access)\n",
    "- class `property`: [docs.python.org/3.12/library/functions.html#property](https://docs.python.org/3.12/library/functions.html#property)\n",
    "\n",
    "🐍 **PEP**:\n",
    "\n",
    "- Instance Descriptors [[PEP 549](https://peps.python.org/pep-0549/)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Toyota\n",
      "Corolla\n"
     ]
    }
   ],
   "source": [
    "class Car:\n",
    "    def __init__(self, make: str, model: str):\n",
    "        self._make = make  # protected attribute\n",
    "        self.__model = model  # private attribute\n",
    "\n",
    "    def get_model(self) -> str:\n",
    "        return self.__model  # accessor for private attribute\n",
    "\n",
    "\n",
    "car = Car(\"Toyota\", \"Corolla\")\n",
    "print(car._make)  # Access allowed (though protected by convention)\n",
    "# print(car.__model)  # Error: Attribute is private\n",
    "print(car.get_model())  # Correct way to access private attribute"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_2_2_'></a>[Access Controllers](#toc0_)\n",
    "\n",
    "- Methods that allow controlled access to an object's attributes.\n",
    "- They provide a way to read and modify private or protected attributes indirectly.\n",
    "\n",
    "✍️ **Types**:\n",
    "\n",
    "- **Getter**: A method that retrieves the value of a private or protected attribute.\n",
    "- **Setter**: A method that sets or modifies the value of a private or protected attribute.\n",
    "- **deleter**: A method that deletes or removes the value of a private or protected attribute.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "student_1.first     : Morty\n",
      "student_1.last      : Smith\n",
      "student_1.get_age() : 14\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self, first: str, last: str, age: int):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "        self.set_age(age)  # to use setter in __init__\n",
    "\n",
    "    # getter\n",
    "    def get_age(self) -> int:\n",
    "        return self.__age\n",
    "\n",
    "    # setter\n",
    "    def set_age(self, value) -> None:\n",
    "        if value >= 7:\n",
    "            self.__age = value\n",
    "        else:\n",
    "            raise ValueError\n",
    "\n",
    "\n",
    "# initializing\n",
    "student_1 = Student(\"Morty\", \"Smith\", 14)\n",
    "# student_2 = Student(\"Judith\", \"Grimes\", 6)  # ValueError\n",
    "\n",
    "# log\n",
    "print(f\"student_1.first     : {student_1.first}\")\n",
    "print(f\"student_1.last      : {student_1.last}\")\n",
    "print(f\"student_1.get_age() : {student_1.get_age()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "student_1.first : Morty\n",
      "student_1.last  : Smith\n",
      "student_1.age   : 14\n"
     ]
    }
   ],
   "source": [
    "# using decorators for getter, setter, deleter\n",
    "class Student:\n",
    "    def __init__(self, first: str, last: str, age: int):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "\n",
    "        # self.age is an interface for getting and setting the value\n",
    "        # behind the scenes, Python automatically calls the getter or setter method.\n",
    "        # private variable __age is created.\n",
    "        self.age = age\n",
    "\n",
    "    # getter\n",
    "    @property\n",
    "    def age(self) -> int:\n",
    "        return self.__age\n",
    "\n",
    "    # setter\n",
    "    @age.setter\n",
    "    def age(self, value) -> None:\n",
    "        if value >= 7:\n",
    "            self.__age = value\n",
    "        else:\n",
    "            raise ValueError\n",
    "\n",
    "\n",
    "# Initializing students\n",
    "student_1 = Student(\"Morty\", \"Smith\", 14)\n",
    "# student_2 = Student(\"Judith\", \"Grimes\", 6)  # Raises ValueError\n",
    "\n",
    "# Log\n",
    "print(f\"student_1.first : {student_1.first}\")\n",
    "print(f\"student_1.last  : {student_1.last}\")\n",
    "print(f\"student_1.age   : {student_1.age}\")  # No need for get_age()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_2_3_'></a>[Descriptors](#toc0_)\n",
    "\n",
    "- It is a powerful and advanced feature that allows you to customize the behavior of attribute access.\n",
    "\n",
    "**Descriptors vs. Getters and Setters with `@property`**:\n",
    "\n",
    "<table style=\"margin:0 auto;\">\n",
    "  <thead>\n",
    "    <tr>\n",
    "      <th>Aspect</th>\n",
    "      <th>Descriptors</th>\n",
    "      <th>Getters and Setters (<code>@property</code>)</th>\n",
    "    </tr>\n",
    "  </thead>\n",
    "  <tbody>\n",
    "    <tr>\n",
    "      <td><b>Implementation</b></td>\n",
    "      <td>Defined as a separate class implementing <code>__get__</code>, <code>__set__</code>, and <code>__delete__</code>.</td>\n",
    "      <td>Defined within the class using <code>@property</code> for getter and <code>@&lt;property_name&gt;.setter</code> for setter.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td><b>Reusability</b></td>\n",
    "      <td>Can be reused across multiple classes.</td>\n",
    "      <td>Specific to the class where they are defined.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td><b>Syntax</b></td>\n",
    "      <td>Explicit use of descriptor instances as class attributes.</td>\n",
    "      <td>Implicit access through attribute access.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td><b>Flexibility</b></td>\n",
    "      <td>More flexible in terms of defining multiple behaviors for different attributes.</td>\n",
    "      <td>Simpler and more straightforward for single attributes.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td><b>Complexity</b></td>\n",
    "      <td>More complex to implement, especially for multiple attributes.</td>\n",
    "      <td>Simpler and more readable for basic use cases.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "      <td><b>Example</b></td>\n",
    "      <td>Requires a separate class for the descriptor.</td>\n",
    "      <td>Uses decorators for a clean syntax.</td>\n",
    "    </tr>\n",
    "  </tbody>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AboveSevenAge:\n",
    "    \"\"\"Descriptor to manage age with a minimum value.\"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        self.__age = None  # private variable to store the age\n",
    "\n",
    "    def __get__(self, instance, owner):\n",
    "        return self.__age\n",
    "\n",
    "    def __set__(self, instance, value):\n",
    "        if value >= 7:\n",
    "            self.__age = value\n",
    "        else:\n",
    "            raise ValueError(\"Age must be 7 or older.\")\n",
    "\n",
    "    def __delete__(self, instance):\n",
    "        del self.__age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "student_1.first : Morty\n",
      "student_1.last  : Smith\n",
      "student_1.age   : 14\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    age = AboveSevenAge()  # descriptor for managing age\n",
    "\n",
    "    def __init__(self, first: str, last: str, age: int):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "\n",
    "        # calls the descriptor's __set__ method\n",
    "        self.age = age\n",
    "\n",
    "\n",
    "# Initializing students\n",
    "student_1 = Student(\"Morty\", \"Smith\", 14)\n",
    "# student_2 = Student(\"Judith\", \"Grimes\", 6)  # Raises ValueError\n",
    "\n",
    "# Log\n",
    "print(f\"student_1.first : {student_1.first}\")\n",
    "print(f\"student_1.last  : {student_1.last}\")\n",
    "print(f\"student_1.age   : {student_1.age}\")  # calls the descriptor's __get__ method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_3_'></a>[Abstraction](#toc0_)\n",
    "\n",
    "- Abstraction focuses on hiding the implementation details and exposing only the necessary parts of an object to the outside world.\n",
    "- By doing this, abstraction reduces complexity and allows the programmer to work with higher-level interfaces.\n",
    "- Abstraction can be achieved through the use of *abstract classes* and *interfaces* provided by the `abc` (Abstract Base Class) module.\n",
    "\n",
    "✍️ **Key Elements of Abstract Classes**:\n",
    "\n",
    "- `ABC` class\n",
    "  - All abstract classes inherit from the `ABC` class in the `abc` module.\n",
    "- `abstractmethod` decorator\n",
    "  - This decorator is used to declare methods that must be implemented by any subclass.\n",
    "- Instantiation\n",
    "  - Abstract classes cannot be instantiated directly.\n",
    "\n",
    "🆚 **Abstract Methods vs Concrete Methods**:\n",
    "\n",
    "- Abstract Methods\n",
    "  - Defined using the `@abstractmethod` decorator.\n",
    "  - Must be overridden in derived classes.\n",
    "- Concrete Methods\n",
    "  - Defined like normal methods in the abstract class.\n",
    "  - Can have a default implementation and may be overridden by subclasses.\n",
    "\n",
    "📝 **Docs**:\n",
    "\n",
    "- Abstract Base Classes: [docs.python.org/3/library/abc.html](https://docs.python.org/3/library/abc.html)\n",
    "\n",
    "🐍 **PEP**:\n",
    "\n",
    "- Introducing Abstract Base Classes [[PEP 3119](https://peps.python.org/pep-3119/)]\n",
    "- A Type Hierarchy for Numbers: [[PEP 3141](https://peps.python.org/pep-3141/)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC, abstractmethod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Shape(ABC):\n",
    "    @abstractmethod\n",
    "    def area(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def perimeter(self):\n",
    "        pass\n",
    "\n",
    "\n",
    "# shape = Shape()  # raises TypeError: Can't instantiate abstract class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n",
      "60\n"
     ]
    }
   ],
   "source": [
    "class Rectangle(Shape):\n",
    "    def __init__(self, width: int, height: int):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "\n",
    "    def area(self) -> int:\n",
    "        return self.width * self.height\n",
    "\n",
    "    def perimeter(self) -> int:\n",
    "        return 2 * (self.width + self.height)\n",
    "\n",
    "\n",
    "# log\n",
    "rect = Rectangle(10, 20)\n",
    "print(rect.area())\n",
    "print(rect.perimeter())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "78.5\n",
      "31.400000000000002\n"
     ]
    }
   ],
   "source": [
    "class Circle(Shape):\n",
    "    def __init__(self, radius: int):\n",
    "        self.radius = radius\n",
    "\n",
    "    def area(self) -> float:\n",
    "        return 3.14 * self.radius**2\n",
    "\n",
    "    def perimeter(self) -> float:\n",
    "        return 2 * 3.14 * self.radius\n",
    "\n",
    "\n",
    "# log\n",
    "circ = Circle(5)\n",
    "print(circ.area())\n",
    "print(circ.perimeter())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_4_'></a>[Polymorphism](#toc0_)\n",
    "\n",
    "- Polymorphism means \"many forms.\" In Python.\n",
    "- It allows objects of different classes to be treated as objects of a common superclass.\n",
    "\n",
    "✍️ **Types of Polymorphism**:\n",
    "\n",
    "- **Compile-time Polymorphism (Method Overloading)**:\n",
    "  - Method overloading allows the same method name to be defined with different parameters.\n",
    "  - Not natively supported in Python but can be mimicked.\n",
    "  - Python allows only the last method definition to be recognized, so this form of polymorphism isn't used directly.\n",
    "- **Run-time Polymorphism (Method Overriding)**:\n",
    "  - Achieved through inheritance, where a child class can provide its own implementation of a method already defined in its parent class.\n",
    "  - This is the most common form of polymorphism in Python.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_4_1_'></a>[Polymorphism with Functions](#toc0_)\n",
    "\n",
    "- A function can take objects of different types as arguments and perform specific operations depending on the object type.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n",
      "Meow!\n"
     ]
    }
   ],
   "source": [
    "class Dog:\n",
    "    def speak(self) -> str:\n",
    "        return \"Woof!\"\n",
    "\n",
    "\n",
    "class Cat:\n",
    "    def speak(self) -> str:\n",
    "        return \"Meow!\"\n",
    "\n",
    "\n",
    "# in this case, animal_sound() works with any object that implements the speak() method, demonstrating polymorphism.\n",
    "def animal_sound(animal) -> None:\n",
    "    print(animal.speak())\n",
    "\n",
    "\n",
    "# initialization\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "\n",
    "# log\n",
    "animal_sound(dog)\n",
    "animal_sound(cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_4_2_'></a>[Polymorphism with Classes (Method Overriding)](#toc0_)\n",
    "\n",
    "- Inheritance-based polymorphism allows a subclass to override a method in its parent class while maintaining the method signature.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Flying in the sky.\n",
      "I can't fly!\n"
     ]
    }
   ],
   "source": [
    "class Bird:\n",
    "    def fly(self) -> str:\n",
    "        print(\"Flying in the sky.\")\n",
    "\n",
    "\n",
    "class Penguin(Bird):\n",
    "    def fly(self) -> str:\n",
    "        print(\"I can't fly!\")\n",
    "\n",
    "\n",
    "# initialization\n",
    "bird = Bird()\n",
    "penguin = Penguin()\n",
    "\n",
    "# log\n",
    "bird.fly()\n",
    "penguin.fly()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_4_3_'></a>[Polymorphism with Abstract Base Classes](#toc0_)\n",
    "\n",
    "- Python provides the `abc` (Abstract Base Class) module to define interfaces and enforce certain methods that must be implemented by subclasses.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n",
      "Meow!\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "\n",
    "class Animal(ABC):\n",
    "    @abstractmethod\n",
    "    def speak(self) -> str:\n",
    "        pass\n",
    "\n",
    "\n",
    "class Dog(Animal):\n",
    "    def speak(self) -> str:\n",
    "        return \"Woof!\"\n",
    "\n",
    "\n",
    "class Cat(Animal):\n",
    "    def speak(self) -> str:\n",
    "        return \"Meow!\"\n",
    "\n",
    "\n",
    "# initialization\n",
    "animals = [Dog(), Cat()]\n",
    "\n",
    "# log\n",
    "for animal in animals:\n",
    "    print(animal.speak())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_4_4_'></a>[Duck Typing in Python](#toc0_)\n",
    "\n",
    "- Python is dynamically typed and supports \"duck typing,\" meaning it doesn't require objects to inherit from a specific class to be treated polymorphically.\n",
    "- Instead, it relies on the presence of methods or attributes in the object.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quack quack\n",
      "I'm quacking like a duck!\n"
     ]
    }
   ],
   "source": [
    "class Duck:\n",
    "    def quack(self) -> None:\n",
    "        print(\"Quack quack\")\n",
    "\n",
    "\n",
    "class Person:\n",
    "    def quack(self) -> None:\n",
    "        print(\"I'm quacking like a duck!\")\n",
    "\n",
    "\n",
    "def quack_it(obj) -> None:\n",
    "    obj.quack()\n",
    "\n",
    "\n",
    "# initialization\n",
    "# if it looks like a duck and quacks like a duck, it must be a duck.\n",
    "duck = Duck()\n",
    "person = Person()\n",
    "\n",
    "# log\n",
    "quack_it(duck)\n",
    "quack_it(person)"
   ]
  }
 ],
 "metadata": {
  "author_email": "AmirhosseinHeydari78@gmail.com",
  "author_github": "https://github.com/mr-pylin",
  "author_name": "Amirhossein Heydari",
  "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.12.3"
  },
  "origin_repo": "https://github.com/mr-pylin/python-workshop"
 },
 "nbformat": 4,
 "nbformat_minor": 2
}