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 PS3\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": 8,
   "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": {
    "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": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Greta Thunberg 21\n"
     ]
    }
   ],
   "source": [
    "from datetime import date\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 __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()`"
   ]
  },
  {
   "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!**"
   ]
  },
  {
   "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!**\n",
    "  * `Person.get_age(p1)`"
   ]
  },
  {
   "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": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "['Tom Holland', '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",
    "    \n",
    "p1 = Person('Greta', 'Thunberg')\n",
    "p2 = Person('Tom', 'Holland')\n",
    "print(p1 < p2)\n",
    "\n",
    "lst = sorted([p1, p2])\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**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Greta'"
      ]
     },
     "execution_count": 5,
     "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": [],
   "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 __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"
   ]
  },
  {
   "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": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milena Tsvetkova 1\n",
      "Daniel de Kadt 2\n",
      "True\n",
      "True\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Person' object has no attribute 'id_num'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[6], line 28\u001b[0m\n\u001b[1;32m     26\u001b[0m \u001b[38;5;28mprint\u001b[39m(staff1 \u001b[38;5;241m<\u001b[39m staff2)\n\u001b[1;32m     27\u001b[0m \u001b[38;5;28mprint\u001b[39m(p1 \u001b[38;5;241m<\u001b[39m staff1)\n\u001b[0;32m---> 28\u001b[0m \u001b[38;5;28mprint\u001b[39m(staff1 \u001b[38;5;241m<\u001b[39m p1)\n",
      "Cell \u001b[0;32mIn[6], line 18\u001b[0m, in \u001b[0;36mLSEPerson.__lt__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;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[1;32m     17\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Returns True if self's id number is smaller than other's id number.\"\"\"\u001b[39;00m\n\u001b[0;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 other\u001b[38;5;241m.\u001b[39mid_num\n",
      "\u001b[0;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('Daniel', 'de Kadt')\n",
    "print(staff2, staff2.get_id_num())\n",
    "\n",
    "print(staff1 < staff2)\n",
    "print(p1 < staff1)\n",
    "print(staff1 < p1)"
   ]
  },
  {
   "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": 13,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Acad'>\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "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))\n",
    "print(isinstance(prof1, Staff))\n",
    "print(isinstance(prof1, Student))"
   ]
  },
  {
   "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": 14,
   "metadata": {
    "collapsed": true,
    "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": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Look at me\n",
      "Look at me too\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'InfoHiding' object has no attribute '__invisible'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-15-6e8545b30eba>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisible\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__visible__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__invisible\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'InfoHiding' object has no attribute '__invisible'"
     ]
    }
   ],
   "source": [
    "# These are for demonstration purposes only!\n",
    "# You should not access object attributes directly like this, \n",
    "# use get and set methods instead\n",
    "print(test.visible)\n",
    "print(test.__visible__)\n",
    "print(test.__invisible)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Look at me\n",
      "Do not look at me directly\n",
      "Do not look at me directly\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'InfoHiding' object has no attribute '__invisible_print_invisible'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-bbce7b1bc4db>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_invisible\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__visible_print_invisible__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mtest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__invisible_print_invisible\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'InfoHiding' object has no attribute '__invisible_print_invisible'"
     ]
    }
   ],
   "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": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'SubClass' object has no attribute '_SubClass__invisible'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-17-b223680b57bf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__invisible\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0msub_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSubClass\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-17-b223680b57bf>\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m         \u001b[0mInfoHiding\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__invisible\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0msub_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSubClass\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'SubClass' object has no attribute '_SubClass__invisible'"
     ]
    }
   ],
   "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": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "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": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "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": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<generator object Course.get_students at 0x103e08830>\n"
     ]
    }
   ],
   "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": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mappingproxy({'__dict__': <attribute '__dict__' of 'Person' objects>,\n",
       "              '__doc__': None,\n",
       "              '__init__': <function __main__.Person.__init__>,\n",
       "              '__lt__': <function __main__.Person.__lt__>,\n",
       "              '__module__': '__main__',\n",
       "              '__str__': <function __main__.Person.__str__>,\n",
       "              '__weakref__': <attribute '__weakref__' of 'Person' objects>,\n",
       "              'get_age': <function __main__.Person.get_age>,\n",
       "              'get_name': <function __main__.Person.get_name>,\n",
       "              'set_birthdate': <function __main__.Person.set_birthdate>})"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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 we are still available for regular office hours.\n",
    "* **Problem Set 3**: Due two weeks from now at 12:00 noon on Monday, November 11th"
   ]
  },
  {
   "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",
    "  2. Divide work\n",
    "  3. Write code simultaneously\n",
    "  4. Merge contributions  \n",
    "* Problem Set 3 will be done in groups of two\n",
    "* Pairs will be formed randomly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Work on Problem Set 3 in Pairs\n",
    "\n",
    "1. You will get e-mail notification from GitHub that you have been added to a team\n",
    "2. The team will give you and your partner write access to a new repo\n",
    "3. Go to GitHub and look for repo `https://github.com/lse-my470/ps-3-[team name]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What Happens Next\n",
    "\n",
    "* Each of you should clone the team repository locally\n",
    "* Open an issue to contact your partner if you prefer to communicate privately\n",
    "* Work separately on a branch and open a pull request when ready to merge\n",
    "* Merge your contributions and close any open issues before final push\n",
    "\n",
    "### We will discuss how to use GitHub for collaboration in class"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "base",
   "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.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}