12 Object-oriented design.ipynb

{
  "cells": [
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Introduction\n\nObject-oriented programming and design is an approach that is based around 'objects'. \nYou have already been working\nregularly with objects such as lists, tuples, dictionaries, and NumPy arrays.\n\nThe topic of object-oriented programming is a whole lecture course on its own, so in this notebook \nwe will focus on:\n\n- Classes\n- Attributes of objects\n- Class methods\n\nWe will do this primarily by example. We will not delve into inheritance and polymorphism.\n\nPython supports the object-oriented programming paradigm; in fact, everything in Python is an object.\nYou have been using concepts from object-oriented computing throughout this course.\n\n\n## Objectives\n\n- Appreciate objects as instantiations of classes\n- Understanding of attributes and methods of classes\n- Learn to create simple classes\n- Implement and use class methods"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We will be using NumPy, so we import it here:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "import numpy as np",
      "execution_count": 1,
      "outputs": []
    },
    {
      "metadata": {
        "collapsed": true
      },
      "cell_type": "markdown",
      "source": "# Example: Numpy array objects\n\nConsider a NumPy array:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "A = np.array([[1, -4, 7], [2, 6, -1]])\nprint(A)",
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[[ 1 -4  7]\n [ 2  6 -1]]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We already know how to check the type of an object:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(type(A))",
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": "<class 'numpy.ndarray'>\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "This says that `A` is an *instantiation* of the class `numpy.ndarray`. You can read this as '`A` is a `numpy.ndarray`'.\n\nSo what is a `numpy.ndarray`? It is a class that has *attributes* and *member functions*."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Attributes\n\nAttributes are *data* that belong to an object. The array `A` has a number of attributes. An attribute we have seen already is `shape`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "s = A.shape\nprint(s)",
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": "(2, 3)\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Every object of type `numpy.ndarray` has the attribute `shape` which describes the number of entries in the array in each direction. Other attributes are `size`, which is the total number of entries:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "s = A.size\nprint(s)",
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": "6\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "and `ndim`, which is the number of array dimensions (i.e. 1 for a vector, 2 for a matrix): "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "d = A.ndim\nprint(d)",
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": "2\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Notice that after an attribute name there are no braces, i.e. no `()`. This is a feature of attributes - we are\njust accessing some data that belongs to an object. We are not calling a function or doing any computational work."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Methods\n\nMethods are *functions* that are associated with a class, and perform operations on the data associated with an instantiation of a class. A `numpy.ndarray` object has a method '`min`', which returns the minimum entry in \nthe array:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(A.min())",
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": "-4\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Methods are functions, and as functions can take arguments. For example, we can use the method `sort` to sort the rows of an array: "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "A.sort(kind='quicksort')\nprint(A)",
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[[-4  1  7]\n [-1  2  6]]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "where we have called the `sort` method that belongs to `numpy.ndarray`, and we have passed an argument that specifies that it should use quicksort."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Object methods can take other objects as arguments. Given a two-dimensional array (matrix) $A$ and\na one-dimensional array (vector) $x$:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "A = np.array([[1, -4, 7], [2, 6, -1]])\n\nx = np.ones(A.shape[1])\nprint(x)",
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[1. 1. 1.]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can compute $b = Ax$ using the `dot` method:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "b = A.dot(x)\nprint(b)",
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[4. 7.]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Finding class attributes and methods\n\nClass attributes and methods are usually listed in documentation. For `numpy.ndarray`, all attributes and methods are listed and explained at http://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html.\n\nUsing Jupyter (or IPython) you can use 'tab-completion' to see the available attributes and methods. You will often know from the name which one you need."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Creating classes\n\nSometimes we cannot find a class (object type) that suits our problem. In this case we can make our own.\nAs a simple example, consider a class that holds a person's surname and forename:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "class PersonName:\n    def __init__(self, surname, forename):\n        self.surname = surname  # Attribute\n        self.forename = forename  # Attribute\n        \n    # This is a method\n    def full_name(self):\n        \"Return full name (forename surname)\"\n        return self.forename + \" \" + self.surname\n\n    # This is a method\n    def surname_forename(self, sep=\",\"):\n        \"Return 'surname, forename', with option to specify separator\"\n        return self.surname + sep + \" \" + self.forename",
      "execution_count": 11,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Before dissecting the syntax of this class, we will use it. \nWe first create an object (an instantiation) of type `PersonName`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "name_entry = PersonName(\"Bloggs\", \"Joanna\")\nprint(type(name_entry))",
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": "<class '__main__.PersonName'>\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We first test the attributes:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(name_entry.surname)\nprint(name_entry.forename)",
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Bloggs\nJoanna\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Next, we test the class methods:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "name = name_entry.full_name()\nprint(name)\n\nname = name_entry.surname_forename()\nprint(name)\n\nname = name_entry.surname_forename(\";\")\nprint(name)",
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Joanna Bloggs\nBloggs, Joanna\nBloggs; Joanna\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Dissecting the class, it is declared by\n```python\nclass PersonName:\n```\nWe then have what is known as the *intialiser*:\n```python\n    def __init__(self, surname, forename):\n        self.surname = surname\n        self.forename = forename\n```\nThis is the 'function' that is called when we create an object, i.e. when we use `name_entry = PersonName(\"Bloggs\", \"Joanna\")`. The keyword '`self`' refers to the object itself - it can take time to \ndevelop an understanding of `self`. The initialiser in this case stores the surname and forename of the person (attributes). You can test when the initialiser is called by inserting a print statement.\n\nThis class has two methods:\n```python\n    def full_name(self):\n        \"Return full name (forname surname)\"\n        return self.forename + \" \" + self.surname\n\n    def surname_forename(self, sep=\",\"):\n        \"Return 'surname, forname', with option to specify separator\"\n        return self.surname + sep + \" \" + self.forename\n```\nThese methods are functions that do something with the class data. In this case, from the forename and surname\nthey return the full name of the person, formatted in different ways."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Operators\n\nOperators like `+`, `-`, `*` and `/` are actually functions - in Python they are shorthand for functions with \nthe names `__add__`, `__sub__`, `__mul__` and `__truediv__`, respectively. By\nadding these methods to a class, we can define what the mathematical operators should do."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Mixed-up maths\n\nSay we want to create our own numbers with their own operations. As a simple (and very silly) example, \nwe decide we want to change notation such that '`*`' means division and '`/`' means multiplication.\n\nTo switch '`*`' and '`/`' for our special numbers, we create a class to represent our special numbers, and\nprovide it with its own `__mul__` and `__truediv__` functions.\nWe will also provide the method `__repr__(self)` - this is called when we use the `print` function. "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "class crazynumber:\n    \"A crazy number class that switches the mutliplcation and division operations\"\n    \n    # Initialiser\n    def __init__(self, x):\n        self.x = x  # This is an attribute\n\n    # Define multiplication (*) (this is a method)\n    def __mul__(self, y):\n        return crazynumber(self.x/y.x)\n\n    # Define the division (/) (this is a method)\n    def __truediv__(self, y):\n        return crazynumber(self.x*y.x)\n    \n    # This is called when we use 'print' (this is a method)\n    def __repr__(self):\n        return str(self.x)  # Convert type to a string and return",
      "execution_count": 15,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "> *Note:* the method names `__mul__`, ` __truediv__`, `__repr__`, etc, should not be called directly. They \n> are mapped by Python to operators (`*` and `/` in the first two cases). The method `__repr__` is called behind the scenes when using `print`.\n\nWe now create two `crazynumber` objects:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "u = crazynumber(10)\nv = crazynumber(2)",
      "execution_count": 16,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Since we have defined `*` to be division, we expect u\\*v to be equal to 5:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "a = u*v  # This will call '__mul__(self, y)'\nprint(a)  # This will call '__repr__(self)'",
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": "5.0\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Testing '`/`':"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "b = u/v\nprint(b)",
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": "20\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "By providing methods, we have defined how the mathematical operators should be interpreted."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Equality testing\n\nWe have previously used library versions of sorting functions, and seen that they are much faster than our own implementations. What if we have a list of our own objects that we want to sort? For example,\nwe might have a `StudentEntry` class, and then have a list with a `StudentEntry` object for each student.\nThe built-in sort functions cannot know how we want to sort our list.\n\nAnother case is if we have a list of numbers, and we we want to sort according to a custom rule?\n\nThe built-in sort functions do not care about the details of our data. All they rely on\nare *comparisons*, e.g. the `<`, `>`, and `==` operators. If we equip our class with comparison operators,\nwe can use built-in sorting functions."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Custom sorting\n\nSay we want to sort a list of numbers such that all even numbers appear before odd numbers, but otherwise the usual ordering rule applies. We do not want to write our own sorting function. We can do this custom sorting by creating our own class for holding a number and equipping it with `<`, `>`, and `==` operators.\nThe functions corresponding to the operators are:\n\n- `__lt__(self, other)` (less than `other`, `<`)\n- `__gt__(self, other)` (greater than `other`, `>`)\n- `__eq__(self, other)` (equal to `other`, `==`)\n\nThe functions return `True` or `False`."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Below is a class for storing a number which obeys our custom ordering rules:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "class MyNumber:\n\n    def __init__(self, x):\n        self.x = x  # Store value (attribute)\n        \n    # Custom '<' operator (method)\n    def __lt__(self, other):\n        if self.x % 2 == 0 and other.x % 2 != 0:  # I am even, other is odd, so I am less than                   \n            return True\n        elif self.x % 2 != 0 and other.x % 2 == 0:  # I am odd, other is even, so I am not less than \n            return False\n        else:\n            return self.x < other.x  # Use usual ordering of numbers\n\n    # Custom '==' operator (method)\n    def __eq__(self, other):\n        return self.x == other.x\n\n    # Custom '>' operator (method)\n    def __gt__(self, other):\n        if self.x % 2 == 0 and other.x % 2 != 0:  # I am even, other is odd, so I am not greater                    \n            return False\n        elif self.x % 2 != 0 and other.x % 2 == 0:  # I am odd, other is even, so I am greater                    \n            return True\n        else:\n            return self.x > other.x  # Use usual ordering of numbers\n\n    # This function is called by Python when we try to print something   \n    def __repr__(self):\n        return str(self.x)",
      "execution_count": 19,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can perform some simple tests on the operators (insert print statements into the methods if you want\nto verify which function is called)"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = MyNumber(4)\ny = MyNumber(3)\nprint(x < y)  # Expect True (since x is even and y is odd)\nprint(y < x)  # Expect False",
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": "True\nFalse\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We now try applying the built-in list sort function to check that the sorted list obeys our \ncustom sorting rule:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Create an array of random integers\nx = np.random.randint(0, 200, 10)\n\n# Create a list of 'MyNumber' from x (using list comprehension)\ny = [MyNumber(v) for v in x]\n\n# This is the long-hand for building y\n#y = []\n#for v in x:\n#    y.append(MyNumber(v))\n\n# Use the built-in list sort method to sort the list of 'MyNumber' objects\ny.sort()\nprint(y)",
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[6, 16, 34, 76, 92, 126, 142, 188, 147, 153]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Without modifying the sort algorithm, we have applied our own ordering. Approaches like this are a feature of \nobject-oriented computing. The sort algorithms sort *objects*, and the objects simply need\nthe comparison operators. The sort algorithms do not need to know the details of the objects."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Using the magic methods\n\nThe special Python methods that begin and end with double underscore (`__`) are *magic* methods. They map to special operators, typically mathematical operators such as `*`, `/`, `<`, `==`, etc.\n\nThey are standard methods in that they can be called directly on an object, but this is not their intended use.\nUse operators instead. Below is an example."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "class SomePair:\n    def __init__(self, x, y):\n        self.x = x  # Store value (attribute)\n        self.y = y  # Store value (attribute)\n\n    # '==' operator (note that it has a return value)\n    def __eq__(self, other):\n        return self.x == other.x and self.y == other.y\n    \na = SomePair(23, 2)\nb = SomePair(23, 4)\n\n# Check for equality using ==\nprint(a == b)\n\n# Check for equality using __eq__ (not recommended)\nprint(a.__eq__(b))",
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": "False\nFalse\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "An object does not need to have all the magic functions defined - just the ones you intend to use. If you try to use\nand operator that is not defined you will get an error."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Exercises\n\nComplete now the [12 Exercises](Exercises/12%20Exercises.ipynb) notebook."
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "name": "python",
      "file_extension": ".py",
      "version": "3.5.4",
      "pygments_lexer": "ipython3",
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 1
}