06-classes-in-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Programming Design\n",
    "\n",
    "> Classes in Python\n",
    "\n",
    "Yao-Jen Kuo <yaojenkuo@ntu.edu.tw> from [DATAINPOINT](https://www.datainpoint.com/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## So far, we've learned programming known as \"Procedural Programming\"\n",
    "\n",
    "In its simplest definition, procedural programming involves writing code in a number of sequential steps and sometimes we combine these steps into commands called functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Another practice adopted in software development is called \"Object-oriented Programming, OOP\"\n",
    "\n",
    "Rather than code being designed around sequential steps, it is instead defined around objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is an object?\n",
    "\n",
    "> In Object-oriented programming, an object is an instance of a Class. Objects are an abstraction. They hold both data, and ways to manipulate the data. The data is usually not visible outside the object. It can only be changed by using a well-specified mechanism (usually called interface).\n",
    "\n",
    "Source: <https://simple.wikipedia.org/wiki/Object_(computer_science)>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Simply put, an object is instantiated via a specific class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# the object favorite_integer is an instance of int class\n",
    "favorite_integer = 5566\n",
    "print(type(favorite_integer))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# the object favorite_tv_character is an instance of str class\n",
    "favorite_tv_character = \"Phoebe Buffay\"\n",
    "print(type(favorite_tv_character))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is a class?\n",
    "\n",
    "A class provides a set of behaviors in the form of member functions (also known as methods), with implementations that are common to all instances of that class. A class also serves as a **blueprint** for its instances, effectively determining the way that state information for each instance is represented in the form of attributes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The relationship between objects and classes\n",
    "\n",
    "- A class is like a blueprint designed by its creators.\n",
    "- An object is like the final product build by its users based on its blueprint."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Why implementing a class by ourselves?\n",
    "\n",
    "- We define our own functions if there is no appropriate built-in functions or module-powered functions\n",
    "- We implement our own classes if there is no appropriate built-in classes or module-powered classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## So far, we've been using these built-in classes\n",
    "\n",
    "- Data types\n",
    "    - `int`\n",
    "    - `float`\n",
    "    - `str`\n",
    "    - `bool`\n",
    "    - `NoneType`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## So far, we've been using these built-in classes(Cont'd)\n",
    "\n",
    "- Data Structures\n",
    "    - `list`\n",
    "    - `tuple`\n",
    "    - `dict`\n",
    "    - `set`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Simply put, implementing a class is binding specific functions and data onto an object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Defining classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Let's create a class named `SimpleCalculator` with no methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleCalculator:\n",
    "    \"\"\"\n",
    "    This class creates a simple calculator that is unable to do anything.\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.SimpleCalculator'>\n",
      "\n",
      "    This class creates a simple calculator that is unable to do anything.\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "sc = SimpleCalculator()\n",
    "print(type(sc))\n",
    "print(sc.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Defining functions inside a class makes them methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleCalculator:\n",
    "    \"\"\"\n",
    "    This class creates a simple calculator that is able to add and subtract 2 numbers.\n",
    "    \"\"\"\n",
    "    def add(self, x: int, y: int) -> int:\n",
    "        return x + y\n",
    "    def subtract(self, x: int, y: int) -> int:\n",
    "        return x - y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What does \"self\" mean in the parenthesis?\n",
    "\n",
    "![](https://media.giphy.com/media/QBcuE4Jas6MxmTWiIn/giphy.gif)\n",
    "\n",
    "Source: <https://giphy.com/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The \"self\" actually means the not yet instantiated object\n",
    "\n",
    "Think of the behavior of whom that is gonna use our class:\n",
    "\n",
    "```python\n",
    "sc = SimpleCalculator()\n",
    "sc.add('55', '66')\n",
    "sc.subtract(55, 66)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'5566'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sc = SimpleCalculator()\n",
    "sc.add('55', '66')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-11"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sc.subtract(55, 66)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## We not only bind functions to a class, but also bind data to a class\n",
    "\n",
    "Use the `__init__` methods to create attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class SimpleCalculator:\n",
    "    \"\"\"\n",
    "    This class creates a simple calculator that is able to add and subtract 2 numbers.\n",
    "    This class has an attribute of Euler's number: e.\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        self.e = 2.71828182846\n",
    "    def add(self, x: int, y: int) -> int:\n",
    "        return x + y\n",
    "    def subtract(self, x: int, y: int) -> int:\n",
    "        return x - y\n",
    "    def exp(self, n: int) -> float:\n",
    "        return self.e**n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.71828182846\n",
      "7.38905609893584\n"
     ]
    }
   ],
   "source": [
    "sc = SimpleCalculator()\n",
    "print(sc.e)\n",
    "print(sc.exp(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The object instantiated by self-defined class does not have a default print layout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.SimpleCalculator object at 0x7fbef9c29ca0>\n"
     ]
    }
   ],
   "source": [
    "print(sc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## If you want to give it a print layout, we can define the `__repr__` method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class SimpleCalculator:\n",
    "    \"\"\"\n",
    "    This class creates a simple calculator that is able to add and subtract 2 numbers.\n",
    "    This class has an attribute of Euler's number: e.\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        self.e = 2.71828182846\n",
    "    def __repr__(self):\n",
    "        return \"A Simple Calculator Class.\"\n",
    "    def add(self, x: int, y: int) -> int:\n",
    "        return x + y\n",
    "    def subtract(self, x: int, y: int) -> int:\n",
    "        return x - y\n",
    "    def exp(self, n: int) -> float:\n",
    "        return self.e**n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A Simple Calculator Class.\n"
     ]
    }
   ],
   "source": [
    "sc = SimpleCalculator()\n",
    "print(sc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The `SimpleCalculator` is a bit too simple, can we add more methods?\n",
    "\n",
    "- Of course! Let's implement a `IntermediateCalculator` class with other arithmetic operations; \n",
    "- But do we have to define the class from scratch?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Besides encapsulation, there is another powerful feature of implementing a class called \"Inheritance\"\n",
    "\n",
    "Inheritance enables new objects to take on the properties of existing objects.\n",
    "\n",
    "```python\n",
    "class ChildClass(ParentClass):\n",
    "    # sequence of statements\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "class IntermediateCalculator(SimpleCalculator):\n",
    "    \"\"\"\n",
    "    This class inherits from simple calculator does nothing.\n",
    "    \"\"\"\n",
    "    pass\n",
    "\n",
    "ic = IntermediateCalculator()\n",
    "print(\"e\" in dir(ic))\n",
    "print(\"exp\" in dir(ic))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What can we do when inheriting from a parent class?\n",
    "\n",
    "- Extending attributes or methods\n",
    "- Revising attributes or methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Extending attributes or methods\n",
    "class IntermediateCalculator(SimpleCalculator):\n",
    "    \"\"\"\n",
    "    This class inherits from simple calculator and add more methods to it.\n",
    "    \"\"\"\n",
    "    def mutiply(self, x: int, y: int) -> int:\n",
    "        return x*y\n",
    "    def divide(self, x: int, y: int) -> float:\n",
    "        return x / y\n",
    "    def power(self, x: int, y: int) -> int:\n",
    "        return x**y\n",
    "    def mod(self, x: int, y: int) -> int:\n",
    "        return x % y\n",
    "    def floor_divide(self, x: int, y: int) -> int:\n",
    "        return x // y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "sc = SimpleCalculator()\n",
    "ic = IntermediateCalculator()\n",
    "print(\"power\" in dir(sc))\n",
    "print(\"power\" in dir(ic))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Extending attributes or methods\n",
    "class IntermediateCalculator(SimpleCalculator):\n",
    "    def __init__(self):\n",
    "        SimpleCalculator.__init__(self)\n",
    "        self.pi = 3.14159265359\n",
    "\n",
    "sc = SimpleCalculator()\n",
    "ic = IntermediateCalculator()\n",
    "print(\"pi\" in dir(sc))\n",
    "print(\"pi\" in dir(ic))"
   ]
  }
 ],
 "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": 4
}