wk5/MY470_wk5_lecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### MY470 Computer Programming\n",
    "# ⚙️ Classes in Python\n",
    "### Week 5 Lecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Overview\n",
    "\n",
    "* Object-oriented programming\n",
    "* Classes\n",
    "* Class inheritance and polymorphism\n",
    "* Encapsulation and information hiding\n",
    "* Generators\n",
    "* Team formation for Assignment 5\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## From Last Week: Decomposition and Abstraction\n",
    "\n",
    "* Decomposition creates structure\n",
    "* Abstraction hides detail\n",
    "\n",
    "![Decomposition and abstraction](figs/decomposition_abstraction.png \"Decomposition and abstraction\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Achieving Decomposition and Abstraction\n",
    "\n",
    "* With functions\n",
    "* With **classes**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## From Week 2: Objects\n",
    "\n",
    "### Python supports many different kinds of objects\n",
    "\n",
    "* `25`, `'LSE'`, `[1, 2, 7, 0]`, `range(10)` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### In fact, EVERYTHING in Python is an object\n",
    "\n",
    "* Objects have types (belong to classes)\n",
    "* Objects also have a set of procedures for interacting with them (methods)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "SOME STRING\n"
     ]
    }
   ],
   "source": [
    "s = 'some string'\n",
    "print(type(s))\n",
    "print(s.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Object-Oriented Programming\n",
    "\n",
    "A programming paradigm based on the concept of \"objects\"\n",
    "\n",
    "An object is a **data abstraction** that captures:\n",
    "\n",
    "* **Internal representation** (data attributes)\n",
    "* **Interface** for interacting with object (methods)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Procedural  vs. Object-Oriented Programming\n",
    "\n",
    "![Procedural vs. object-oriented programming](figs/procedural_object-oriented.png \"Procedural vs. object-oriented programming\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Object oriented programming is an abstraction that helps us to operate and manipulate data. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Abstraction\n",
    "\n",
    "![Abstraction in science](figs/science_abstraction.png \"Abstraction in science\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Data Abstraction With Classes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Greta Thunberg 19\n"
     ]
    }
   ],
   "source": [
    "from datetime import date\n",
    "\n",
    "# Capitalized names are reserved for objects (ie it's a higher class then just a variable)\n",
    "# Meanwhile full caps are reserved for global variables (even higher class than objects)\n",
    "# Within each class are methods that you can define. \n",
    "class Person(object):\n",
    "        \n",
    "    def __init__(self, f_name, l_name):\n",
    "        \"\"\"Creates a person using first and last names.\"\"\"\n",
    "        self.first_name = f_name\n",
    "        self.last_name = l_name\n",
    "        self.birthdate = None\n",
    "    # self denotes an instance, and therefore first_name is an attribute linked only to that instance\n",
    "    def get_name(self):\n",
    "        \"\"\"Gets self's full name.\"\"\"\n",
    "        return self.first_name + ' ' + self.last_name\n",
    "    \n",
    "    def get_age(self):\n",
    "        \"\"\"Gets self's age in years.\"\"\"\n",
    "        return date.today().year - self.birthdate.year\n",
    "    \n",
    "    def set_birthdate(self, dob):\n",
    "        \"\"\"Assumes dob is of type date.\n",
    "        Sets self's birthdate to dob.\n",
    "        \"\"\"\n",
    "        self.birthdate = dob\n",
    "    \n",
    "    def __str__(self):\n",
    "        \"\"\"Returns self's full name.\"\"\"\n",
    "        return self.first_name + ' ' + self.last_name\n",
    "    \n",
    "p1 = Person('Greta', 'Thunberg')\n",
    "p1.set_birthdate(date(2003, 1, 3))\n",
    "print(p1, p1.get_age())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Classes in Python\n",
    "\n",
    "* Data attributes — `first_name`, `last_name`, `birthdate`\n",
    "* Methods\n",
    "  * `get_name()`, `get_age()`, `set_birthdate()`\n",
    "  * `__init__()` — called when a class is instantiated\n",
    "  * `__str__()` — called by `print()` and `str()`\n",
    "  \n",
    "---\n",
    "\n",
    "* Operations\n",
    "  * Instantiation: `p1 = Person('Greta', 'Thunberg')` calls method `__init__()`\n",
    "  * Attribute/method reference: `p1.get_age()`\n",
    "  \n",
    "---\n",
    "\n",
    "This way we only interact with the data via an interface, and not with it directly. \n",
    "ie: saying get, or set to the interface (which then deals with the data)\n",
    "rather than indexing it, calling the row by the row number etc. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Classes vs. Objects\n",
    "\n",
    "* `Person` is a class\n",
    "* `p1` is an instance of the class `Person`; it is an object of type `Person`\n",
    "* Similarly, `str` is a class and `'Greta Thunberg'` is an object of type `str`\n",
    "\n",
    "![Class vs. object](figs/person_greta.png \"Class vs. object\")\n",
    "\n",
    "By Anders Hellberg - Own work, CC BY-SA 4.0, https://commons.wikimedia.org/w/index.php?curid=77270098\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `self`\n",
    "\n",
    "```\n",
    "def set_birthdate(self, dob):\n",
    "    self.birthdate = dob\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* Variable that references the current instance of the class\n",
    "* The name is a convention\n",
    "* It's a *strong* convention — **Do not use any other variable name!** ie always use *\"self\"*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Class Operations: Method Reference\n",
    "\n",
    "```\n",
    "def get_age(self):\n",
    "    return date.today().year - self.birthdate.year\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* Methods are functions that are associated with a class\n",
    "* Two ways to call methods:\n",
    "  * `p1.get_age()`  **— Use this one!** # this calls the one instance from the class then applies the method to it\n",
    "  * `Person.get_age(p1)` # this calls the entire class (ie all the instances) and applies the method to only one instance\n",
    "  \n",
    "Because the method functions is already linked with the class that has been defined\n",
    "so python already knows which class you are referring to. \n",
    "The first approach (p1.get_age()) is then computationally faster."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Special Methods\n",
    "\n",
    "* `__init__()` — called when a class is instantiated\n",
    "* `__str__()` — called by `print()` and `str()`\n",
    "* `__lt__()` — overloads the `<` operator\n",
    "* `__le__()` — overloads the `<=` operator\n",
    "* `__eq__()` — overloads the `==` operator\n",
    "* `__ne__()` — overloads the `!=` operator (defaults to opposite of `__eq__()`)\n",
    "* `__gt__()` — overloads the `>` operator\n",
    "* `__ge__()` — overloads the `>=` operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Overloading provides access to other methods defined using the methods above\n",
    "\n",
    "* E.g. `sort()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "['Taylor Swift', 'Greta Thunberg']\n"
     ]
    }
   ],
   "source": [
    "class Person(object):\n",
    "        \n",
    "    def __init__(self, f_name, l_name):\n",
    "        \"\"\"Creates a person using first and last names.\"\"\"\n",
    "        self.first_name = f_name\n",
    "        self.last_name = l_name\n",
    "        self.birthdate = None\n",
    "    \n",
    "    def get_name(self):\n",
    "        \"\"\"Gets self's full name.\"\"\"\n",
    "        return self.first_name + ' ' + self.last_name\n",
    "    \n",
    "    def get_age(self):\n",
    "        \"\"\"Gets self's age in years.\"\"\"\n",
    "        return date.today().year - self.birthdate.year\n",
    "    \n",
    "    def set_birthdate(self, dob):\n",
    "        \"\"\"Assumes dob is of type date.\n",
    "        Sets self's birthdate to dob.\n",
    "        \"\"\"\n",
    "        self.birthdate = dob\n",
    "    \n",
    "    def __str__(self):\n",
    "        \"\"\"Returns self's full name.\"\"\"\n",
    "        return self.get_name()\n",
    "    \n",
    "    def __lt__(self, other):\n",
    "        \"\"\"Returns True if self's last name precedes other's last name\n",
    "        in alphabethical order. If they are equal, compares first names.\n",
    "        \"\"\"\n",
    "        if self.last_name == other.last_name:\n",
    "            return self.first_name < other.first_name\n",
    "        return self.last_name < other.last_name\n",
    "    # this overwrites the lessthan function within the Person class. \n",
    "    # it does not overwrite the lessthan function in the mainframe or other functions\n",
    "    \n",
    "p1 = Person('Greta', 'Thunberg')\n",
    "p2 = Person('Taylor', 'Swift')\n",
    "print(p1 < p2)\n",
    "# ie compares if T(hunberg) comes before S(wift)\n",
    "\n",
    "lst = sorted([p1, p2]) # sorted(etcetc) would only show you where that data is kept.\n",
    "print([str(i) for i in lst])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Class Operations: Attribute Reference\n",
    "\n",
    "```\n",
    "def __init__(self, f_name, l_name):\n",
    "    self.first_name = f_name\n",
    "    self.last_name = l_name\n",
    "    self.birthdate = None\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### In Python, you have direct access to instance attributes but you shouldn't use it\n",
    "\n",
    "  * `p1.first_name`  **<— DO NOT EVER USE THIS ONE!** \n",
    "  * `p1.get_name()`  **<— Use this one instead**\n",
    "  \n",
    "To access the attribute, use the method. Do not call on the attribute itself. Again, the whole point of object-oriented programming is to interact with the data via methods and not with the data itself.\n",
    "So you don't have to learn how the data is structured, or how it's called etc. In this way, it standardizes the method with which you can use to interact and store the data, so no matter how the data looks, you can still interact with it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Greta'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1.get_name().split()[0]  # Or write a new method get_first_name()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Using methods to get instance attributes is essential for encapsulation and information hiding — two important goals of object-oriented programming."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Classes: Exercise\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'activist'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Update the class below to include the attribute occupation.\n",
    "# Then write a get method and a set method for occupation.\n",
    "\n",
    "class Person(object):\n",
    "        \n",
    "    def __init__(self, f_name, l_name):\n",
    "        \"\"\"Creates a person using first and last names.\"\"\"\n",
    "        self.first_name = f_name\n",
    "        self.last_name = l_name\n",
    "        self.birthdate = None\n",
    "    \n",
    "    def get_name(self):\n",
    "        \"\"\"Gets self's full name.\"\"\"\n",
    "        return self.first_name + ' ' + self.last_name\n",
    "    \n",
    "    def get_age(self):\n",
    "        \"\"\"Gets self's age in years.\"\"\"\n",
    "        return date.today().year - self.birthdate.year\n",
    "    \n",
    "    def set_birthdate(self, dob):\n",
    "        \"\"\"Assumes dob is of type date.\n",
    "        Sets self's birthdate to dob.\n",
    "        \"\"\"\n",
    "        self.birthdate = dob\n",
    "    \n",
    "    def set_occupation(self, occupation):\n",
    "        \"\"\" Sets self's occupation \"\"\"\n",
    "        self.occupation = occupation\n",
    "        \n",
    "    def get_occupation(self):\n",
    "        \"\"\" Gets self's occupation \"\"\"\n",
    "        return self.occupation\n",
    "    \n",
    "    def __str__(self):\n",
    "        \"\"\"Returns self's full name.\"\"\"\n",
    "        return self.get_name()\n",
    "    \n",
    "    def __lt__(self, other):\n",
    "        \"\"\"Returns True if self's last name precedes other's last name\n",
    "        in alphabethical order. If they are equal, compares first names.\n",
    "        \"\"\"\n",
    "        if self.last_name == other.last_name:\n",
    "            return self.first_name < other.first_name\n",
    "        return self.last_name < other.last_name\n",
    "    \n",
    "p1 = Person('Greta', 'Thunberg')\n",
    "p1.set_occupation('activist')\n",
    "p1.get_occupation()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Inheritance\n",
    "\n",
    "> **Q:** *What's the object-oriented way to become wealthy?*\n",
    "\n",
    "> **A:** *Inheritance.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Inheritance\n",
    "\n",
    "* Allows to build hierarchies of related abstractions\n",
    "* **Subclasses** inherit data attributes and methods from their **superclasses** (classes that are higher in the hierarchy)\n",
    "* On top of the hierarchy is class `object`\n",
    "* Subclasses can:\n",
    "  * Add new data attributes and methods\n",
    "  * Override data attributes and methods of the superclass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Subclasses "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milena Tsvetkova 1\n",
      "Ken Benoit 2\n",
      "True\n",
      "True\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Person' object has no attribute 'id_num'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Input \u001b[1;32mIn [4]\u001b[0m, in \u001b[0;36m<cell line: 28>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     26\u001b[0m \u001b[38;5;28mprint\u001b[39m(staff1 \u001b[38;5;241m<\u001b[39m staff2) \u001b[38;5;66;03m# we have overwritten what less than means for this subclass to compare id num rather than name.\u001b[39;00m\n\u001b[0;32m     27\u001b[0m \u001b[38;5;28mprint\u001b[39m(p1 \u001b[38;5;241m<\u001b[39m staff1) \u001b[38;5;66;03m# python reads left to right and will use the less than definition for Person in this comparison.\u001b[39;00m\n\u001b[1;32m---> 28\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mstaff1\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m<\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mp1\u001b[49m)\n",
      "Input \u001b[1;32mIn [4]\u001b[0m, in \u001b[0;36mLSEPerson.__lt__\u001b[1;34m(self, other)\u001b[0m\n\u001b[0;32m     16\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__lt__\u001b[39m(\u001b[38;5;28mself\u001b[39m, other):\n\u001b[0;32m     17\u001b[0m     \u001b[38;5;124;03m\"\"\"Returns True if self's id number is smaller than other's id number.\"\"\"\u001b[39;00m\n\u001b[1;32m---> 18\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mid_num \u001b[38;5;241m<\u001b[39m \u001b[43mother\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mid_num\u001b[49m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'Person' object has no attribute 'id_num'"
     ]
    }
   ],
   "source": [
    "class LSEPerson(Person):\n",
    "    \n",
    "    # This is a class variable\n",
    "    next_id_num = 1 # unique identifiication number\n",
    "        \n",
    "    def __init__(self, f_name, l_name):\n",
    "        \"\"\"Creates an LSE person using first and last names.\"\"\"\n",
    "        Person.__init__(self, f_name, l_name)\n",
    "        self.id_num = LSEPerson.next_id_num\n",
    "        LSEPerson.next_id_num += 1\n",
    "    \n",
    "    def get_id_num(self):\n",
    "        \"\"\"Gets self's unique LSE number.\"\"\"\n",
    "        return self.id_num\n",
    "    \n",
    "    def __lt__(self, other):\n",
    "        \"\"\"Returns True if self's id number is smaller than other's id number.\"\"\"\n",
    "        return self.id_num < other.id_num\n",
    "\n",
    "staff1 = LSEPerson('Milena', 'Tsvetkova')\n",
    "print(staff1, staff1.get_id_num())\n",
    "\n",
    "staff2 = LSEPerson('Ken', 'Benoit')\n",
    "print(staff2, staff2.get_id_num())\n",
    "\n",
    "print(staff1 < staff2) # we have overwritten what less than means for this subclass to compare id num rather than name.\n",
    "print(p1 < staff1) # python reads left to right and will use the less than definition for Person in this comparison.\n",
    "print(staff1 < p1) # python uses the less than definition of LSEPerson, but p1 does not have id.num, so it doesnt work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Polymorphism\n",
    "\n",
    "* An expression can do different things depending on the objects it applies to\n",
    "* Enabled by overriding inherited methods\n",
    "* Helps reduce code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Inheritance Hierarchies "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Acad'>\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Acad' object has no attribute 'occupation'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Input \u001b[1;32mIn [7]\u001b[0m, in \u001b[0;36m<cell line: 26>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     24\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(prof1, Student))\n\u001b[0;32m     25\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(prof1, LSEPerson))\n\u001b[1;32m---> 26\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mprof1\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_occupation\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m)\n",
      "Input \u001b[1;32mIn [1]\u001b[0m, in \u001b[0;36mPerson.get_occupation\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m     30\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_occupation\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m     31\u001b[0m     \u001b[38;5;124;03m\"\"\" Gets self's occupation \"\"\"\u001b[39;00m\n\u001b[1;32m---> 32\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moccupation\u001b[49m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'Acad' object has no attribute 'occupation'"
     ]
    }
   ],
   "source": [
    "class Staff(LSEPerson):\n",
    "    pass\n",
    "\n",
    "class Admin(Staff):\n",
    "    pass\n",
    "\n",
    "class Acad(Staff):\n",
    "    pass\n",
    "\n",
    "class Student(LSEPerson):\n",
    "    pass\n",
    "\n",
    "class Undergrad(Student):\n",
    "    pass\n",
    "\n",
    "class Grad(Student):\n",
    "    pass\n",
    "    \n",
    "prof1 = Acad('Angelina', 'Jolie')\n",
    "\n",
    "print(type(prof1))\n",
    "print(isinstance(prof1, Acad)) # gives T/F if the instance is a (sub)class\n",
    "print(isinstance(prof1, Staff))\n",
    "print(isinstance(prof1, Student))\n",
    "print(isinstance(prof1, LSEPerson)) # obviously if she is a staff, which is a subclass of LSEperson, this returns True. \n",
    "print(prof1.get_occupation()) # no occupation because she's an acad."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Inheritance: Exercise\n",
    "\n",
    "Edit the relevant code in this notebook to add properties `department` and `salary`, as well as the associated `get()` and `set()` methods, to describe all relevant classes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Encapsulation and Information Hiding\n",
    "\n",
    "![Encapsulation and infromation hiding](figs/encapsulation.png \"Encapsulation and infromation hiding\")\n",
    "\n",
    "### Encapsulation\n",
    "\n",
    "* The bundling of data attributes and the methods for operating on them\n",
    "\n",
    "### Information hiding\n",
    "\n",
    "* Allows changing the class definition without affecting its external behavior\n",
    "\n",
    "### Encapsulation and information hiding keep class attributes and methods safe from outside interference and misuse.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Information Hiding in Python\n",
    "\n",
    "* Use naming conventions to make data attributes and methods invisible outside the class\n",
    "* Convention: Begin name with `__` but do not end with it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class InfoHiding(object):\n",
    "    def __init__(self):\n",
    "        self.visible = 'Look at me'\n",
    "        self.__visible__ = 'Look at me too'\n",
    "        self.__invisible = 'Do not look at me directly'\n",
    "        \n",
    "    def print_visible(self):\n",
    "        print(self.visible)\n",
    "    \n",
    "    def print_invisible(self):\n",
    "        print(self.__invisible)\n",
    "        \n",
    "    def __invisible_print_invisible(self):\n",
    "        print(self.__invisible)\n",
    "        \n",
    "    def __visible_print_invisible__(self):\n",
    "        print(self.__invisible)\n",
    "\n",
    "test = InfoHiding()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Information Hiding in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "print(test.visible)\n",
    "print(test.__visible__)\n",
    "print(test.__invisible)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "test.print_visible()\n",
    "test.print_invisible()\n",
    "test.__visible_print_invisible__()\n",
    "test.__invisible_print_invisible()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Information Hiding and Subclasses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class SubClass(InfoHiding):\n",
    "    def __init__(self):\n",
    "        InfoHiding.__init__(self)\n",
    "        print(self.__invisible)\n",
    "\n",
    "sub_test = SubClass()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## In Practice, Information Hiding Convention in Python Is Rarely Used \n",
    "\n",
    "* Without it users may rely on attributes that are not necessarily part of the specification of the class\n",
    "* Without it users may also change these attributes in undesirable ways"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Course(object):\n",
    "    \n",
    "    def __init__(self, student_list):\n",
    "        self.students = student_list\n",
    "        self.grades = {}\n",
    "    \n",
    "course1 = Course([1, 2, 3])\n",
    "course2 = Course([4, 5, 6])\n",
    "\n",
    "all_students = course1.students\n",
    "all_students.extend(course2.students)\n",
    "\n",
    "print(course1.students)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## In Practice, Information Hiding in Python Requires Discipline!\n",
    "\n",
    "* Do not directly access data attributes from outside the class in which they are defined\n",
    "* Return copies of mutable objects rather than the objects themselves"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ⚡️ Speed Considerations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Course(object):\n",
    "    \n",
    "    def __init__(self, student_list):\n",
    "        self.students = student_list\n",
    "        self.grades = {}\n",
    "    \n",
    "    def get_students(self):\n",
    "        return self.students[:] # Creates a copy of a list already in memory\n",
    "    \n",
    "    def add_grade(self, student, grade):\n",
    "        self.grades[student] = grade\n",
    "    \n",
    "course1 = Course([i for i in range(1, 11)])\n",
    "for i in course1.get_students():\n",
    "    course1.add_grade(i, 100)\n",
    "    \n",
    "print(course1.get_students()) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ⚡️ Generators with `yield`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Course(object):\n",
    "    \n",
    "    def __init__(self, student_list):\n",
    "        self.students = student_list\n",
    "        self.grades = {}\n",
    "    \n",
    "    def get_students(self):\n",
    "        for i in self.students:\n",
    "            yield i\n",
    "    \n",
    "    def add_grade(self, student, grade):\n",
    "        self.grades[student] = grade\n",
    "    \n",
    "course1 = Course([i for i in range(1, 11)])\n",
    "for i in course1.get_students():\n",
    "    course1.add_grade(i, 100)\n",
    "    \n",
    "print(course1.get_students())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## When to Use Classes\n",
    "\n",
    "* Methods require look-up so are a bit slower than functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "Person.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Designing classes properly can be quite time-consuming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* In general, data scientists are less likely to implement classes\n",
    "* However, most modules and packages that data scientists use make heavy use of object-oriented programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* **If you are building a reusable and extendable code to share with others and/or release publicly, use classes!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Classes in Python\n",
    "\n",
    "* Reusable abstractions\n",
    "* Reduce development time for large projects\n",
    "* Allow to maintain and update programs without disruptions for users\n",
    "* Help produce more reliable programs\n",
    "* Essential for developing user applications"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "-------\n",
    "\n",
    "* **Lab**: Collaborative programming\n",
    "* **Week 6**: No lecture or class! But I am still available for regular office hours.\n",
    "* **Assignment 5**: Due at 12:00 noon on Monday, November 9th"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Collaborative Programming\n",
    "\n",
    "* Most programming is collaborative\n",
    "* Functions and classes allow us to:\n",
    "  1. Design programs\n",
    "  * Divide work\n",
    "  * Write code simultaneously\n",
    "  * Merge contributions  \n",
    "* The next two weekly assignments will be done in groups of two\n",
    "* Pairs will be formed randomly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Work on Assignment 5 in Pairs\n",
    "\n",
    "1. You will get e-mail notification from GitHub that you have been added to a team\n",
    "* The team will give you and your partner write access to a new repo\n",
    "* Go to your GitHub account and look for a repo called `lse-my470/assignment-5-[team name]`\n",
    "* Open an issue to contact your partner"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What Happens Next\n",
    "\n",
    "* Each of you should clone the team repository locally\n",
    "* Coordinate how to divide the labor\n",
    "* Work separately but use GitHub to open issues and pull requests\n",
    "* Merge your contributions\n",
    "\n",
    "### We will discuss how to use GitHub for collaboration in class"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}