Update notebooks/python/python_3_8_to_3_11.ipynb and notebooks/python/python_oo.ipynb

2 files changed, 270 insertions, 85 deletions

diff --git a/notebooks/python/python_3_8_to_3_11.ipynb b/notebooks/python/python_3_8_to_3_11.ipynb
index 52d5630..62fea7d 100644
--- a/notebooks/python/python_3_8_to_3_11.ipynb
+++ b/notebooks/python/python_3_8_to_3_11.ipynb
@@ -5,7 +5,7 @@
    "id": "95c6942c-cd6a-437f-a35e-f6bbaf3555bd",
    "metadata": {},
    "source": [
-    "# A very brief summary of changes introduced in Python 3.8, 3.9, 3.10 and 3.11\n"
+    "# A very brief summary of changes introduced in Python 3.8, 3.9, 3.10 and 3.11"
    ]
   },
   {
@@ -31,7 +31,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 226,
+   "execution_count": 113,
    "id": "a21e461a-8a7c-49d2-8a53-ab63ff2488bb",
    "metadata": {},
    "outputs": [
@@ -40,10 +40,7 @@
      "output_type": "stream",
      "text": [
       "List is too long (6 elements, expected <= 10)\n",
-      "List is too long (6 elements, expected <= 10)\n",
-      "my_list[3]='Eric'\n",
-      "my_list[4]='Terry J'\n",
-      "my_list[5]=Michael\n"
+      "List is too long (6 elements, expected <= 10)\n"
      ]
     }
    ],
@@ -59,18 +56,12 @@
     "\n",
     "# while using the walrus operator...\n",
     "if (list_length := len(my_list)) > 5:\n",
-    "    print(f\"List is too long ({list_length} elements, expected <= 10)\")\n",
-    "\n",
-    "\n",
-    "# f-strings support for self-documenting expressions and debugging using =\n",
-    "print(f\"{my_list[3]=!r}\")\n",
-    "print(f\"{my_list[4]=}\")  # !r is implicit\n",
-    "print(f\"{my_list[5]=!s}\")"
+    "    print(f\"List is too long ({list_length} elements, expected <= 10)\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 227,
+   "execution_count": 114,
    "id": "99b75989-e991-4f77-a62e-01776f5b606c",
    "metadata": {},
    "outputs": [
@@ -114,6 +105,29 @@
    ]
   },
   {
+   "cell_type": "code",
+   "execution_count": 115,
+   "id": "f683072f-c555-404b-b2c9-0d7d3621b118",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "my_list[3]='Eric'\n",
+      "my_list[4]='Terry J'\n",
+      "my_list[5]=Michael\n"
+     ]
+    }
+   ],
+   "source": [
+    "# f-strings support for self-documenting expressions and debugging using =\n",
+    "print(f\"{my_list[3]=!r}\")\n",
+    "print(f\"{my_list[4]=}\")  # !r is implicit\n",
+    "print(f\"{my_list[5]=!s}\")"
+   ]
+  },
+  {
    "cell_type": "markdown",
    "id": "1801f5cb-6620-43c9-a1c8-1ada25b046bf",
    "metadata": {},
@@ -151,7 +165,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 228,
+   "execution_count": 116,
    "id": "a21fdf0a-92d2-4987-93c4-ea68f34f71b3",
    "metadata": {},
    "outputs": [
@@ -161,7 +175,15 @@
      "text": [
       "2019\n",
       "('GREHAM', 'John', 'TerryG', 'Eric', 'TerryJ', 'Michael')\n",
-      "9.333333333333334\n",
+      "Performing a very expensive operation\n",
+      "Performing a very expensive operation\n",
+      "dataset.string='836278421', id(dataset.string)=36514294704\n",
+      "Performing a very expensive operation\n",
+      "Performing a very expensive operation\n",
+      "dataset.string='836278421', id(dataset.string)=36514289520\n",
+      "Performing a very expensive operation\n",
+      "dataset.cached_string='836278421', id(dataset.cached_string)=36514289520\n",
+      "dataset.cached_string='836278421', id(dataset.cached_string)=36514289520\n",
       "Permutations of 10 things taken 3 at a time: math.perm(10, 3)=720\n",
       "Combinations of 10 things taken 3 at a time: math.comb(10, 3)=120\n"
      ]
@@ -172,7 +194,7 @@
     "import re\n",
     "\n",
     "notice = \"Copyright © 2019\"\n",
-    "copyright_year_pattern = re.compile(r\"\\N{copyright sign}\\s*(\\d{4})\")\n",
+    "copyright_year_pattern = re.compile(r\"\\N{copyright sign}\\s*(\\d{4})\")  # expands to the named Unicode character\n",
     "print(copyright_year_pattern.search(notice).group(1))\n",
     "\n",
     "\n",
@@ -187,11 +209,11 @@
     "# functools.lru_cache() can now be used as a straight decorator rather than as a function returning a decorator\n",
     "import functools\n",
     "\n",
-    "@functools.lru_cache\n",
+    "@functools.lru_cache(maxsize=256)\n",
     "def f(x):\n",
     "    pass\n",
     "\n",
-    "@functools.lru_cache(maxsize=256)\n",
+    "@functools.lru_cache  # Python >= 3.8 (maxsize will be 128)\n",
     "def f(x):\n",
     "    pass\n",
     "\n",
@@ -200,15 +222,26 @@
     "import statistics\n",
     "\n",
     "class Dataset:\n",
-    "   def __init__(self, sequence_of_numbers):\n",
-    "      self.data = sequence_of_numbers\n",
+    "    def __init__(self, sequence_of_numbers):\n",
+    "        self.data = sequence_of_numbers\n",
+    "\n",
+    "    @property\n",
+    "    def string(self) -> str:\n",
+    "        return self._stringify()\n",
     "\n",
-    "   @functools.cached_property\n",
-    "   def variance(self):\n",
-    "      return statistics.variance(self.data)\n",
+    "    @functools.cached_property\n",
+    "    def cached_string(self) -> str:\n",
+    "        return self._stringify()\n",
     "\n",
-    "dataset = Dataset((8, 2, 4))\n",
-    "print(dataset.variance)\n",
+    "    def _stringify(self) -> str:\n",
+    "        print(\"Performing a very expensive operation\")\n",
+    "        return \"\".join(map(str, self.data))\n",
+    "\n",
+    "dataset = Dataset((836, 278, 421))\n",
+    "print(f\"{dataset.string=}, {id(dataset.string)=}\")\n",
+    "print(f\"{dataset.string=}, {id(dataset.string)=}\")\n",
+    "print(f\"{dataset.cached_string=}, {id(dataset.cached_string)=}\")\n",
+    "print(f\"{dataset.cached_string=}, {id(dataset.cached_string)=}\")\n",
     "\n",
     "\n",
     "# new combinatoric functions math.perm() and math.comb()\n",
@@ -247,7 +280,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 229,
+   "execution_count": 117,
    "id": "1f567f26-3783-4435-bcff-48826ea50404",
    "metadata": {},
    "outputs": [
@@ -256,8 +289,7 @@
      "output_type": "stream",
      "text": [
       "{'key1': 'value1 from x', 'key2': 'value2 from y', 'key3': 'value3 from y'}\n",
-      "{'key1': 'value1 from x', 'key2': 'value2 from y', 'key3': 'value3 from y'}\n",
-      "Bravely bold Sir Robin rode forth fro\n"
+      "{'key1': 'value1 from x', 'key2': 'value2 from y', 'key3': 'value3 from y'}\n"
      ]
     }
    ],
@@ -273,12 +305,27 @@
     "\n",
     "x |= y\n",
     "\n",
-    "print(f\"{x}\")\n",
-    "\n",
-    "\n",
+    "print(f\"{x}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 118,
+   "id": "3f527469-64c7-4cef-8a4d-ef536c418fa1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Bravely bold Sir Robin rode forth fro\n"
+     ]
+    }
+   ],
+   "source": [
     "# PEP 616 – String methods to remove prefixes and suffixes\n",
     "\n",
-    "print(\"Bravely bold Sir Robin rode forth from Camelot\".removesuffix(\"m Camelot\"))\n"
+    "print(\"Bravely bold Sir Robin rode forth from Camelot\".removesuffix(\"m Camelot\"))"
    ]
   },
   {
@@ -335,9 +382,59 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 230,
+   "execution_count": 119,
    "id": "11aaff48-28a3-49f5-86b6-059af6ab534d",
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Parenthesized context managers are now officially allowed\n",
+    "import io\n",
+    "\n",
+    "with (\n",
+    "    io.open(\"input_file.dat\", \"rb\") as input_fp,\n",
+    "    io.open(\"output_file.dat\", \"wb\") as output_fp,\n",
+    "):\n",
+    "    data = input_fp.read()\n",
+    "    # do some processing magic on data\n",
+    "    output_fp.write(data)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "208a032f-c0f1-4591-8dbb-3d10e080c29f",
+   "metadata": {},
+   "source": [
+    "### Better error messages:\n",
+    "\n",
+    "```Python\n",
+    "the_pythons = [\"Greham\", \"John\", \"Terry G\", \"Eric\",\n",
+    "               \"Terry J\", \"Michael\"\n",
+    "some_other_code = foo()\n",
+    "```\n",
+    "\n",
+    "Python < 3.10:\n",
+    "\n",
+    "```Python\n",
+    "  File \"test.py\", line 16\n",
+    "    some_other_code = foo()\n",
+    "    ^\n",
+    "SyntaxError: invalid syntax\n",
+    "```\n",
+    "\n",
+    "Python >= 3.10:\n",
+    "```Python\n",
+    "  Cell In [25], line 15\n",
+    "    the_pythons = [\"Greham\", \"John\", \"Terry G\", \"Eric\",\n",
+    "                  ^\n",
+    "SyntaxError: '[' was never closed\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 120,
+   "id": "59329225-db92-4eb6-ad1b-b88455e48d50",
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -352,45 +449,12 @@
        "True"
       ]
      },
-     "execution_count": 230,
+     "execution_count": 120,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# Parenthesized context managers are now officially allowed\n",
-    "import io\n",
-    "\n",
-    "with (\n",
-    "    io.open(\"input_file.dat\", \"rb\") as input_fp,\n",
-    "    io.open(\"output_file.dat\", \"wb\") as output_fp,\n",
-    "):\n",
-    "    data = input_fp.read()\n",
-    "    # do some processing magic on data\n",
-    "    output_fp.write(data)\n",
-    "\n",
-    "\n",
-    "# Better error messages:\n",
-    "\n",
-    "# the_pythons = [\"Greham\", \"John\", \"Terry G\", \"Eric\",\n",
-    "#                \"Terry J\", \"Michael\"\n",
-    "# some_other_code = foo()\n",
-    "\n",
-    "# Results in:\n",
-    "\n",
-    "# Python >= 3.10\n",
-    "#   Cell In [25], line 15\n",
-    "#     the_pythons = [\"Greham\", \"John\", \"Terry G\", \"Eric\",\n",
-    "#                   ^\n",
-    "# SyntaxError: '[' was never closed\n",
-    "\n",
-    "# Python < 3.10\n",
-    "#   File \"test.py\", line 16\n",
-    "#     some_other_code = foo()\n",
-    "#     ^\n",
-    "# SyntaxError: invalid syntax\n",
-    "\n",
-    "\n",
     "# PEP 634, PEP 635, PEP 636 - Structural pattern matching\n",
     "command = \"start the clock\"\n",
     "# command = input(\"Command: \")\n",
@@ -458,7 +522,7 @@
     "\n",
     "- The first reference implementation (CPython) using C11 instead of C89\n",
     "\n",
-    "- Python 3.11 is between 10-60% faster than Python 3.10. On average, we measured a 1.25x speedup on the standard benchmark suite\n",
+    "- Python 3.11 is between 10-60% faster than Python 3.10. \"On average, we measured a 1.25x speedup on the standard benchmark suite\"\n",
     "\n",
     "- **PEP 654** - Exception groups and except* - enable a program to raise and handle multiple unrelated exceptions simultaneously\n",
     "\n",
@@ -474,8 +538,83 @@
    ]
   },
   {
+   "cell_type": "markdown",
+   "id": "978a4c1e-9cc0-4117-ae8a-e85bcf9f5359",
+   "metadata": {},
+   "source": [
+    "## Faster CPython\n",
+    "\n",
+    "Many of the ideas presented are a result of the work on \"better error messages\" (Python 3.10) and \"fine-grained error locations in tracebacks\".\n",
+    "\n",
+    "\n",
+    "### Frozen imports / Static code objects\n",
+    "\n",
+    "Python caches bytecode in the `__pycache__` directory to speed up module loading.\n",
+    "\n",
+    "Selected set of core modules essential for Python startup are statically allocated  by the interpreter (\"frozen\").\n",
+    "\n",
+    "Interpreter startup is now 10-15% faster in Python 3.11. This has a big impact for short-running programs using Python.\n",
+    "\n",
+    "\n",
+    "### Cheaper / optimized lazy Python frames\n",
+    "\n",
+    "Python frames are created whenever Python calls a Python function. This frame holds execution information. The following are new frame optimizations:\n",
+    "\n",
+    "- streamlined the frame creation process.\n",
+    "\n",
+    "- avoided memory allocation by generously re-using frame space on the C stack.\n",
+    "\n",
+    "- streamlined the internal frame struct to contain only essential information. Frames previously held extra debugging and memory management information.\n",
+    "\n",
+    "3-7% speedup.\n",
+    "\n",
+    "\n",
+    "### Inlined Python function calls\n",
+    "\n",
+    "Most Python function calls now consume no C stack space. This speeds up most of such calls. In simple recursive functions like fibonacci or factorial, a 1.7x speedup was observed. This also means recursive functions can recurse significantly deeper (if the user increases the recursion limit).\n",
+    "\n",
+    "1-3% improvement in pyperformance.\n",
+    "\n",
+    "\n",
+    "### PEP 659 – Specializing Adaptive Interpreter\n",
+    "\n",
+    "Any instruction that would benefit from specialization will be replaced by an \"adaptive\" form of that instruction. When executed, the adaptive instructions will specialize themselves in response to the types and values that they see. This process is known as \"quickening\".\n",
+    "\n",
+    "Once an instruction in a code object has executed enough times, that instruction will be \"specialized\" by replacing it with a new instruction that is expected to execute faster for that operation.\n",
+    "\n",
+    "\n",
+    "#### Quickening\n",
+    "\n",
+    "Quickening is the process of replacing slow instructions with faster variants.\n",
+    "\n",
+    "Quickened code has number of advantages over immutable bytecode:\n",
+    "\n",
+    "- it can be changed at runtime\n",
+    "\n",
+    "- it can use super-instructions that span lines and take multiple operands\n",
+    "\n",
+    "- it does not need to handle tracing as it can fallback to the original bytecode for that\n",
+    "\n",
+    "In order that tracing can be supported, the quickened instruction format should match the immutable, user visible, bytecode format: 16-bit instructions of 8-bit opcode followed by 8-bit operand.\n",
+    "\n",
+    "Each instruction that would benefit from specialization is replaced by an adaptive version during quickening.\n",
+    "\n",
+    "\n",
+    "#### Compatibility\n",
+    "\n",
+    "There will be no change to the language, library or API.\n",
+    "\n",
+    "The only way that users will be able to detect the presence of the new interpreter is through timing execution, the use of debugging tools, or measuring memory use.\n",
+    "\n",
+    "\n",
+    "#### Costs\n",
+    "\n",
+    "Memory, complexity (simeons)"
+   ]
+  },
+  {
    "cell_type": "code",
-   "execution_count": 231,
+   "execution_count": 121,
    "id": "ef9285ea-2bdb-4fb0-968d-833011fe0724",
    "metadata": {},
    "outputs": [
@@ -486,8 +625,7 @@
       "KeyError detected\n",
       "TypeError detected\n",
       "KeyError detected\n",
-      "TypeError detected\n",
-      "bad type - ['Really bad types at work']\n"
+      "TypeError detected\n"
      ]
     }
    ],
@@ -515,9 +653,24 @@
     "        result = my_dict[key]\n",
     "    except* (KeyError, TypeError) as eg:\n",
     "        for e in eg.exceptions:\n",
-    "            print(f\"{type(e).__name__} detected\")\n",
-    "            \n",
-    "\n",
+    "            print(f\"{type(e).__name__} detected\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 122,
+   "id": "c70ce21d-bdf8-4a30-a5a2-c888ab75b92a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "bad type - ['Really bad types at work']\n"
+     ]
+    }
+   ],
+   "source": [
     "# PEP 678 – Enriching exceptions with notes\n",
     "# BaseException gains a new method .add_note(note: str).\n",
     "# If note is a string, .add_note(note) appends it to the __notes__ list, creating the attribute if it does not already exist.\n",
@@ -530,7 +683,7 @@
     "        e.add_note(\"Really bad types at work\")\n",
     "        raise\n",
     "except Exception as e:\n",
-    "    print(f\"{e!s} - {e.__notes__}\")\n"
+    "    print(f\"{e!s} - {e.__notes__}\")"
    ]
   },
   {
@@ -550,12 +703,22 @@
     "\n",
     "- added non parallel-safe `contextlib.chdir()` context manager to change the current working directory and then restore it on exit. Simple wrapper around `chdir()`\n",
     "\n",
-    "- added `datetime.UTC`, a convenience alias for `datetime.timezone.utc`"
+    "- added `datetime.UTC`, a convenience alias for `datetime.timezone.utc`\n",
+    "\n",
+    "- many chages and additions to the `enum` module\n",
+    "\n",
+    "- added `math.exp2(x)` (returns 2 raised to the power of x) and `math.cbrt(x)` (returns the cube root of x). `math.nan` is now always available (C11)\n",
+    "\n",
+    "- on Windows, `os.urandom()` now uses *BCryptGenRandom()*, instead of *CryptGenRandom()* which is deprecated\n",
+    "\n",
+    "- `pathlib.Path.glob()` and `pathlib.Path.rglob()` return only directories if pattern ends with a pathname components separator: `os.sep` or `os.altsep`\n",
+    "\n",
+    "- `time.sleep()` uses higher resulution 10E-6 seconds -> 10E-9 seconds (Unix), 10E-3 -> 10E-7 (Windows >= 8.1)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 232,
+   "execution_count": 123,
    "id": "f1f9977c-20f4-4bc1-9fa7-14acd0f16193",
    "metadata": {},
    "outputs": [
@@ -568,9 +731,7 @@
       "3\n",
       "3\n",
       "4\n",
-      "5\n",
-      "0.0\n",
-      "+0.0\n"
+      "5\n"
      ]
     }
    ],
@@ -582,7 +743,25 @@
     "for i in *t1, *t2:\n",
     "    print(i)\n",
     "\n",
-    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 124,
+   "id": "7260ad15-4215-4b48-b6a3-870a14d8079c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0\n",
+      "+0.0\n"
+     ]
+    }
+   ],
+   "source": [
     "# PEP 682 – Format specifier for signed zero\n",
     "# When z is present, negative zero (whether the original value or the result of rounding) will be normalized to positive zero\n",
     "import decimal\n",
@@ -591,7 +770,7 @@
     "print(f\"{x:z.1f}\")\n",
     "\n",
     "x = decimal.Decimal('-.00001')\n",
-    "print(f\"{x:+z.1f}\")\n"
+    "print(f\"{x:+z.1f}\")"
    ]
   }
  ],
diff --git a/notebooks/python/python_oo.ipynb b/notebooks/python/python_oo.ipynb
index 9f0774a..fe717a9 100644
--- a/notebooks/python/python_oo.ipynb
+++ b/notebooks/python/python_oo.ipynb
@@ -735,7 +735,7 @@
     "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",
+    "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. It is a \"is-a\" relationship between base (parent) class and a derived (child) class.\n",
     "\n",
     "One can simply view inheritance as a tool for code reuse.\n",
     "\n",
@@ -1048,7 +1048,13 @@
     "\n",
     "Not all classes admit a linearization. There are cases, in complicated hierarchies, where it is not possible to derive a class such that its linearization respects all the desired properties.  \n",
     "`TypeError: Cannot create a consistent method resolution order (MRO) for bases X, Y` is raised then.\n",
-    "\n"
+    "\n",
+    "\n",
+    "## The Liskov substitution principle (LSP):\n",
+    "\n",
+    "Functions that use references to base class objects must be able to use objects of derived classes without knowing it.\n",
+    "\n",
+    "In other words: an object (such as a class) may be replaced by a sub-object (such as a class that extends the first class) without breaking the program.\n"
    ]
   },
   {