super_inheritance.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "super_inheritance.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMYmHtGrEjTHktttC9GxWRX",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/wenxuan0923/My-notes/blob/master/super_inheritance.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4tRHNhFLDGAF",
        "colab_type": "text"
      },
      "source": [
        "# `super()` inheritance in Python\n",
        "\n",
        "In this note I will use examples to explain the main concepts of Class Inheritance in Python 3, including:\n",
        "\n",
        "- Singel Inheritance\n",
        "\n",
        "- Use `super()` to access methods from superclasses\n",
        "\n",
        "- Multiple Inheritance\n",
        "\n",
        "- Method Resolution Order (MRO)\n",
        "\n",
        "- Use `**kwargs` for flexible class initialization\n",
        "\n",
        "**Before jump into the details, recall that:**\n",
        "\n",
        "- The primary use case of **Inheritance** is to extend the functionality of the inherited class (superclass) without repeating code.\n",
        "\n",
        "- The `__init__()` function is for initialization. It is called automatically every time a class is being used to create a new object.\n",
        "\n",
        "## Single Inheritance\n",
        "\n",
        "• When using inheritance, if you are not redefining the `__init__` method in the subclass, the one of its parent class will be called automatically.\n",
        "\n",
        "• Subclass will inherit the properties and methods from its parient class."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "plc9ppMzDZ9e",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class SchoolMember:\n",
        "  def __init__(self, name, age):\n",
        "    self.name = name\n",
        "    self.age = age\n",
        "    \n",
        "  def get_name(self):\n",
        "    print(self.name)\n",
        "\n",
        "  def get_age(self):\n",
        "    print(self.age)\n",
        " \n",
        "# The pass keyword means no other properties or methods is added to the class \n",
        "class Teacher(SchoolMember):\n",
        "    pass     "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gbFaT5oECsxG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "ba6395ac-ae4b-4139-990a-aae0428f7ba4"
      },
      "source": [
        "hung = Teacher('Hung', 28)\n",
        "hung.get_name()\n",
        "hung.get_age()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hung\n",
            "28\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L0aHABlNZY7f",
        "colab_type": "text"
      },
      "source": [
        "• If the `__init__` in redefined in the subclass, the `__init__` from parent class will not be automatically invoked, but the subclass still have access to the methods defined in its parent class\n",
        "\n",
        "• To keep the inheritance of the parent's `__init__()` function, we need to add a call to the parent's `__init__()` function.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jaFYnNtIZKea",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class SchoolMember:\n",
        "  def __init__(self, name, age):\n",
        "    self.name = name\n",
        "    self.age = age\n",
        "    \n",
        "  def sayhi(self):\n",
        "    print('Hi! this is SchoolMemer')\n",
        " \n",
        "class Teacher(SchoolMember):\n",
        "  def __init__(self, name, age, subject):\n",
        "    self.subject = subject\n",
        "\n",
        "  def get_subject(self):\n",
        "    print(self.subject)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ofpx8mc5Z2wI",
        "colab_type": "text"
      },
      "source": [
        "$\\color{green}{\\text{✔ This works:}}$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d-aum81TZKhR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "b9fe8122-fd00-4306-9499-01d7f3657116"
      },
      "source": [
        "hung = Teacher('Hung', 28, 'Math')\n",
        "hung.sayhi()\n",
        "hung.get_subject()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hi! this is SchoolMemer\n",
            "Math\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0um-JGSkZwAR",
        "colab_type": "text"
      },
      "source": [
        "$\\color{red}{\\text{✖ This does not work:}}$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "29qPfzyEZsJl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 189
        },
        "outputId": "667df132-1769-4807-daf4-b3745c3574a4"
      },
      "source": [
        "print(hung.name)\n",
        "print(hung.age)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-20-e6cbd91a1af2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhung\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhung\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: 'Teacher' object has no attribute 'name'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TT35l25tHv-Y",
        "colab_type": "text"
      },
      "source": [
        "This command leads to $\\color{indianred}{\\text{AttributeError}}$ since the `__init__()` from the parent class SchoolMember has never been called. \n",
        "\n",
        "To fix this, you need to explicitly call the `__init__()` of the parent class inside the init of the subclass. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fWOiggVUHQGB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class SchoolMember:\n",
        "  def __init__(self, name, age):\n",
        "    self.name = name\n",
        "    self.age = age\n",
        " \n",
        "class Teacher(SchoolMember):\n",
        "  def __init__(self, name, age, subject):\n",
        "    SchoolMember.__init__(self, name, age)\n",
        "    self.subject = subject"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RaUx1mlgIiSl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "outputId": "65d6e04a-900c-43dd-cf0c-385d405fab32"
      },
      "source": [
        "hung = Teacher('Hung', 28, 'Math')\n",
        "print(hung.name)\n",
        "print(hung.age)\n",
        "print(hung.subject)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hung\n",
            "28\n",
            "Math\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wGwTRnbKKS5Q",
        "colab_type": "text"
      },
      "source": [
        "**Using `super()` to call methods of the parent class**\n",
        "\n",
        "Instead of using `SchoolMember.__init__(self, name, age)`, we can use the `super()` function which allows us to refer the superclass implicitly, meaning we don’t need to write the name of superclass explicitly. \n",
        "\n",
        "• This `super()` alone returns a temporary object (called **roxy object**) of the superclass that then allows you to call methods defined in superclass. \n",
        "\n",
        "• Note we don't need the `self` argument when calling method from `super()`.\n",
        "\n",
        "The following code will do the same thing with the one above. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oo7yUEfCJ6Pv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class SchoolMember:\n",
        "  def __init__(self, name, age):\n",
        "    self.name = name\n",
        "    self.age = age\n",
        " \n",
        "class Teacher(SchoolMember):\n",
        "  def __init__(self, name, age, subject):\n",
        "    super().__init__(name, age)\n",
        "    self.subject = subject"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-mmz7hNKgqFo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "outputId": "05e30c33-c1a6-4500-b2bc-ca1cc4f4528c"
      },
      "source": [
        "hung = Teacher('Hung', 28, 'Math')\n",
        "print(hung.name)\n",
        "print(hung.age)\n",
        "print(hung.subject)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hung\n",
            "28\n",
            "Math\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AKuqi9QuhDPd",
        "colab_type": "text"
      },
      "source": [
        "**We can use super() to call any other method from its parent class, not just `__init__`**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D5Nd-XZ_IjsE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class SchoolMember:\n",
        "  def __init__(self, name, age, gender):\n",
        "    self.name = name\n",
        "    self.age = age\n",
        "    self.gender = gender\n",
        "\n",
        "  def sayhi(self):\n",
        "    print('Hi! This is SchoolMemer')\n",
        "    \n",
        "  def get_portrait(self):\n",
        "    return '👦' if self.gender=='male' else '👧'\n",
        "\n",
        "class Teacher(SchoolMember):\n",
        "  def __init__(self, name, age, gender, subject):\n",
        "    super().__init__(name, age, gender)\n",
        "    self.subject = subject\n",
        "\n",
        "  def sayhi(self):\n",
        "    super().sayhi()\n",
        "    profile = super().get_portrait()\n",
        "    print('Hi! This is {} Teacher {} {}'.format(self.subject, self.name, profile))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0BeOblx-Jzda",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "81a6fb11-e7c1-41f3-f534-4c90dd23ddc6"
      },
      "source": [
        "hung = Teacher('Hung', 28, 'male', 'Math')\n",
        "hung.sayhi()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hi! This is SchoolMemer\n",
            "Hi! This is Math Teacher Hung 👦\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dKD_B10gkrp2",
        "colab_type": "text"
      },
      "source": [
        "## Multiple Inheritance\n",
        "\n",
        "Python supports multiple inheritance, in which a subclass can inherit from multiple superclasses.  \n",
        "\n",
        "Let's now define a class **Myclass** which inherit from two superclasses: **Base1** and **Base2**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3yvdFsPHqe4F",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Base1:\n",
        "  def __init__(self):\n",
        "    print('Initializing Base 1')\n",
        "\n",
        "  def sayhi(self):\n",
        "    print('Hi from Base 1')  \n",
        "\n",
        "class Base2:\n",
        "  def __init__(self):\n",
        "    print('Initializing Base 2')\n",
        "\n",
        "  def sayhi(self):\n",
        "    print('Hi from Base 2')  \n",
        "\n",
        "class Myclass(Base1, Base2):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    \n",
        "  def sayhi(self):\n",
        "    print('Hi from Myclass')\n",
        "    super().sayhi()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AKea4-O0qe8t",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "outputId": "743b1a65-49e3-4140-bbcc-0b27a4ecad58"
      },
      "source": [
        "myObject = Myclass()\n",
        "myObject.sayhi()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Initializing Base 1\n",
            "Hi from Myclass\n",
            "Hi from Base 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fnme84g6rlCy",
        "colab_type": "text"
      },
      "source": [
        "You may notice that even though both superclasses have `__init__()` and `sayhi()` methods, only the ones from **Base1** got invoked when being called using `super()`. This is because of something called **Method Resolution Order (MRO)**. It tells Python where to search for methods when being called using `super()`. You can easily inspect the order by checking the `__mro__` attribute of the class."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rexpvJ3lrkir",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "cca58af9-7f12-4ec1-c524-c186093ebcaa"
      },
      "source": [
        "Myclass.__mro__"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(__main__.Myclass, __main__.Base1, __main__.Base2, object)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xYhIdN9lsDsz",
        "colab_type": "text"
      },
      "source": [
        "This tells us that methods will be searched in the order:<strong> Myclass $\\Rightarrow$ Base1 $\\Rightarrow$ Base2 </strong>. \n",
        "\n",
        "What if we swich the position of Base1 and Base2?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qBoR6UQ-qe7D",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Base1:\n",
        "  def __init__(self):\n",
        "    print('Initializing Base 1')\n",
        "\n",
        "  def sayhi(self):\n",
        "    print('Hi from Base 1')  \n",
        "\n",
        "class Base2:\n",
        "  def __init__(self):\n",
        "    print('Initializing Base 2')\n",
        "\n",
        "  def sayhi(self):\n",
        "    print('Hi from Base 2')  \n",
        "\n",
        "class Myclass(Base2, Base1):\n",
        "  def __init__(self):\n",
        "    print('Initializing Myclass')\n",
        "    super().__init__()\n",
        "    \n",
        "  def sayhi(self):\n",
        "    print('Hi from Myclass')\n",
        "    super().sayhi()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DsG5B0ELr7EW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "4c237a3d-8116-426c-b764-40199a6345a7"
      },
      "source": [
        "Myclass.__mro__"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(__main__.Myclass, __main__.Base2, __main__.Base1, object)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d-VmYorqrWmA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        },
        "outputId": "8efc634b-2e13-4de5-ed63-967e13549156"
      },
      "source": [
        "myObject = Myclass()\n",
        "myObject.sayhi()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Initializing Myclass\n",
            "Initializing Base 2\n",
            "Hi from Myclass\n",
            "Hi from Base 2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zX_p4FvBvaO7",
        "colab_type": "text"
      },
      "source": [
        "In this case, only the methods from **Base2** got called, and the MRO also has changed accordingly.\n",
        " \n",
        "Let's check another example where Myclass inherit from Base2, and Base2 inherit from Base1:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TtV8nG95rX57",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Base1:\n",
        "  def __init__(self):\n",
        "    print('Initializing Base 1')\n",
        "\n",
        "  def sayhi(self):\n",
        "    print('Hi from Base 1')  \n",
        "\n",
        "class Base2(Base1):\n",
        "  def __init__(self):\n",
        "    print('Initializing Base 2')\n",
        "    super().__init__()\n",
        "\n",
        "  def sayhi(self):\n",
        "    print('Hi from Base 2') \n",
        "    super().__init__() \n",
        "\n",
        "class Myclass(Base2):\n",
        "  def __init__(self):\n",
        "    print('Initializing Myclass')\n",
        "    super().__init__()\n",
        "    \n",
        "  def sayhi(self):\n",
        "    print('Hi from Myclass')\n",
        "    super().sayhi()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NI0rBjpqvVgs",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "ec7097bc-d51f-4f87-cc71-e4e65858cc5f"
      },
      "source": [
        "Myclass.__mro__"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(__main__.Myclass, __main__.Base2, __main__.Base1, object)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 103
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z6f736YfrX8h",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 126
        },
        "outputId": "014a5853-b3b5-4712-bc0e-3e9b4572345a"
      },
      "source": [
        "myObject = Myclass()\n",
        "myObject.sayhi()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Initializing Myclass\n",
            "Initializing Base 2\n",
            "Initializing Base 1\n",
            "Hi from Myclass\n",
            "Hi from Base 2\n",
            "Initializing Base 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_drTkoEAZUn9",
        "colab_type": "text"
      },
      "source": [
        "the `__init__()` function of Myclass got called at first, then class Base2 and after that Base1. Same things happened when `sayhi()` is called.\n",
        "\n",
        "### More flexible `__init__` with **\\*\\*kwargs**\n",
        "\n",
        "\\*\\*kwargs allows users to instantiate objects only with the arguments that make sense for that particular object."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bx0DNMBQZSlV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class A:\n",
        "  def __init__(self, a):\n",
        "    self.a = a\n",
        "\n",
        "class B(A):\n",
        "  def __init__(self, b, **kwargs):\n",
        "    self.b = b\n",
        "    super().__init__(**kwargs)"
      ],
      "execution_count": 52,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nvOrpOBuWcYX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "5271da02-7eeb-44e9-c6e4-1238a976efe9"
      },
      "source": [
        "b1 = B(a=1, b=3)\n",
        "print(b1.b)\n",
        "print(b1.a)"
      ],
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ci8Kfx3N0Utz",
        "colab_type": "text"
      },
      "source": [
        "What if we pass in another attribute which is not defined in either A or B class?\n",
        "\n",
        "$\\color{green}{\\text{✔ This works:}}$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "va0z8jLk0wMS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class A:\n",
        "  def __init__(self, a, **kwargs):\n",
        "    self.a = a\n",
        "\n",
        "class B(A):\n",
        "  def __init__(self, b, **kwargs):\n",
        "    self.b = b\n",
        "    super().__init__(**kwargs)"
      ],
      "execution_count": 56,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nSPMQjOJ0xQy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "a5df6d4d-bc21-4a77-d78f-134344be3860"
      },
      "source": [
        "b1 = B(a=1, b=3, c=4)\n",
        "print(b1.b)\n",
        "print(b1.a)"
      ],
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "we5cPY3D1Fc4",
        "colab_type": "text"
      },
      "source": [
        "In this example, both A and B has \\*\\*kwargs (a keyword dictionary) which can take in any extra parameter, even though it's not defined in these two classes as long as we don't try to use this argument inside A and B. Note the named arguments have to be set up before \\*\\*kwargs.\n",
        "\n",
        "$\\color{red}{\\text{✖ This does not work:}}$\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2XrWdRri1ZZy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class A:\n",
        "  def __init__(self, a, **kwargs):\n",
        "    self.a = a\n",
        "    self.c = c\n",
        "\n",
        "class B(A):\n",
        "  def __init__(self, b, **kwargs):\n",
        "    self.b = b\n",
        "    super().__init__(**kwargs)"
      ],
      "execution_count": 58,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bB8NrWA-1amT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 358
        },
        "outputId": "d43979cb-0a75-4d17-c121-4c357643b7d1"
      },
      "source": [
        "b1 = B(a=1, b=3, c=4)\n",
        "print(b1.b)\n",
        "print(b1.a)"
      ],
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-59-d727f71cdc4e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mb1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mB\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-58-e380af0b9756>\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, b, **kwargs)\u001b[0m\n\u001b[1;32m      7\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m     \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\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-58-e380af0b9756>\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, a, **kwargs)\u001b[0m\n\u001b[1;32m      2\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mB\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'c' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A49vjobA0U_L",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "Things can get a little confusing when it comes to **multiple inheritence when using \\*\\*kwargs**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VDfiO9UYcMyL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class A:\n",
        "  def __init__(self, a):\n",
        "    self.a = a\n",
        "\n",
        "class B:\n",
        "  def __init__(self, b):\n",
        "    self.b = b\n",
        "\n",
        "class C(A, B):\n",
        "  def __init__(self, c, **kwargs):\n",
        "    self.c = c\n",
        "    super().__init__(**kwargs)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Ebd0SC-qFZN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "8125cfb2-d11d-409d-e865-60b3acd9539b"
      },
      "source": [
        "C.__mro__"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(__main__.C, __main__.A, __main__.B, object)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 281
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2WFSJZoOcp2T",
        "colab_type": "text"
      },
      "source": [
        "$\\color{green}{\\text{✔ This works:}}$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZfEq6JlzcNrm",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "17b3d018-6a00-4a1f-df43-01ff280831ea"
      },
      "source": [
        "c1 = C(c=7, a=1)\n",
        "print(c1.c)\n",
        "print(c1.a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ajWHRP5F3XgF",
        "colab_type": "text"
      },
      "source": [
        "In this case, `**kwargs = {a: 1}`. When we call `super().__init__(**kwargs)` we are actually calling `A.__init__(a=1)`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EuwocPwbdZL8",
        "colab_type": "text"
      },
      "source": [
        "$\\color{red}{\\text{✖ This does not work:}}$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yVtx8cE3cwom",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "outputId": "c7478ddf-97f1-4d54-9a86-5740f8bc2d4f"
      },
      "source": [
        "c2 = C(c=7, a=1, b=2)\n",
        "print(c2.c)\n",
        "print(c2.b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-283-eda45bea887d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mc2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-280-5df0f447d15e>\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, c, **kwargs)\u001b[0m\n\u001b[1;32m     10\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m     \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: __init__() got an unexpected keyword argument 'b'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6ALfUobR32va",
        "colab_type": "text"
      },
      "source": [
        "In this case, `**kwargs = {a: 1; b:2}`. When we call `super().__init__(**kwargs)` we are actually calling `A.__init__(a=1, b=2)`. However b is not an argument for class A, so we got $\\color{indianred}{\\text{TypeError}}$ when we try to define an object of class C. We can fix this issue by adding \\*\\*kwargs into the `A.__init__()`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BWnVgOKO4lK9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class A:\n",
        "  def __init__(self, a, **kwargs):\n",
        "    self.a = a\n",
        "\n",
        "class B:\n",
        "  def __init__(self, b):\n",
        "    self.b = b\n",
        "\n",
        "class C(A, B):\n",
        "  def __init__(self, c, **kwargs):\n",
        "    self.c = c\n",
        "    super().__init__(**kwargs)"
      ],
      "execution_count": 60,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5_Bcrqwb44jl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "a1cfd7d0-3001-4f05-b069-9debb0f00c42"
      },
      "source": [
        "c2 = C(c=7, a=1, b=2)\n",
        "print(c2.c)"
      ],
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kkEfw20H5DOe",
        "colab_type": "text"
      },
      "source": [
        "Great, this time we successfully defined an object of class C with three arguments a, b, and c. However, if you try to get the attribute b of this object, you get an $\\color{indianred}{\\text{AttributeError}}$ this time."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hRsS4I004_fe",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 171
        },
        "outputId": "4a12bc5f-8da9-4175-f112-d4f47b93206f"
      },
      "source": [
        "print(c2.b)"
      ],
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-63-b3849a309712>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mc2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: 'C' object has no attribute 'b'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tkpQ4w9851om",
        "colab_type": "text"
      },
      "source": [
        "This is because the `super().__init__()` provides the next `__init__()` method according to the MRO.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bvj4jz4s5xS4",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "14f7a0f9-9f4e-43ed-c86b-126ba3470f5d"
      },
      "source": [
        "C.__mro__"
      ],
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(__main__.C, __main__.A, __main__.B, object)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8IDApDsweEUn",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "In this example, \n",
        "\n",
        "1. `C.__init__(c, **kwargs)` is executed, attribute `c` got set up.\n",
        "> then `super().__init__(**kwargs)` executes and MRO returns `A.__init__(**kwargs)` which is called next.\n",
        "\n",
        "2. `A.__init__(**kwargs)` is executed, attribute `a` got set up. \n",
        "\n",
        "That's it. The execution stops at the end of `A.__init__()` and never make it to `B.__init__()`.\n",
        "\n",
        "To make the `C.__init__` go one step deeper to execute `B.__init__()`, we need to add `super().__init__()` into A."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OoJolJC4fHi2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class A:\n",
        "  def __init__(self, a, **kwargs):\n",
        "    self.a = a\n",
        "    super().__init__(**kwargs)\n",
        "\n",
        "class B:\n",
        "  def __init__(self, b, **kwargs):\n",
        "    self.b = b\n",
        "\n",
        "class C(A, B):\n",
        "  def __init__(self, c, **kwargs):\n",
        "    self.c = c\n",
        "    super().__init__(**kwargs)"
      ],
      "execution_count": 65,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vtjq3Pc7fNPW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "outputId": "b1204948-9969-41cf-a8a7-f0dcb22e07a2"
      },
      "source": [
        "c2 = C(a=1, c=7, b=2)\n",
        "print(c2.c)\n",
        "print(c2.b)\n",
        "print(c2.a)"
      ],
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n",
            "2\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K1abSbHosn1e",
        "colab_type": "text"
      },
      "source": [
        "I find this concept is better illustrated by another example below, which is originally from <a href='https://stackoverflow.com/questions/3277367/how-does-pythons-super-work-with-multiple-inheritance' target='_blank'>StackOverFlow</a>."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IQN4_49wfNV2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class First:\n",
        "  def __init__(self):\n",
        "    print(\"First(): entering\")\n",
        "    super().__init__()\n",
        "    print(\"First(): exiting\")\n",
        "\n",
        "class Second:\n",
        "  def __init__(self):\n",
        "    print(\"Second(): entering\")\n",
        "    super().__init__()\n",
        "    print(\"Second(): exiting\")\n",
        "\n",
        "class Third(First, Second):\n",
        "  def __init__(self):\n",
        "    print(\"Third(): entering\")\n",
        "    super().__init__()\n",
        "    print(\"Third(): exiting\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XDHHM2dlfNUL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 145
        },
        "outputId": "52b46bed-fffe-461a-bc3b-0cc7816e700f"
      },
      "source": [
        "Third()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Third(): entering\n",
            "First(): entering\n",
            "Second(): entering\n",
            "Second(): exiting\n",
            "First(): exiting\n",
            "Third(): exiting\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<__main__.Third at 0x7fb1a9a3b7b8>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 277
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GUwqotcUjBUD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "c752815f-fd7b-483b-9619-f8fa8a9b557b"
      },
      "source": [
        "Third.__mro__"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(__main__.Third, __main__.First, __main__.Second, object)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 276
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lIvmRxARlFRu",
        "colab_type": "text"
      },
      "source": [
        "The MRO to resolve `Third.__init__()` is calculated: <strong>Third $\\Rightarrow$ First $\\Rightarrow$ Second $\\Rightarrow$ Object.</strong>  According to MRO:\n",
        "\n",
        "\n",
        "1. `Third.__init__()` executes first:\n",
        "> prints `Third(): entering`\n",
        ">\n",
        "> then `super().__init__()` executes and MRO returns `First.__init__()` which is called next.\n",
        "\n",
        "2. `First.__init__()` executes:\n",
        "> prints `First(): entering`\n",
        ">\n",
        "> then `super().__init__()` executes and MRO returns `Second.__init__()` which is called next.\n",
        "\n",
        "3. `Second.__init__()` executes:\n",
        ">  prints `Second(): entering`\n",
        ">\n",
        "> then `super().__init__()` executes and MRO returns `object.__init__()` which is called next.\n",
        "\n",
        "4. `object.__init__()` executes (no print statements in the code there)\n",
        "\n",
        "5. execution goes back to `Second.__init__()` which then prints `Second(): exiting`\n",
        "\n",
        "6. execution goes back to `First.__init__()` which then prints `First(): exiting`\n",
        "\n",
        "7. execution goes back to `Third.__init__()` which then prints `Third(): exiting`\n",
        "\n",
        "### It can become very powerful when being used together with **\\*\\*kwargs**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pnM1XiReNyXe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class A:\n",
        "  def __init__(self, a, **kwargs):\n",
        "    self.a = a\n",
        "    super().__init__(**kwargs)\n",
        "\n",
        "  def heart(self):\n",
        "    return '❤'\n",
        "\n",
        "class B:\n",
        "  def __init__(self, b, **kwargs):\n",
        "    self.b = b\n",
        "    super().__init__(**kwargs)\n",
        "  \n",
        "  def star(self):\n",
        "    return '⭐'\n",
        "\n",
        "class C(A, B):\n",
        "  def __init__(self, c, **kwargs):\n",
        "    self.c = c\n",
        "    kwargs['a'] = c - 1\n",
        "    kwargs['b'] = c + 1 \n",
        "    super().__init__(**kwargs)\n",
        "  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vfl2yh5QQ3e6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 108
        },
        "outputId": "2a9a821b-29c4-460c-f9fd-56ec9d3a3f6d"
      },
      "source": [
        "myVar = C(3)\n",
        "print(myVar.a)\n",
        "print(myVar.b)\n",
        "print(myVar.c)\n",
        "print(myVar.heart())\n",
        "print(myVar.star())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "4\n",
            "3\n",
            "❤\n",
            "⭐\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YqlSYdFsw90j",
        "colab_type": "text"
      },
      "source": [
        "### A little more complicated example\n",
        "\n",
        "In this final example we will calculate the area of RightPyramid (a pyramid with a square base) illustrated below. This example is originally from: <a target='_blank' href='https://realpython.com/python-super/#super-in-multiple-inheritance'>Supercharge Your Classes With Python super() </a>. I made some modifications to simplify the code a little bit."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vk1FjIcG2cA2",
        "colab_type": "text"
      },
      "source": [
        "<center><img src='https://drive.google.com/uc?id=1IB8CgbAQtrczR_aio3d0XwOrH248OZtP'></img></center>\n",
        "\n",
        "Methods `area()` and `area2()` in RightPyramid class are two different ways to calculte the area. They should yield to the same result."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zy5rN8WP4cRR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Square:\n",
        "  def __init__(self, length, **kwargs):\n",
        "    self.length = length\n",
        "    super().__init__(**kwargs)\n",
        "  \n",
        "  def area(self):\n",
        "    return self.length * self.length\n",
        "\n",
        "  def perimeter(self):\n",
        "    return 4 * self.length\n",
        "\n",
        "class Triangle:\n",
        "  def __init__(self, base, height, **kwargs):\n",
        "    self.base = base\n",
        "    self.height = height\n",
        "    super().__init__(**kwargs)\n",
        "\n",
        "  def tri_area(self):\n",
        "    return 0.5 * self.base * self.height\n",
        "  \n",
        "  def hi(self):\n",
        "    print('Hi from Triangle')\n",
        "     \n",
        "class RightPyramid(Square, Triangle):\n",
        "  def __init__(self, base, slant_height, **kwargs):\n",
        "    self.base = base\n",
        "    self.slant_height = slant_height\n",
        "    kwargs[\"height\"] = slant_height\n",
        "    kwargs[\"length\"] = base\n",
        "    super().__init__(base=base, **kwargs)\n",
        "\n",
        "  def area(self):\n",
        "    base_area = super().area()\n",
        "    perimeter = super().perimeter()\n",
        "    return 0.5 * perimeter * self.slant_height + base_area\n",
        "\n",
        "  def area_2(self):\n",
        "    base_area = super().area()\n",
        "    triangle_area = super().tri_area()\n",
        "    return triangle_area * 4 + base_area"
      ],
      "execution_count": 67,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6DhxdJSv675s",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 108
        },
        "outputId": "2bdaedf6-10cc-4b50-bfd4-e2b10c760ce7"
      },
      "source": [
        "pyramid = RightPyramid(2, 4)\n",
        "print(pyramid.base)\n",
        "print(pyramid.height)\n",
        "print(pyramid.length)\n",
        "print(pyramid.area())\n",
        "print(pyramid.area_2())"
      ],
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "4\n",
            "2\n",
            "20.0\n",
            "20.0\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}