lecture_20_classes2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes & Object Oriented Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Object-oriented programming or programming using classes is an abstraction that tries to apply the same abstraction rules used for categorizing nature to programming techniques.\n",
    "\n",
    "This has the advantage that the process for creating a computer program that should simulate a detail of nature can apply similar principles than nature seems to apply.\n",
    "Hence, the thought process for creating a simulated world in your program becomes rather similar to the thought process of understanding nature via abstraction.\n",
    "\n",
    "Let me show you by example what this abstract description means.\n",
    "\n",
    "When classifying fauna, one important class for example, are mammals. \n",
    "But how did we define what mammals are?\n",
    "We do this classification abstraction by identifying features that are similar between the different animals, and once we are sure to have found a defining feature that is only true or applicable for this one class, we can save time by just checking or using this feature for identification."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Today: Recap basic structure, nomenclature, \\_\\_call\\_\\_()\n",
    "\n",
    "Next few lectures/tutorials: applications."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A class is really just a container for related functions and values. \n",
    "\n",
    "Classes are put together in families. The point of this is to make it easier to modify and extend programs. A family of classes is known as a **class hierarchy**\n",
    "\n",
    "A class hierarchy has **parent classes** and **child classes**. Child classes can inherit data and methods from parent classes.\n",
    "\n",
    "You may also hear parent classes referred to as **super-classes** or **base-classes** and child classes referred to as **sub-classes** or **derived-classes**\n",
    "\n",
    "When people talk about **object-oriented programming** they are probably referring to programs that are class-based. Believe it or not, we have been doing object-oriented programming for a long time now because **everything in Python is an object.** This is why Python programmers typically reserve \"object-oriented\" to mean \"programming with classes.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The variable \"np\" is an object with many **attributes** such as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<ufunc 'sin'>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sin"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Arrays are also objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = np.arange(10)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Every array has many attributes, such as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.size       # size is an attribute: just a number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.5"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.mean()     # mean is an attribute: a method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Anytime you use \"dot-access\" (e.g., np.sin) the thing after the dot is an attribute. It could be a number, a function, an array, etc.\n",
    "\n",
    "An attribute could also be a **class instance.**\n",
    "\n",
    "Let's learn about classes with a simple example:  a class for straight lines.\n",
    "\n",
    "$y = mx + b$\n",
    "\n",
    "A class for parabolas will build on this.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Line:\n",
    "\n",
    "    # __init__ is a special method used to create the class.\n",
    "    # It is referred to as \"the constructor.\"\n",
    "    def __init__(self, m, b):\n",
    "        # self must be the first argument in every class method\n",
    "        # m and b are attributes of the Line class\n",
    "        self.m = m\n",
    "        self.b = b\n",
    "        \n",
    "    # The special method __call__ will allow us to call Line \n",
    "    # with the syntax of a function.\n",
    "    # It is referred to as the call operator.\n",
    "    def __call__(self, x):   \n",
    "        return self.m * x + self.b\n",
    "    \n",
    "    # A class method for tabulating results\n",
    "    def table(self, L, R, n):\n",
    "        \"\"\"\n",
    "        Return a table with n points at L <= x <= R.\n",
    "        \"\"\"\n",
    "        s = ''  # This is a string that will contain table lines\n",
    "        import numpy as np\n",
    "        for x in np.linspace(L, R, n):\n",
    "            # The self call yields self.m*x + self.b\n",
    "            y = self(x)\n",
    "            s += '%12g %12g\\n' % (x, y)\n",
    "        return s\n",
    "    \n",
    "# Note that there is more than one return statement!"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Test a single value (note the self argument is not passed when the class is called):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Line at 0x115c891d0>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test = Line(1, 5)  # This sets the slope and intercept\n",
    "test         # and creates an instance of Line"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The variable \"test\" is now **an instance of the Line class**\n",
    "\n",
    "(We have not calculated a y for a give x yet.)\n",
    "\n",
    "We can access its attributes like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 5)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.m, test.b"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "We can call it like a function too (uses __call__ method):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test(2)  # Now we calculate a y for a given x."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Note again that \"self\" is not passed as an argument.\n",
    "\n",
    "Now make a table of values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           0            5\n",
      "           1            6\n",
      "           2            7\n",
      "           3            8\n",
      "           4            9\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(test.table(0, 4, 5))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "We could create an instance of Line, and build the table in a single line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           0            5\n",
      "           1            6\n",
      "           2            7\n",
      "           3            8\n",
      "           4            9\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(Line(1, 5).table(0, 4, 5) )\n",
    "# Table is an attribute, or function, or method of class Line\n",
    "\n",
    "# Where 1 is the slope, 5 is the y-intercept,\n",
    "# 0 to 5 is the range, and there are 5 points."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A Class for Parabolas\n",
    "\n",
    "$$y = ax^2 + bx + c$$\n",
    "\n",
    "Note that a straight line is a special case of this where $a = 0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "class Parabola:\n",
    "    def __init__(self, a, b, c):\n",
    "        self.a = a\n",
    "        self.b = b\n",
    "        self.c = c\n",
    "        \n",
    "    def __call__(self, x):\n",
    "        return self.a * x**2 + self.b * x + self.c\n",
    "    \n",
    "    def table(self, L, R, n):\n",
    "        \"\"\"\n",
    "        Return a table with n points at L <= x <= R.\n",
    "        \"\"\"\n",
    "        s = ''\n",
    "        for x in np.linspace(L, R, n):\n",
    "            y = self(x)\n",
    "            s += '%12g %12g\\n' % (x, y)\n",
    "        return s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test a single value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test = Parabola(1, 1, 1)  # We've created test, an instances of Parabola.\n",
    "test1 = test(x=3)  # Here we evaluate test at x = 3\n",
    "\n",
    "# Q. What should test1 be?\n",
    "test1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. Before we do this, let's review: what are the 1, 1, 1, and x=3 values? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           0            1\n",
      "           1            3\n",
      "           2            7\n",
      "           3           13\n",
      "           4           21\n",
      "           5           31\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Make a table of values\n",
    "print(test.table(0, 5, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. What are the 0, 5, 6 values?\n",
    "\n",
    "Which is equivalent to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           0            1\n",
      "           1            3\n",
      "           2            7\n",
      "           3           13\n",
      "           4           21\n",
      "           5           31\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Q. What does the next line do?\n",
    "\n",
    "print(Parabola(1, 1, 1).table(0, 5, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A Class for Parabolas Using Inheritance \n",
    "\n",
    "We can specify that class Parabola inherits all the code (attributes:  data, functions...) from class Line by making the class statement \n",
    "\n",
    "    class Parabola(Line):\n",
    "\n",
    "Thus, class Parabola is derived from class Line. Line is a superclass or parent class, Parabola is a subclass or child class.\n",
    " \n",
    "(**Note that if we implement the constructor and call operators in Parabola, they will override the inherited versions from Line.**)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aside:  Any method in the superclass Line can be called with\n",
    "\n",
    "    super().methodname(arg1, arg2, ...) \n",
    "\n",
    "Note that **calling** a method does not require `self` as an argument, only defining them.\n",
    "Unless you call a \"class method\" instead of an \"object method\", then there's no object around to attach things to, and one needs to provide `self`. See difference shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Parabola(Line):\n",
    "    def __init__(self, a, b, c):\n",
    "        super().__init__(b, c) # Line stores b and c\n",
    "        self.a = a  # a is a\n",
    "        \n",
    "    def __call__(self, x):   \n",
    "        return Line.__call__(self, x) + self.a*x**2 \n",
    "    \n",
    "    # When Parabola is called it returns a call to Line (+ a*x**2)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Parabola(Line):\n",
    "    def __init__(self, a, b, c):\n",
    "        super().__init__(b, c) # Line stores b and c\n",
    "        self.a = a  # a is a\n",
    "        \n",
    "    def __call__(self, x):   \n",
    "        return super().__call__(x) + self.a*x**2 \n",
    "    \n",
    "    # When Parabola is called it returns a call to Line (+ a*x**2)."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Now, use it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Test a single value:\n",
    "test = Parabola(1, 2, 3)   # Q. What does this do?\n",
    "\n",
    "# And below self is test.\n",
    "test1 = test(x=2)          # Q. What does this do?\n",
    "# (Note that the x= is not needed.)\n",
    "print(test1)\n",
    "print(test.a)\n",
    "print(test.m)\n",
    "print(test.b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. How would we access b and c?  (That is, b and c are attributes of Parabola, and therefore test. How can we see what those attributes are?)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test calculates a*x**2 + b*x + c, \n",
    "# Line is a subclass of Parabola, and in Line\n",
    "# m is b and b is c. So, the argument order\n",
    "# is a, m, b.\n",
    "# (Trace it!)\n",
    "\n",
    "test.a, test.m, test.b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To compare with later in the notebook, let's have a look at all attributes. It shows also the inherited attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__call__',\n",
       " '__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'a',\n",
       " 'b',\n",
       " 'm',\n",
       " 'table']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           0            3\n",
      "           1            6\n",
      "           2           11\n",
      "           3           18\n",
      "           4           27\n",
      "           5           38\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Hierarchy!\n",
    "\n",
    "# Make a table of values:\n",
    "# test is an attribute of Line,\n",
    "# Line is a parent class or superclass of Parabola,\n",
    "# and test is an instance of Parabola.\n",
    "\n",
    "print(test.table(0, 5, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### To here -- Lecture 1."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Review:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. Which is the parent class and which is the child class?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. Can you think of any disadvantages of using inheritance?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Review -- Jargon summary:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Object-oriented programming**\n",
    " - Python programming is always object oriented, so \n",
    "this phrase really refers to class-based programming.\n",
    "\n",
    "* **Class**\n",
    " - It's the definition for an object. A collection of related data and/or methods. But not `alive` unless `instantiated`!\n",
    " \n",
    "* **Object**\n",
    " - The `instance` of a class. Instances of the same class are independent of each other.\n",
    "\n",
    "* **Attributes**\n",
    " - Data or methods that belong to objects.\n",
    "\n",
    "* **Constructor**\n",
    " - A special method that initializes a class instance.\n",
    "\n",
    "* **Inheritance**\n",
    " - Passing functionality from a parent class to a child class.\n",
    " - This is similar to importing everything from a module,\n",
    "\n",
    "i.e., \n",
    "\n",
    "    from ___ import * \n",
    "    \n",
    "so be careful! You might get more than you expect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Being Careful:  Checking occurance for instances, checking for subclasses, and checking the class type"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "An instance is an occurance (usage) of a user-defined object.\n",
    "\n",
    "The command:\n",
    "\n",
    "    isinstance(i, t)\n",
    "\n",
    "checks whether instance i is of class type t:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = Line(0, 1)\n",
    "isinstance(l, Line)\n",
    "\n",
    "# Q. What should the output be?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# MAKE SURE TO RUN ALL ABOVE CELLS FIRST!!\n",
    "\n",
    "p = Parabola(1, 2, 3)\n",
    "isinstance(p, Line)\n",
    "\n",
    "# Q. And what about this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Q. And this?\n",
    "\n",
    "isinstance(l, Parabola)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "We can also test whether classes are subclasses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is Parabola a subclass of Line?\n",
    "\n",
    "issubclass(Parabola, Line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Q. Should this be true or false?\n",
    "issubclass(Line, Parabola)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A couple of attributes of classes:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Every instance has an attribute __class__ that holds the type of class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Parabola"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This should tell us that instance p is a Parabola type of class:\n",
    "\n",
    "p.__class__"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Q. How can we tell whether the attribute __class__ is Parabola\n",
    "using Boolean logic?\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.__class__ == Parabola"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "There is also an attribute __name__ that contains the class name string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Parabola'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.__class__.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can see it's a string from the tick\n",
    "# marks, but also:\n",
    "\n",
    "type(p.__class__.__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Careful Distinction:  Attribute vs. Inheritance \n",
    "\n",
    "#### a.k.a. the infamous \"has a ...\" vs \"is a ...\" question."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# What we have done so far is make class Parabola inherit class Line\n",
    "# (by making Line an argument of Parabola in the class statement):\n",
    "\n",
    "class Parabola(Line):\n",
    "    def __init__(self, a, b, c):\n",
    "        super().__init__(b, c) # Line stores b and c\n",
    "        self.a = a  # a is a\n",
    "        \n",
    "    def __call__(self, x):   \n",
    "        # Recall equation:  a*x**2 + b*x + c\n",
    "        return super().__call__(x) + self.a*x**2 \n",
    "    \n",
    "test = Parabola(1, 2, 3)  \n",
    "test1 = test(x=2)\n",
    "test1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Q. Verifying:  Is test an instance of Parabola?\n",
    "\n",
    "isinstance(test, Parabola)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This also can be phrased as: \"A Parabola object **IS** a Line object\".\n",
    "\n",
    "A more specialized one, but nonetheless!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Q. Verifying:  Is Parabola a subclass of Line?\n",
    "\n",
    "issubclass(Parabola, Line)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "As we have been discussing, there are some disadvantages to inheritance (e.g., the appearance of attributes from the parent class can be confusing).\n",
    "\n",
    "Instead, we could make class Parabola have a class Line instance as an attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Parabola:   # Before \"class Parabola(Line):\", which\n",
    "                  # made Parabola inherit the attributes of Line.\n",
    "    \n",
    "    def __init__(self, a, b, c):   # Same as before\n",
    "        \n",
    "        self.line = Line(b, c)   # Now Line will be an attribute of Parabola\n",
    "        # Before \"Line.__init__(self, b, c)\" constructed an instance of Line\n",
    "        \n",
    "        self.a = a   # Same as before\n",
    "        self.c = c\n",
    "        self.b = b\n",
    "        \n",
    "    def __call__(self, x):   # Same as before  \n",
    "        \n",
    "        return self.line(x) + self.a*x**2 \n",
    "        # Before \"return Line.__call__(self, x) + self.a*x**2\", \n",
    "        # which returned an instance of Line evaluated at x.\n",
    "        \n",
    "# To summarize:\n",
    "# 1. We have not made Parabola a subclass of line\n",
    "# 2. Line is an attribute of Parabola "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test = Parabola(1, 2, 3)\n",
    "test1 = test(x=2)\n",
    "test1\n",
    "\n",
    "# And the result should be the same:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is this still true?\n",
    "\n",
    "isinstance(test, Parabola)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Is this still true?\n",
    "\n",
    "issubclass(Parabola, Line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, the relationship has to be phrased as \"The Parabola object **HAS** a Line object\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# So, will this work?  Why or why not?\n",
    "\n",
    "test.table(0, 5, 6)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "So, Parabola has not inherited table from Line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__call__',\n",
       " '__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__']"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# To see this, list the attributes of Parabola with dir(Parabola):\n",
    "\n",
    "dir(Parabola)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__call__',\n",
       " '__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'a',\n",
       " 'b',\n",
       " 'c',\n",
       " 'line']"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# BUT, test is an instance of Parabola and has an attribute line:\n",
    "\n",
    "dir(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__call__',\n",
       " '__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'b',\n",
       " 'm',\n",
       " 'table']"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# AND line has an attribute table:\n",
    "\n",
    "dir(test.line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           0            3\n",
      "           1            5\n",
      "           2            7\n",
      "           3            9\n",
      "           4           11\n",
      "           5           13\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Hence:\n",
    "\n",
    "print( test.line.table(0, 5, 6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__abs__',\n",
       " '__add__',\n",
       " '__and__',\n",
       " '__bool__',\n",
       " '__ceil__',\n",
       " '__class__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__divmod__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__float__',\n",
       " '__floor__',\n",
       " '__floordiv__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__index__',\n",
       " '__init__',\n",
       " '__int__',\n",
       " '__invert__',\n",
       " '__le__',\n",
       " '__lshift__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__neg__',\n",
       " '__new__',\n",
       " '__or__',\n",
       " '__pos__',\n",
       " '__pow__',\n",
       " '__radd__',\n",
       " '__rand__',\n",
       " '__rdivmod__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rfloordiv__',\n",
       " '__rlshift__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__ror__',\n",
       " '__round__',\n",
       " '__rpow__',\n",
       " '__rrshift__',\n",
       " '__rshift__',\n",
       " '__rsub__',\n",
       " '__rtruediv__',\n",
       " '__rxor__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__sub__',\n",
       " '__subclasshook__',\n",
       " '__truediv__',\n",
       " '__trunc__',\n",
       " '__xor__',\n",
       " 'bit_length',\n",
       " 'conjugate',\n",
       " 'denominator',\n",
       " 'from_bytes',\n",
       " 'imag',\n",
       " 'numerator',\n",
       " 'real',\n",
       " 'to_bytes']"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# And the attributes of test.line have attributes!\n",
    "\n",
    "dir(test.line.m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The slope of the line is m:\n",
    "\n",
    "test.line.m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Focusing on two of the attributes, \n",
    "# m is a real number:\n",
    "\n",
    "test.line.m.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# So, its imaginary component is zero:\n",
    "\n",
    "test.line.m.imag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "type(test.line.m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.imag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [stable]",
   "language": "python",
   "name": "Python [stable]"
  },
  "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.5.1"
  },
  "widgets": {
   "state": {},
   "version": "1.1.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}