Update notebooks/python/python_oo.ipynb

1 files changed, 131 insertions, 64 deletions

diff --git a/notebooks/python/python_oo.ipynb b/notebooks/python/python_oo.ipynb
index 7147a87..ff48ca0 100644
--- a/notebooks/python/python_oo.ipynb
+++ b/notebooks/python/python_oo.ipynb
@@ -42,7 +42,7 @@
     "\n",
     "- **Object-oriented programming in Python: How Python \"really works\"**\n",
     "\n",
-    "- Control flow: if / for / while / try, iterators, \"tactical programming\" tips\n",
+    "- Control flow: if / for / while / try, use of iterators, \"tactical programming\" tips\n",
     "\n",
     "- A brief tour through Python's standard library\n",
     "\n",
@@ -120,6 +120,10 @@
     "\n",
     "## SOLID\n",
     "\n",
+    "Robert C. Martin - 2000 paper \"Design Principles and Design Patterns\" discussing software rot.\n",
+    "\n",
+    "The *SOLID* acronym was introduced later, around 2004, by Michael Feathers.\n",
+    "\n",
     "- **S**ingle responsibility principle - a class should have only a single responsibility or a single job or a single purpose. We should strictly avoid using generalized classes where the entire implementation is given in the same class. It also states that the responsibility should be entirely encapsulated by the class, module, or function.\n",
     "\n",
     "- **O**pen/closed principle - entities like classes, modules, functions, etc. should be open for extension and the classes should be closed for modification. This means that we should be able to extend a class behavior, without modifying it.\n",
@@ -137,9 +141,7 @@
     "\n",
     "- avoid global and non-deterministic behavior - \"we need to ensure that the global behavior of the variables and objects are minimized. This can be visualized with an example of creating an animal cheetah. The color of the animal doesn’t change after its creation. So, we need to ensure that the attribute is not global and is unreachable to make sure data clashes don’t occur. Therefore, the use of global variables or objects needs to be avoided. We can use the concept of encapsulation on the data members to solve this issue.\"\n",
     "\n",
-    "- reducing conditional statements - The usage of conditional statements must be reduced as much as possible. Using too many conditional statements in the program increases the complexity as well as the code cannot be reused. Instead, we can make use of interfaces and abstract classes and implement the conditional logic in different methods which can be reused and also, the single responsibility of the methods and classes is maintained. Wherever we need to reuse the same conditioning, we simply call the method where it is implemented instead of writing the code again.\n",
-    "\n",
-    "- autonomy principle - "
+    "- reducing conditional statements - The usage of conditional statements must be reduced as much as possible. Using too many conditional statements in the program increases the complexity as well as the code cannot be reused. Instead, we can make use of interfaces and abstract classes and implement the conditional logic in different methods which can be reused and also, the single responsibility of the methods and classes is maintained. Wherever we need to reuse the same conditioning, we simply call the method where it is implemented instead of writing the code again."
    ]
   },
   {
@@ -183,6 +185,8 @@
     "\n",
     "- `dir(obj)` -  returns a list of valid attributes for that object\n",
     "\n",
+    "- `hasattr(object, name)` - returns `True` if *object* contains attribute *name*\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",
@@ -193,44 +197,48 @@
     "\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."
+    "- `type(object)` - returns the type of an object. Useful for debugging / analysis.\n"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "d647b1ad-948d-495d-bb30-15761b806354",
+   "id": "3db6b54c-c65b-4ec8-b0d7-32123e806061",
    "metadata": {},
    "source": [
-    "# Example1\n",
-    "\n",
-    "We will create and extend classes for representing points and vectors in 2D space"
+    "# Example 1 - Creating instances of a class (objects)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "id": "391e816e-c53b-454b-9e9f-3587234f1fea",
+   "execution_count": 40,
+   "id": "a9c30a5d-aa86-45ab-b897-f051df80f1d8",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "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",
-      "8\n"
+      "car1.get_obj_info_str() = \"I am <__main__.Car object at 0x7fdda86a51d0> with id 140589990040016 from <class '__main__.Car'> with id 93981278397392\"\n",
+      "car2.get_obj_info_str() = \"I am <__main__.Car object at 0x7fdda86c4d90> with id 140589990170000 from <class '__main__.Car'> with id 93981278397392\"\n",
+      "id(Car.cls_extras) = 140589990168000, id(Car.__init__) = 140589989979424\n",
+      "car1.model = 'BMW', car1.reg_nr = 'EC76183', car1.extras = ['GPSnav', 'Sound system'], id(car1.cls_extras) = 140589990168000, id(car1.__init__) = 140589990039168\n",
+      "car2.model = 'Scoda', car2.reg_nr = 'BD77655', car2.extras = ['GPSnav'], id(car2.cls_extras) = 140589990168000, id(car2.__init__) = 140589990039808\n",
+      "car1.cls_extras = ['GPSnav', 'Sound system'], id(car1.cls_extras) = 140589990168000\n",
+      "car2.cls_extras = ['GPSnav', 'Sound system'], id(car2.cls_extras) = 140589990168000\n",
+      "True\n",
+      "hasattr(car1, 'import_tax_paid') = True\n",
+      "hasattr(car2, 'import_tax_paid') = False\n",
+      "id(car1.__class__) = 93981278397392, id(car2.__class__) = 93981278397392, id(Car) = 93981278397392\n"
      ]
     }
    ],
    "source": [
-    "class Point:\n",
-    "    \"\"\"Basic class for representing points in 2D space\"\"\"\n",
+    "class Car:  # base class that inherits only from 'object' (class Car(object): )\n",
     "\n",
-    "    def __init__(self, x: int, y: int):\n",
+    "    cls_extras = []  # class attribute - shared by all instances\n",
+    "    # cls_extras: list = [] is also possible\n",
+    "\n",
+    "    def __init__(self, model: str, reg_nr: str, extras: list):\n",
     "        \"\"\"\n",
     "        Called after the instance has been created (by __new__()), but before\n",
     "        it is returned to the caller. The arguments are those passed to the\n",
@@ -241,6 +249,78 @@
     "        initialization of the base class part of the instance;\n",
     "        for example: super().__init__([args...]).\n",
     "        \"\"\"\n",
+    "        self.model = model  # instance attribute - unique for a particular instance (object)\n",
+    "        self.reg_nr = reg_nr\n",
+    "        self.extras = extras\n",
+    "\n",
+    "        # self.cls_extras = extras  # will create a *NEW instance attribute* called 'cls_extras'\n",
+    "        \n",
+    "    def get_obj_info_str(self):  # regular method that becomes instance attribute\n",
+    "        return f\"I am {self} with id {id(self)} from {self.__class__} with id {id(self.__class__)}\"\n",
+    "\n",
+    "car1 = Car(\"BMW\", \"EC76183\", [\"GPSnav\", \"Sound system\"])\n",
+    "car2 = Car(\"Scoda\", \"BD77655\", [\"GPSnav\"])\n",
+    "\n",
+    "print(f\"{car1.get_obj_info_str() = }\")\n",
+    "print(f\"{car2.get_obj_info_str() = }\")\n",
+    "\n",
+    "# default behavior for `object.attr`:\n",
+    "# getter:\n",
+    "#     - checks if 'attr' is an instance attribute\n",
+    "#     - checks if 'attr' is a class attribute\n",
+    "#     - raises AttributeError\n",
+    "# setter: (re)defines an instance attribute\n",
+    "print(f\"{id(Car.cls_extras) = }, {id(Car.__init__) = }\")\n",
+    "print(f\"{car1.model = }, {car1.reg_nr = }, {car1.extras = }, {id(car1.cls_extras) = }, {id(car1.__init__) = }\")\n",
+    "print(f\"{car2.model = }, {car2.reg_nr = }, {car2.extras = }, {id(car2.cls_extras) = }, {id(car2.__init__) = }\")\n",
+    "car1.cls_extras.extend(car1.extras)\n",
+    "# car1.cls_extras = car1.extras  # N.B. This will create a *NEW instance attribute* called 'cls_extras'\n",
+    "print(f\"{car1.cls_extras = }, {id(car1.cls_extras) = }\")\n",
+    "print(f\"{car2.cls_extras = }, {id(car2.cls_extras) = }\")\n",
+    "\n",
+    "# creating new instance attributes that have no connection to the corresponding class (type) is possible:\n",
+    "car1.import_tax_paid = True  # 'import_tax_paid' will only be present in car1\n",
+    "print(car1.import_tax_paid)\n",
+    "print(f\"{hasattr(car1, 'import_tax_paid') = }\")  # Out: True\n",
+    "print(f\"{hasattr(car2, 'import_tax_paid') = }\")  # Out: False\n",
+    "\n",
+    "# .__class__ instance attribute pointing to its class (type) will be created\n",
+    "print(f\"{id(car1.__class__) = }, {id(car2.__class__) = }, {id(Car) = }\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d647b1ad-948d-495d-bb30-15761b806354",
+   "metadata": {},
+   "source": [
+    "# Example 2 - Creating and extending classes for representing points and vectors in 2D space"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "391e816e-c53b-454b-9e9f-3587234f1fea",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "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",
+      "8\n"
+     ]
+    }
+   ],
+   "source": [
+    "class Point:\n",
+    "    \"\"\"Basic class for representing points in 2D space\"\"\"\n",
+    "\n",
+    "    def __init__(self, x: int, y: int):\n",
     "        # defines instance attributes that will \"live\" as long as\n",
     "        # the object / instance \"lives\" \n",
     "        self._x = x  # _ indicates \"protected\" attribute\n",
@@ -260,7 +340,7 @@
     "        that class is required. This is typically used for debugging, so it is\n",
     "        important that the representation is information-rich and unambiguous.\n",
     "        \"\"\"\n",
-    "        return f\"<Point(x={self._x!r}, y={self.__y!r})>\"\n",
+    "        return f\"Point(x={self._x!r}, y={self.__y!r})\"\n",
     "\n",
     "    def __str__(self) -> str:\n",
     "        \"\"\"\n",
@@ -308,7 +388,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 42,
    "id": "e82feefb-025d-4cbb-a8ac-ddc3cc01269c",
    "metadata": {},
    "outputs": [
@@ -316,9 +396,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "my_first_vector = <Vector (start=<Point(x=0, y=0)>, end=<Point(x=9, y=12)>>\n",
-      "my_first_vector = <Vector (start=<Point(x=0, y=0)>, end=<Point(x=12, y=12)>>\n",
-      "other_vector = <Vector (start=<Point(x=0, y=0)>, end=<Point(x=12, y=12)>>\n",
+      "my_first_vector = Vector(start=Point(x=0, y=0), end=Point(x=9, y=12))\n",
+      "my_first_vector = Vector(start=Point(x=0, y=0), end=Point(x=12, y=12))\n",
+      "other_vector = Vector(start=Point(x=0, y=0), end=Point(x=12, y=12))\n",
       "other_vector.length = Decimal('16.97056274847714058562026469')\n",
       "False\n",
       "False\n",
@@ -337,10 +417,9 @@
     "        self._end = end\n",
     "\n",
     "    def __repr__(self) -> str:\n",
-    "        return f\"<Vector (start={self._start!r}, end={self._end!r}>\"\n",
+    "        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",
@@ -354,7 +433,7 @@
     "        self._end = value\n",
     "\n",
     "    @property\n",
-    "    def length(self) -> decimal.Decimal:\n",
+    "    def length(self) -> decimal.Decimal:  # could also be a method f.i. def get_length(self) -> decimal.Decimal:\n",
     "        \"\"\"length of a Vector property\"\"\"\n",
     "        # length: sqrt(a^2 + b^2)\n",
     "        return (\n",
@@ -391,7 +470,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 43,
    "id": "71a90ec6-3cc0-441e-a866-c2c2b9984559",
    "metadata": {},
    "outputs": [
@@ -399,9 +478,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "my_first_vector = <Vector (start=<Point(x=0, y=0)>, end=<Point(x=9, y=12)>>\n",
-      "my_first_vector = <Vector (start=<Point(x=0, y=0)>, end=<Point(x=12, y=12)>>\n",
-      "other_vector = <Vector (start=<Point(x=0, y=0)>, end=<Point(x=12, y=12)>>\n",
+      "my_first_vector = Vector(start=<Point(x=0, y=0)>, end=<Point(x=9, y=12)>)\n",
+      "my_first_vector = Vector(start=<Point(x=0, y=0)>, end=<Point(x=12, y=12)>)\n",
+      "other_vector = Vector(start=<Point(x=0, y=0)>, end=<Point(x=12, y=12)>)\n",
       "other_vector.length = Decimal('16.97056274847714058562026469')\n",
       "True\n",
       "True\n",
@@ -440,7 +519,11 @@
     "        A rich comparison method may return the singleton NotImplemented if it\n",
     "        does not implement the operation for a given pair of arguments.\n",
     "        By convention, False and True are returned for a successful comparison.\n",
-    "        However, these methods can return any value\n",
+    "        However, these methods can return any value.\n",
+    "        \n",
+    "        If the operands are of different types, and right operand’s type is a direct or indirect\n",
+    "        subclass of the left operand’s type, the reflected method of the right operand has priority,\n",
+    "        otherwise the left operand’s method has priority. Virtual subclassing is not considered.\n",
     "        \"\"\"\n",
     "        return self._x == other.x and self._y == other.y\n",
     "\n",
@@ -505,7 +588,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 44,
    "id": "a4d2735d-d167-4f43-ad55-cb3d13ece2dc",
    "metadata": {},
    "outputs": [
@@ -548,7 +631,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 45,
    "id": "a6ead5e6-e987-4bda-bf48-30f91877278d",
    "metadata": {},
    "outputs": [
@@ -607,7 +690,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 46,
    "id": "11f6a3fb-64d7-40a9-a130-27548ec4b802",
    "metadata": {},
    "outputs": [
@@ -616,9 +699,9 @@
      "output_type": "stream",
      "text": [
       "__mul__ called\n",
-      "vector * 3 = <Vector (start=<Point(x=2, y=2)>, end=<Point(x=12, y=18)>>\n",
+      "vector * 3 = Vector(start=<Point(x=2, y=2)>, end=<Point(x=12, y=18)>)\n",
       "__rmul__ called\n",
-      "3 * vector = <Vector (start=<Point(x=2, y=2)>, end=<Point(x=12, y=18)>>\n"
+      "3 * vector = Vector(start=<Point(x=2, y=2)>, end=<Point(x=12, y=18)>)\n"
      ]
     }
    ],
@@ -685,7 +768,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 47,
    "id": "c345a69f-02da-40e7-bb37-c0511b6af096",
    "metadata": {},
    "outputs": [
@@ -694,7 +777,7 @@
      "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"
+      "Vector.from_str('1:1:5:6') = Vector(start=<Point(x=1, y=1)>, end=<Point(x=5, y=6)>)\n"
      ]
     }
    ],
@@ -776,7 +859,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 48,
    "id": "44d47e1c-1a06-4577-8db6-6ec78ce5cef8",
    "metadata": {},
    "outputs": [
@@ -950,7 +1033,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 49,
    "id": "e6076925-75f0-456c-aed5-7db0a24a67a1",
    "metadata": {},
    "outputs": [
@@ -1061,7 +1144,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 50,
    "id": "cf79617a-95d2-48f2-be66-fa1fa34e4e04",
    "metadata": {},
    "outputs": [
@@ -1140,7 +1223,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 51,
    "id": "95a1d0cc-0006-4ddc-b08d-d0b8b02acfba",
    "metadata": {},
    "outputs": [
@@ -1206,7 +1289,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 52,
    "id": "38066107-0190-4383-ba14-a4e9cd454a9c",
    "metadata": {},
    "outputs": [
@@ -1216,23 +1299,7 @@
      "text": [
       "Using mock data\n",
       "Extracting production plans from data\n",
-      "some magic is happening here...\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'{}'"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "some magic is happening here...\n",
       "(<class '__main__.MockedButStillCoolTSPreprocessor'>, <class '__main__.CoolTSPreprocessor'>, <class '__main__.MockConnectionManager'>, <class '__main__.ConnectionManager'>, <class 'object'>)\n"
      ]
     }
@@ -1291,7 +1358,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.8"
+   "version": "3.11.1"
   }
  },
  "nbformat": 4,