Add inheritance slides in python-OO

1 files changed, 485 insertions, 28 deletions

diff --git a/notebooks/python/python_oo.ipynb b/notebooks/python/python_oo.ipynb
index 7ce5c73..2440efb 100644
--- a/notebooks/python/python_oo.ipynb
+++ b/notebooks/python/python_oo.ipynb
@@ -33,6 +33,24 @@
   },
   {
    "cell_type": "markdown",
+   "id": "be3062ad-9437-4ba2-9975-c2837b0af9dc",
+   "metadata": {},
+   "source": [
+    "# The big picture - the course so far\n",
+    "\n",
+    "- Basics: About the language, the Python eco-system, types, modules, functions, scopes, decorators, string formatting\n",
+    "\n",
+    "- **Object-oriented programming in Python: How Python \"really works\"**\n",
+    "\n",
+    "- Control flow: if / for / while / try, iterators, \"tactical programming\" tips\n",
+    "\n",
+    "- A brief tour through Python's standard library\n",
+    "\n",
+    "- Code and application design and best practices: How to design your code\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
    "id": "d6d3d0e7-c1d5-4119-940e-0f94ee7542ec",
    "metadata": {},
    "source": [
@@ -147,9 +165,35 @@
     "Python has automatic memory management using reference counting. When an object no longer has\n",
     "any references, the garbage collector kicks inn and removes the object from memory.\n",
     "\n",
+    "Access modifiers in Python are not enforced by the classic 'public', 'protected' and 'private' keywords, but rather by convention.\n",
+    "\n",
     "\"The Zen of Python\" (import this) is still relevant and should be followed :)\n",
     "\n",
-    "\"Python will remain a dynamically typed language, and the authors have no desire to ever make type hints mandatory, even by convention.\" - PEP484"
+    "\"Python will remain a dynamically typed language, and the authors have no desire to ever make type hints mandatory, even by convention.\" - PEP484\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4a57a560-bd01-48dc-99b8-2af816f9c83b",
+   "metadata": {},
+   "source": [
+    "# Useful builtin functions\n",
+    "\n",
+    "\n",
+    "- `dir(obj)` -  returns a list of valid attributes for that object\n",
+    "\n",
+    "- `help(object)` - invokes the built-in help system. This function is intended for interactive use.\n",
+    "\n",
+    "- `id(object)` - returns the \"identity\" (unique number) of the *object*\n",
+    "\n",
+    "- `isinstance(object, classinfo)` - returns `True` if the object argument is an instance of the classinfo argument, or a subclass thereof (**N.B** don't use `type(x) == type(y)`)\n",
+    "\n",
+    "- `issubclass(class, classinfo)` - returns `True` if class is a subclass of classinfo. A class is considered a subclass of itself.\n",
+    "\n",
+    "- `super([type[, object-or-type]])` - returns a proxy object that delegates method calls to a parent or sibling class of type. This is useful for accessing inherited methods that have been overridden in a class. **More on that later**.\n",
+    "\n",
+    "- `type(object)` - returns the type of an object. Useful for debugging / analysis."
    ]
   },
   {
@@ -164,7 +208,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 154,
+   "execution_count": 287,
    "id": "391e816e-c53b-454b-9e9f-3587234f1fea",
    "metadata": {},
    "outputs": [
@@ -172,7 +216,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "my_first_point = <Point(x=2, y=8)>\n",
+      "2:8\n",
+      "<Point(x=2, y=8)>\n",
+      "my_first_point = 2:8\n",
       "my_first_point = <Point(x=2, y=8)>\n",
       "2\n",
       "2\n",
@@ -242,8 +288,10 @@
     "\n",
     "my_first_point = Point(2, 8)\n",
     "\n",
-    "print(f\"{my_first_point = }\")\n",
-    "print(f\"{my_first_point = !r}\")\n",
+    "print(f\"{my_first_point}\")  # !s is implicit\n",
+    "print(f\"{my_first_point!r}\")\n",
+    "print(f\"{my_first_point = !s}\")\n",
+    "print(f\"{my_first_point = !r}\")  # !r is implicit when using =\n",
     "print(my_first_point.x)\n",
     "\n",
     "# we \"should not\" be accessing private and protected attributes directly\n",
@@ -258,7 +306,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 155,
+   "execution_count": 288,
    "id": "e82feefb-025d-4cbb-a8ac-ddc3cc01269c",
    "metadata": {},
    "outputs": [
@@ -290,6 +338,7 @@
     "        return f\"<Vector (start={self._start!r}, end={self._end!r}>\"\n",
     "\n",
     "    def __str__(self) -> str:\n",
+    "        print('str-called')\n",
     "        return f\"{self._start} -> {self._end}\"\n",
     "\n",
     "    @property\n",
@@ -323,11 +372,11 @@
     "\n",
     "\n",
     "my_first_vector = Vector(Point(0, 0), Point(9, 12))\n",
-    "print(f\"{my_first_vector = !r}\")\n",
+    "print(f\"{my_first_vector = }\")\n",
     "my_first_vector.end = Point(12, 12)\n",
-    "print(f\"{my_first_vector = !r}\")\n",
+    "print(f\"{my_first_vector = }\")\n",
     "other_vector = Vector(Point(0, 0), Point(12, 12))\n",
-    "print(f\"{other_vector = !r}\")\n",
+    "print(f\"{other_vector = }\")\n",
     "print(f\"{other_vector.length = }\")\n",
     "\n",
     "# the objects do not evaluate as \"alike\" because:\n",
@@ -340,7 +389,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 156,
+   "execution_count": 289,
    "id": "71a90ec6-3cc0-441e-a866-c2c2b9984559",
    "metadata": {},
    "outputs": [
@@ -413,11 +462,11 @@
     "\n",
     "\n",
     "my_first_vector = Vector(Point(0, 0), Point(9, 12))\n",
-    "print(f\"{my_first_vector = !r}\")\n",
+    "print(f\"{my_first_vector = }\")\n",
     "my_first_vector.end = Point(12, 12)\n",
-    "print(f\"{my_first_vector = !r}\")\n",
+    "print(f\"{my_first_vector = }\")\n",
     "other_vector = Vector(Point(0, 0), Point(12, 12))\n",
-    "print(f\"{other_vector = !r}\")\n",
+    "print(f\"{other_vector = }\")\n",
     "print(f\"{other_vector.length = }\")\n",
     "\n",
     "print(Point(1, 2) == Point(1, 2))\n",
@@ -454,7 +503,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 157,
+   "execution_count": 290,
    "id": "a4d2735d-d167-4f43-ad55-cb3d13ece2dc",
    "metadata": {},
    "outputs": [
@@ -497,7 +546,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 158,
+   "execution_count": 291,
    "id": "a6ead5e6-e987-4bda-bf48-30f91877278d",
    "metadata": {},
    "outputs": [
@@ -556,7 +605,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 159,
+   "execution_count": 292,
    "id": "11f6a3fb-64d7-40a9-a130-27548ec4b802",
    "metadata": {},
    "outputs": [
@@ -634,19 +683,426 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 293,
    "id": "c345a69f-02da-40e7-bb37-c0511b6af096",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "9\n",
+      "Vector.from_str('1:1:5:6') = <Vector (start=<Point(x=1, y=1)>, end=<Point(x=5, y=6)>>\n"
+     ]
+    }
+   ],
    "source": [
     "# Class methods and static methods\n",
     "\n",
+    "class Point(Point):\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def get_manhattan_distance(point1: Point, point2: Point) -> int:\n",
+    "        \"\"\"Returns the Manhattan distance of two points\"\"\"\n",
+    "        return abs(point1.x - point2.x) + abs(point1.y - point2.y)\n",
+    "\n",
+    "\n",
     "class Vector(Vector):\n",
-    "    \n",
+    "\n",
     "    @classmethod\n",
-    "    def from_str(cls, obj_str: str) -> cls:\n",
+    "    def from_str(cls, obj_str: str):\n",
+    "        \"\"\"\n",
+    "        Creates an object from a string with the following format:\n",
+    "        <startx>:<starty>:<endx>:<endy>\n",
     "        \"\"\"\n",
-    "        "
+    "        coordinates = [int(coordinate_str) for coordinate_str in obj_str.split(\":\")]\n",
+    "        return cls(\n",
+    "            Point(coordinates[0], coordinates[1]),\n",
+    "            Point(coordinates[2], coordinates[3]),\n",
+    "        )\n",
+    "\n",
+    "print(Point.get_manhattan_distance(Point(1, 1), Point(5, 6)))\n",
+    "print(f\"{Vector.from_str('1:1:5:6') = }\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "61c1e910-9398-455d-b0c2-cda6c6870224",
+   "metadata": {},
+   "source": [
+    "# Inheritance in Python\n",
+    "\n",
+    "In object-oriented programming, inheritance is the mechanism of basing an object or class upon another object (prototype-based inheritance) or class (class-based inheritance), retaining similar implementation. Also defined as deriving new classes (sub classes) from existing ones such as super class or base class and then forming them into a hierarchy of classes.\n",
+    "\n",
+    "In most class-based object-oriented languages, an object created through inheritance, a \"child object\", acquires all the properties and behaviors of the \"parent object\" , with the exception of: constructors, destructor, overloaded operators and friend functions of the base class.  \n",
+    "Inheritance allows programmers to create classes that are built upon existing classes, to specify a new implementation while maintaining the same behaviors (realizing an interface), to reuse code and to independently extend original software via public classes and interfaces.\n",
+    "\n",
+    "One can simply view inheritance as a tool for code reuse.\n",
+    "\n",
+    "Inheritance is not the only mechanism for extending classes and functionality in general."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eac035eb-7757-485a-be6c-c450bf9ee748",
+   "metadata": {},
+   "source": [
+    "# The `super([type[, object-or-type])` function\n",
+    "\n",
+    "A common misconception is that `super()` returns an object of the parent class.\n",
+    "\n",
+    "There are two typical use cases for `super()`:\n",
+    "\n",
+    "In a class hierarchy with **single inheritance**, `super()` can be used to refer to parent classes without naming them explicitly, thus making the code more maintainable.\n",
+    "This use closely parallels the use of super in other programming languages.\n",
+    "\n",
+    "The second use case is to support cooperative multiple inheritance in a dynamic execution environment.  \n",
+    "This use case is unique to Python and is not found in statically compiled languages or languages that only support single inheritance.  \n",
+    "This makes it possible to implement \"diamond diagrams\" where multiple base classes implement the same method.  \n",
+    "Good design dictates that such implementations have the same calling signature in every case (because the order of calls is determined at runtime, because that order adapts to changes in the class hierarchy, and because that order can include sibling classes that are unknown prior to runtime)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d1d17f26-de6e-4510-b0f0-3ae02761ae24",
+   "metadata": {},
+   "source": [
+    "# Example 2\n",
+    "\n",
+    "We will create a small and incomplete Animal class hierarchy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 294,
+   "id": "44d47e1c-1a06-4577-8db6-6ec78ce5cef8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Moo\n",
+      "Help on class TigerShark in module __main__:\n",
+      "\n",
+      "class TigerShark(Fish)\n",
+      " |  TigerShark(weight: int, alive: bool = True, **kwargs)\n",
+      " |  \n",
+      " |  Base class for all tiger sharks\n",
+      " |  \n",
+      " |  Method resolution order:\n",
+      " |      TigerShark\n",
+      " |      Fish\n",
+      " |      Animal\n",
+      " |      builtins.object\n",
+      " |  \n",
+      " |  Methods defined here:\n",
+      " |  \n",
+      " |  __init__(self, weight: int, alive: bool = True, **kwargs)\n",
+      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
+      " |  \n",
+      " |  ----------------------------------------------------------------------\n",
+      " |  Data descriptors inherited from Animal:\n",
+      " |  \n",
+      " |  __dict__\n",
+      " |      dictionary for instance variables (if defined)\n",
+      " |  \n",
+      " |  __weakref__\n",
+      " |      list of weak references to the object (if defined)\n",
+      " |  \n",
+      " |  alive\n",
+      " |      getter property alive\n",
+      " |  \n",
+      " |  weight\n",
+      " |      getter property weight\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# This example demonstrates a simple and incomplete animal class hierarchy\n",
+    "\n",
+    "# N.B. The use of super() in this example is not optimal\n",
+    "\n",
+    "\n",
+    "class Animal:\n",
+    "    \"\"\"Base class for all animals, inheriting only from 'builtins.object'\"\"\"\n",
+    "\n",
+    "    def __init__(self, weight: int, alive: bool = True, **kwargs):\n",
+    "        self._weight = weight\n",
+    "        self._alive = alive\n",
+    "\n",
+    "    @property\n",
+    "    def weight(self) -> int:\n",
+    "        \"\"\"getter property weight\"\"\"\n",
+    "        return self._weight\n",
+    "\n",
+    "    @weight.setter\n",
+    "    def weight(self, value: int):\n",
+    "        \"\"\"setter property weight\"\"\"\n",
+    "        self._weight = value\n",
+    "\n",
+    "    @property\n",
+    "    def alive(self) -> bool:\n",
+    "        \"\"\"getter property alive\"\"\"\n",
+    "        return self._alive\n",
+    "\n",
+    "    @alive.setter\n",
+    "    def alive(self, value: bool):\n",
+    "        \"\"\"setter property alive\"\"\"\n",
+    "        self._alive = value\n",
+    "\n",
+    "\n",
+    "class Mammal(Animal):\n",
+    "    \"\"\"Base class for all mammals\"\"\"\n",
+    "\n",
+    "    def __init__(self, weight: int, tooth_replacement: bool, alive: bool = True, **kwargs):\n",
+    "        super().__init__(weight, alive, **kwargs)\n",
+    "        self._tooth_replacement = tooth_replacement\n",
+    "\n",
+    "\n",
+    "class Fish(Animal):\n",
+    "    \"\"\"Base class for all fish\"\"\"\n",
+    "\n",
+    "    def __init__(self, weight: int, gill_openings: int, alive: bool = True, **kwargs):\n",
+    "        super().__init__(weight, alive, **kwargs)\n",
+    "        self._gill_openings = gill_openings\n",
+    "\n",
+    "\n",
+    "class Tiger(Mammal):\n",
+    "    \"\"\"Base class for all tigers\"\"\"\n",
+    "\n",
+    "    def __init__(self, weight: int, conservation_status: str, alive: bool = True, **kwargs):\n",
+    "        super().__init__(\n",
+    "            weight=weight, tooth_replacement=True, alive=alive, **kwargs\n",
+    "        )\n",
+    "        self_conservation_status = conservation_status\n",
+    "\n",
+    "\n",
+    "class Cow(Mammal):\n",
+    "    \"\"\"Base class for all cows\"\"\"\n",
+    "\n",
+    "    def __init__(self, weight: int, alive: bool = True, **kwargs):\n",
+    "        super().__init__(\n",
+    "            weight=weight, tooth_replacement=True, alive=alive, **kwargs\n",
+    "        )\n",
+    "\n",
+    "    def make_a_sound(self):\n",
+    "        if self._alive:\n",
+    "            print(\"Moo\" if self._weight > 60 else \"Mee\")\n",
+    "\n",
+    "\n",
+    "class TigerShark(Fish):\n",
+    "    \"\"\"Base class for all tiger sharks\"\"\"\n",
+    "\n",
+    "    def __init__(self, weight: int, alive: bool = True, **kwargs):\n",
+    "        super().__init__(weight=weight, gill_openings=3, alive=alive, **kwargs)\n",
+    "\n",
+    "tiger1 = Tiger(200, \"Endangered\")\n",
+    "tiger2 = Tiger(183, \"Critically endangered\")\n",
+    "cow1 = Cow(350)\n",
+    "cow1.make_a_sound()\n",
+    "tiger_shark1 = TigerShark(80)\n",
+    "help(TigerShark)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cc950a82-40a0-4bdb-89a0-ea6e2ebe5861",
+   "metadata": {},
+   "source": [
+    "# Challenges\n",
+    "\n",
+    "At least two obvious problems arise:\n",
+    "\n",
+    "- how do we handle the growing amount of params we have to send to `super()`?\n",
+    "\n",
+    "- how do insert functionality that does not necessarily follow the structure of our hierarchy. F.i predator functionality?\n",
+    "\n",
+    "\n",
+    "## Possible solutions\n",
+    "\n",
+    "- use `**kwargs` to collect and transmit even 'unwanted' params\n",
+    "\n",
+    "- use multiple inheritance and mixins\n",
+    "\n",
+    "\n",
+    "## Mixins\n",
+    "\n",
+    "A mixin is a class that provides method implementations for reuse by multiple related child classes. However, the inheritance is not implying an is-a relationship.\n",
+    "\n",
+    "A mixin doesn't define a new type. Therefore, it is not intended for direction instantiation.\n",
+    "\n",
+    "A mixin bundles a set of methods for reuse. Each mixin should have a single specific behavior, implementing closely related methods.\n",
+    "\n",
+    "Typically, a child class uses multiple inheritance to combine the mixin classes with a parent class.\n",
+    "\n",
+    "Since Python doesn’t define a formal way to define mixin classes, it’s a good practice to name mixin classes with the suffix *Mixin*.\n",
+    "\n",
+    "Usually, a mixin class should not have any attributes that overlap with the established hierarchy.\n",
+    "\n",
+    "A mixin class is like an interface in Java, hence the phrase 'implements X functionality' should fit in the mixin description.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "35b3a8eb-e7b0-4181-822f-923a74a7ab27",
+   "metadata": {},
+   "source": [
+    "# Example 3\n",
+    "\n",
+    "Demonstrates the use of mixins."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 295,
+   "id": "e6076925-75f0-456c-aed5-7db0a24a67a1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'_weight': 80, '_alive': True, '_gill_openings': 3}\n",
+      "{\"_weight\": 80, \"_alive\": true, \"_gill_openings\": 3}\n",
+      "{\"_weight\": 80, \"_alive\": true, \"_gill_openings\": 3}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Multiple inheritance and mixins\n",
+    "import json\n",
+    "\n",
+    "class DictMixin:\n",
+    "    \"\"\"Implements a dictionary conversion functionality\"\"\"\n",
+    "\n",
+    "    def to_dict(self):\n",
+    "        return self._traverse_dict(self.__dict__)\n",
+    "\n",
+    "    def _traverse_dict(self, attributes):\n",
+    "        result = {}\n",
+    "        for key, value in attributes.items():\n",
+    "            result[key] = self._traverse(key, value)\n",
+    "        return result\n",
+    "\n",
+    "    def _traverse(self, key, value):\n",
+    "        if isinstance(value, DictMixin):\n",
+    "            return value.to_dict()\n",
+    "        elif isinstance(value, dict):\n",
+    "            return self._traverse_dict(value)\n",
+    "        elif isinstance(value, list):\n",
+    "            return [self._traverse(key, v) for v in value]\n",
+    "        elif hasattr(value, '__dict__'):\n",
+    "            return self._traverse_dict(value.__dict__)\n",
+    "        else:\n",
+    "            return value\n",
+    "\n",
+    "\n",
+    "class JSONMixin:\n",
+    "    \"\"\"Implements a JSON conversion functionality\"\"\"\n",
+    "\n",
+    "    def to_json(self):\n",
+    "        return json.dumps(self._traverse_dict(self.__dict__))\n",
+    "\n",
+    "\n",
+    "class AnotherJSONMixin(DictMixin, JSONMixin):\n",
+    "    \"\"\"Another JSON mixin that implements JSON conversion\"\"\"\n",
+    "\n",
+    "\n",
+    "class DictableTigerShark(TigerShark, DictMixin):\n",
+    "    \"\"\"\n",
+    "    A tiger shark class that provides a dictionary conversion functionality\n",
+    "    \"\"\"\n",
+    "\n",
+    "\n",
+    "class JSONConvertableTigerShark(TigerShark, DictMixin, JSONMixin):\n",
+    "    \"\"\"A tiger shark class that provides JSON conversion functionality\"\"\"\n",
+    "\n",
+    "\n",
+    "class AnotherJSONConvertableTigerShark(TigerShark, AnotherJSONMixin):\n",
+    "    \"\"\"\n",
+    "    Another tiger shark class that provides JSON conversion functionality\n",
+    "    \"\"\"\n",
+    "\n",
+    "\n",
+    "dict_tiger_shark = DictableTigerShark(80)\n",
+    "json_tiger_shark = JSONConvertableTigerShark(80)\n",
+    "another_json_tiger_shark = AnotherJSONConvertableTigerShark(80)\n",
+    "print(f\"{dict_tiger_shark.to_dict()}\")\n",
+    "print(f\"{json_tiger_shark.to_json()}\")\n",
+    "print(f\"{another_json_tiger_shark.to_json()}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7624fb8e-f1dd-4ad6-a1c2-f01cca6b1f2a",
+   "metadata": {},
+   "source": [
+    "# Multiple inheritance and `super`\n",
+    "\n",
+    "A common misconception is that `super()` returns an object of the parent class. (repeated)\n",
+    "\n",
+    "Whenever you use `super()` you **can not know in advance** where / what it is going to call.\n",
+    "\n",
+    "In other words, you don't get to choose who your `super()` is going to call, your children get to choose.  \n",
+    "Single inheritance is just a special case and simplification of the general rule.\n",
+    "\n",
+    "Python>=2.3 uses the [C3 Method Resolution Order (MRO)](https://www.python.org/download/releases/2.3/mro/), replacing the old *depth first and then left to right* in Python<=2.2."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 296,
+   "id": "cf79617a-95d2-48f2-be66-fa1fa34e4e04",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Simeon's MRO: (<class '__main__.Simeon'>, <class '__main__.Mother'>, <class '__main__.Grandmother1'>, <class '__main__.Grandfather1'>, <class '__main__.Father'>, <class '__main__.Grandmother2'>, <class '__main__.Grandfather2'>, <class '__main__.Adam'>, <class '__main__.Eve'>, <class 'object'>)\n"
+     ]
+    }
+   ],
+   "source": [
+    "class Adam:\n",
+    "    pass\n",
+    "\n",
+    "\n",
+    "class Eve:\n",
+    "    pass\n",
+    "\n",
+    "\n",
+    "class Grandmother1(Adam, Eve):\n",
+    "    pass\n",
+    "\n",
+    "\n",
+    "class Grandmother2(Adam, Eve):\n",
+    "    pass\n",
+    "\n",
+    "\n",
+    "class Grandfather1(Adam, Eve):\n",
+    "    pass\n",
+    "\n",
+    "\n",
+    "class Grandfather2(Adam, Eve):\n",
+    "    pass\n",
+    "\n",
+    "\n",
+    "class Mother(Grandmother1, Grandfather1):\n",
+    "    pass\n",
+    "\n",
+    "\n",
+    "class Father(Grandmother2, Grandfather2):\n",
+    "    pass\n",
+    "\n",
+    "\n",
+    "class Simeon(Mother, Father):\n",
+    "    pass\n",
+    "\n",
+    "\n",
+    "print(f\"Simeon's MRO: {Simeon.__mro__}\")"
    ]
   },
   {
@@ -656,18 +1112,19 @@
    "source": [
     "# Additional reading\n",
     "\n",
-    "- [Descriptors](https://docs.python.org/3/reference/datamodel.html#implementing-descriptors)\n",
-    "\n",
-    "- [Metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)\n",
+    "- Preferably everything in [Data model - https://docs.python.org/3/reference/datamodel.html](https://docs.python.org/3/reference/datamodel.html)\n",
     "\n",
-    "- `__call__`\n",
+    "    - [Descriptors](https://docs.python.org/3/reference/datamodel.html#implementing-descriptors)\n",
     "\n",
-    "- `__getattr__`\n",
+    "    - [Metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)\n",
     "\n",
-    "- `__hash__`\n",
+    "    - `__call__`\n",
     "\n",
+    "    - `__getattr__`\n",
     "\n",
-    "... preferably everything in [Data model - https://docs.python.org/3/reference/datamodel.html](https://docs.python.org/3/reference/datamodel.html)"
+    "    - `__hash__`\n",
+    "    \n",
+    "    - ...\n"
    ]
   }
  ],