W5: Start inheritance

Author: tomasff

week5/w5.ipynb

@@ -314,85 +314,78 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 4,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "I'm tomas, 20 years old. I'm a student\n"
-     ]
-    }
-   ],
    "source": [
-    "class Animal:\n",
-    "    SPECIES = 'Unknowm'\n",
-    "\n",
-    "class Person(Animal):\n",
-    "    SPECIES = 'Homo Sapiens'\n",
-    "\n",
-    "    def __init__(self, name, age, profession):\n",
-    "        self.name = name\n",
-    "        self.age = age\n",
-    "        self.profession = profession\n",
-    "    \n",
-    "    def describe(self):\n",
-    "        print(f\"I'm {self.name}, {self.age} years old. I'm a {self.profession}.\")\n",
-    "\n",
-    "    def __repr__(self):\n",
-    "        return f\"Person(name={self.name}, age={self.age}, profession={self.profession})\"\n",
-    "\n",
-    "tomas = Person(name=\"tomas\", age=20, profession=\"student\")\n",
-    "tomas.describe()"
+    "We can now represent a person with attributes name, age, and profession. We can introduce a person, and a person can eat."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**[INSERT diagram for class vs object]**"
+    "### Inheritance\n",
+    "People with different professions can do different tasks. For example, a doctor can treat a person and a computer scientist\n",
+    "can write code.\n",
+    "\n",
+    "We can define a `ComputerScientist` and `Doctor` class and define any profession-specific tasks for each one.\n",
+    "However, computer scientists and doctors are still people, and will also have a name, age, and profession."
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "Let's break this down.\n",
-    "\n",
-    "First, we have a `Person` class, and `tomas` is an *instance* of `Person`.\n",
-    "\n",
-    "The functions defined inside the `Person` class, namely `__init__`, `describe`, `__repr__`, are called\n",
-    "instance methods and they belong to an instance of `Person` (e.g. `tomas`).\n",
-    "\n",
-    "They can refer to other methods and attributes that belong to the same object. For example, `describe` refers to the name, age, and profession\n",
-    "of the person (an object). This is done using the parameter `self` which refers to the object which \"owns\" this method.\n",
-    "\n",
-    "You may have also noticed that some of these methods start and end with `__`.\n",
-    "These are called *magic methods* and used to defined very specific behaviours.\n",
-    "We can create an instance of `Person` by \"calling\" the class as a function, and passing any parameters required e.g.\n",
-    "\n",
-    "`Person(name=\"tomas\", age=20, profession=\"student\")`.\n",
+    "class ComputerScientist:\n",
+    "    def __init__(self, name, age, profession):\n",
+    "        self.name = name\n",
+    "        self.age = age\n",
+    "        self.profession = \"computer scientist\"\n",
     "\n",
-    "This will create our object and call `__init__` with our new object (`self`) and any other parameters.\n",
-    "`__init__` is called a constructor and it's used to initialize instances of a class. In the example above, we initialize the new `Person` object\n",
-    "with the given name, age, and profession. These are called the *instance attributes* and they are attached to an instance of the class.\n",
+    "    def introduce(self):\n",
+    "        print(f\"I'm {self.name}, {self.age} years old. I'm a {self.profession}.\")\n",
+    "    \n",
+    "    def eat(self, food):\n",
+    "        return \"\"\n",
+    "    \n",
+    "    def write_code(self):\n",
+    "        print(\"010101010000111001 code go brrrrrr\")\n",
+    "    \n",
+    "class Doctor:\n",
+    "    def __init__(self, name, age, profession):\n",
+    "        self.name = name\n",
+    "        self.age = age\n",
+    "        self.profession = \"doctor\"\n",
     "\n",
-    "For example, if we create a new instance of `Person`, the attribute `name` of this instance will be different\n",
-    "from the `name` of `tomas`.\n"
+    "    def introduce(self):\n",
+    "        print(f\"I'm {self.name}, {self.age} years old. I'm a {self.profession}.\")\n",
+    "    \n",
+    "    def eat(self, food):\n",
+    "        return \"\"\n",
+    "    \n",
+    "    def treat_person(self):\n",
+    "        print(\"Treating a person...\")"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "other_person = Person(name=\"john doe\", age=55, profession=\"epic rust programmer\")\n",
+    "Can you spot what's wrong with the above implementation?\n",
+    "We're repeating the code for the constructor, introduce and, eat. The main difference is the profession specific method!\n",
+    "What if we want to change how a person should be introduced? We'd have to update the `introduce` method in `Person`, `ComputerScientist`, `Doctor`.\n",
     "\n",
-    "print(other_person.name)\n",
-    "print(tomas.name)"
+    "We can use *inheritance* to simplify our code, improve its maintainability, reduce development costs (avoids the scenario above which could introduce bugs!),\n",
+    "and avoid repeating code."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**[INSERT diagram for class vs object]**"
    ]
   },
   {