update Common Design Patterns

Author: rambasnet

notebooks/CommonDesignPatterns.ipynb

@@ -11,6 +11,7 @@
     "- topics:\n",
     "    - the Singleton pattern\n",
     "    - the Decorator pattern\n",
+    "    - the Iterator pattern\n",
     "    - the Observer pattern\n",
     "    - the Strategy pattern\n",
     "    - the Command pattern\n",
@@ -227,7 +228,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "0f8a6536",
    "metadata": {},
    "outputs": [],
@@ -237,7 +238,7 @@
     "from typing import List\n",
     "\n",
     "\n",
-    "class Context():\n",
+    "class Context:\n",
     "    \"\"\"\n",
     "    The Context defines the interface of interest to clients.\n",
     "    \"\"\"\n",
@@ -316,10 +317,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "51e94a76",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Client: Strategy is set to normal sorting.\n",
+      "Context: Sorting data using the strategy (not sure how it'll do it)\n",
+      "a,b,c,d,e\n",
+      "\n",
+      "Client: Strategy is set to reverse sorting.\n",
+      "Context: Sorting data using the strategy (not sure how it'll do it)\n",
+      "e,d,c,b,a\n"
+     ]
+    }
+   ],
    "source": [
     "context = Context(ConcreteStrategyA())\n",
     "print(\"Client: Strategy is set to normal sorting.\")\n",
@@ -538,7 +553,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "id": "c7e13bcd",
    "metadata": {},
    "outputs": [],
@@ -612,8 +627,6 @@
     "Concrete States implement various behaviors, associated with a state of the\n",
     "Context.\n",
     "\"\"\"\n",
-    "\n",
-    "\n",
     "class ConcreteStateA(State):\n",
     "    def handle1(self) -> None:\n",
     "        print(\"ConcreteStateA handles request1.\")\n",
@@ -939,182 +952,6 @@
     "result"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "88c5fa34",
-   "metadata": {},
-   "source": [
-    "## The Single pattern\n",
-    "\n",
-    "- also called anti-pattern \n",
-    "- more common in more strict OOP languages such as Java than in scripting languages such as Python\n",
-    "- the basic idea is to allow exactly one instance of certain objects in the program\n",
-    "\n",
-    "![Single pattern](resources/singleton_pattern.png)\n",
-    "\n",
-    "- singletons are normally enforced by making the constructor private (so no one can create additional instances of it)\n",
-    "- then providing a static method to retrieve the single instance. \n",
-    "    - this method creates a new instance the first time it is called and then returns that same instance for all subsequent calls\n",
-    "    \n",
-    "- since python doesn't have a private access specifier, we've to be a little creative\n",
-    "- can use `__new__()` method and class variable to ensure that only one instance is created"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "id": "57c525e2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class OneOnly:\n",
-    "    _singleton = None\n",
-    "    # not the use of cls instead of self to clarify the usage of _sigleton class variable\n",
-    "    def __new__(cls, *args, **kwargs):\n",
-    "        if not cls._singleton:\n",
-    "            cls._singleton = super().__new__(cls, *args, **kwargs)\n",
-    "        return cls._singleton\n",
-    "    \n",
-    "    def business_operation(self):\n",
-    "        print('perform some business opearation')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "id": "8b4c8be8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "s1 = OneOnly()\n",
-    "s2 = OneOnly()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "id": "151266d1",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 36,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "s1 == s2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "id": "fce54ad5",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 37,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "id(s1) == id(s2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "9a1107c4",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "perform some business opearation\n"
-     ]
-    }
-   ],
-   "source": [
-    "s1.business_operation()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "a3eacfbb",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<__main__.OneOnly at 0x7f9ce6a4f3d0>"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "s1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "611a4d3f",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<__main__.OneOnly at 0x7f9ce6a4f3d0>"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "s2"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "395e9fc5",
-   "metadata": {},
-   "source": [
-    "### Python singleton\n",
-    "\n",
-    "- Python provides two built-in Singleton patterns we can leverage\n",
-    "- rather than invent something hard to read, there are two choices:\n",
-    "\n",
-    "1. Python *module*:\n",
-    "    - One `import` will create a module\n",
-    "    - all other attempts to import the module return the one-and-only singleton instance of the module\n",
-    "\n",
-    "2. Python *class* definition:\n",
-    "    - a Python class can only be created once in a given namespace\n",
-    "    - consider using a class with class-level attributes as a singleton object\n",
-    "    - use `@staticmethod` decorator to not have to use instance variable `self`\n",
-    "    \n",
-    "- see https://github.com/rambasnet/Kattis-Demos-Testing/blob/main/hello/python3/OOP/main.py solution that uses single object of Main class to solve the problem\n",
-    "- see https://github.com/rambasnet/Kattis-Demos-Testing/tree/main/egypt/python3/OOP/main_singleton.py solution that uses static methods and class level variables to use a single pattern"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "e12acc78",
@@ -1142,7 +979,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "oop",
    "language": "python",
    "name": "python3"
   },
@@ -1156,7 +993,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.8"
+   "version": "3.10.9"
   }
  },
  "nbformat": 4,

notebooks/PythonObjects-Singleton.ipynb

@@ -994,8 +994,20 @@
    "id": "1f17389d",
    "metadata": {},
    "source": [
-    "## Singleton Pattern\n",
+    "## The Singleton Pattern\n",
     "\n",
+    "- also called anti-pattern \n",
+    "- more common in more strict OOP languages such as Java than in scripting languages such as Python\n",
+    "- the basic idea is to allow exactly one instance of certain objects in the program\n",
+    "\n",
+    "![Single pattern](resources/singleton_pattern.png)\n",
+    "\n",
+    "- singletons are normally enforced by making the constructor private (so no one can create additional instances of it)\n",
+    "- then providing a static method to retrieve the single instance. \n",
+    "    - this method creates a new instance the first time it is called and then returns that same instance for all subsequent calls\n",
+    "    \n",
+    "- since python doesn't have a private access specifier, we've to be a little creative\n",
+    "- can use `__new__()` method and class variable to ensure that only one instance is created\n",
     "- also called anti-pattern because there is only one instance of the class\n",
     "- use `__new__()` method to create a new instance of the class\n",
     "- `__new__()` is a class method that is called before the `__init__()` instance method\n",
@@ -1023,7 +1035,7 @@
     "        # we don't care about (a, b) so use args and kwargs within __new__\n",
     "        # not providing them will create syntax error because __init__ is defined with two arguments \n",
     "        if not cls._instance:\n",
-    "            cls._instance = super().__new__(cls)\n",
+    "            cls._instance = super().__new__(cls, *args, **kwargs)\n",
     "        return cls._instance\n",
     "\n",
     "    def __init__(self, a, b):\n",
@@ -1133,6 +1145,28 @@
     "test_singleton()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "0ffd34ad",
+   "metadata": {},
+   "source": [
+    "### Python singleton\n",
+    "\n",
+    "- Python provides two built-in Singleton patterns we can leverage\n",
+    "- rather than invent something hard to read, there are two choices:\n",
+    "\n",
+    "1. Python *module*:\n",
+    "    - One `import` will create a module\n",
+    "    - all other attempts to import the module return the one-and-only singleton instance of the module\n",
+    "\n",
+    "2. Python *class* definition:\n",
+    "    - a Python class can only be created once in a given namespace\n",
+    "    - consider using a class with class-level attributes as a singleton object\n",
+    "    - use `@staticmethod` decorator to not have to use instance variable `self`\n",
+    "    \n",
+    "- see `demo-assignments/A1-OOP` and `demo-assignments/A2-ABC` for single pattern examples"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "ce4e86ec",