labs/OO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Object-oriented programming practice quiz\n",
    "\n",
    "This quiz test your basic knowledge of object-oriented programming in Python.\n",
    "\n",
    "(The solutions do not appear if you view this file from github, so download the notebook to your laptop and view it in Jupyter. Clicking on the ▶`Solution` button opens up the solution for each question.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Terminology and semantics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is a class?\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "    A class is a user-defined type and is a template describing the fields and functions for objects of that type.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What's the difference between a class and an instance?\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "     An instance is an object of a particular type/class. A class is the template or blueprint for that collection of objects.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What is the syntax to access a field of an object?\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "    object.field\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "How does a method differ from a function?\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "    \n",
    "    A method is a function defined within a class definition. Functions are called via f(o) but methods are called via o.f(). The target object becomes the self argument of the method.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "What does the __init__ method do?\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "That method is called a constructor and is meant to initialize a fields associated with an instance of the class (an object).   These constructors accept arguments or simply set default values for fields.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Given classes Employee and Manager, which would say is the superclass in which is the subclass?\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "    A manager is a kind of employee so it makes the most sense that Employee would be the superclass and Manager would be the subclass.  The Manager class inherits fields and functionality from Employee.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Can a method in a subclass call a method defined in the superclass?\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "    Yes, if f() exists in the superclass, then a method in the subclass can simply call self.() to invoke that inherited method.  Is a special case, if we are defining function f() in the subclass and want to call the superclass f() from that method, we must use super.f() not self.f() to explicitly indicate which function to call.\n",
    "    \n",
    "The following example prints \"woof\"\n",
    "    \n",
    "    <pre>\n",
    "class Dog:\n",
    "    def speak(self):\n",
    "        print(\"woof\")\n",
    "        \n",
    "class Akita(Dog):\n",
    "    def whos_a_good_boy(self):\n",
    "        self.speak()\n",
    "\n",
    "d = Akita()\n",
    "d.whos_a_good_boy()    \n",
    "    </pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "How do you override a method inherited from your superclass?\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "    Just redefine the method in the subclass and it will override the previous functionality. This program:\n",
    "        \n",
    "    <pre>\n",
    "class Dog:\n",
    "    def speak(self):\n",
    "        print(\"woof\")\n",
    "        \n",
    "class DogCat(Dog):\n",
    "    def speak(self):\n",
    "        print(\"Meowoof!\")\n",
    "\n",
    "Dog().speak()\n",
    "DogCat().speak()\n",
    "</pre>\n",
    "    \n",
    "prints:\n",
    "    \n",
    "<pre>\n",
    "woof\n",
    "Meowoof!\n",
    "</pre>    \n",
    "    \n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Understanding and generating OO code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Define a new class Foo whose constructor takes no arguments but initializes field x to 0.\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "class Foo:\n",
    "    def __init__(self): # don't forget the \"self\"!!\n",
    "        self.x = 0 # don't forget the \"self.\"!!\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Create a class called Point who's constructor accepts x and y coordinates; the constructor should set fields using those parameters. This code\n",
    "\n",
    "```\n",
    "p = Point(9, 2)\n",
    "print(p.x, p.y)\n",
    "```\n",
    "\n",
    "should print \"9 2\".\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "For class Point, define the `__str__` methods so that points are printed out as \"(*x*,*y*)\". E.g., `print( Point(3,9) )` should print \"(3,9)\".\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>    \n",
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    def __str__(self):\n",
    "        return f\"({self.x},{self.y})\"\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Define method `distance(q)` that takes a Point and returns the Euclidean distance from self to q.  Recall that $dist(u,v) = \\sqrt{(u_1-v_1)^2 + (u_2-v_2)^2)}$. You can test your code with:\n",
    "\n",
    "```\n",
    "p = Point(3,4)\n",
    "q = Point(5,6)\n",
    "print(p.distance(q))  # prints 2.8284271247461903\n",
    "```\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "import numpy as np\n",
    "\n",
    "class Point:\n",
    "    def `__init__`(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    def distance(self, other):\n",
    "        return np.sqrt( (self.x - other.x)`**`2 + (self.y - other.y)**2 )\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Define a `Point3D` that inherits from `Point`. \n",
    "\n",
    "Define constructor that takes x,y,z values and sets fields. Call `super().__init__(x,y)` to call the constructor of superclass to set x, y.  Set z directly within the constructor for `Point3D`.\n",
    "\n",
    "Define / override `distance(q)` so it works with 3D field values to return distance.\n",
    "\n",
    "Test with\n",
    "\n",
    "```\n",
    "p = Point3D(3,4,9)\n",
    "q = Point3D(5,6,10)\n",
    "print(p.distance(q))\n",
    "```\n",
    "\n",
    "Add method `__str__` so that `print(q)` prints something nice like `(3,4,9)`.  Recall: $dist(u,v) = \\sqrt{(u_1-v_1)^2 + (u_2-v_2)^2 + (u_3-v_3)^2)}$\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "import numpy as np\n",
    "\n",
    "class Point3D(Point):\n",
    "    def `__init__`(self, x, y, z):\n",
    "        # reuse/refine super class constructor\n",
    "        super().`__init__`(x,y)\n",
    "        self.z = z        \n",
    "    def distance(self, other):\n",
    "        return np.sqrt( (self.x - other.x)**2 +\n",
    "                        (self.y - other.y)**2 +\n",
    "                        (self.z - other.z)**2 )    \n",
    "    def `__str__`(self):\n",
    "        return f\"({self.x},{self.y},{self.z})\"\n",
    "</pre>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "\n",
    "Define a class called `Rectangle` that contains two `Point` objects, one for the lower left and one for the upper right coordinates of the rectangle.  The constructor should take four coordinates, `llx`, `lly`, `urx`, `ury` and construct two `Point` fields from those called `ll` and `ur`.  Define method `area()` that returns the area of the rectangle.\n",
    "\n",
    "Hint: Given rectangle object `r`, `r.ll.x` should be the x-coordinate of the lower left `Point` of `Rectangle` `r`.\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "<pre>\n",
    "class Rectangle:\n",
    "    def __init__(self, llx, lly, urx, ury):\n",
    "        self.ll = Point(llx, lly)\n",
    "        self.ur = Point(urx, ury)\n",
    "    def area(self):\n",
    "        return (self.ur.x - self.ll.x) * (self.ur.y - self.ll.y)</pre>\n",
    "</details>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}