Jupyter/M02-Python/M02E-POP-OOP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Cloud-First](../image/CloudFirst.png) \n",
    "\n",
    "\n",
    "# SIT742: Modern Data Science \n",
    "\n",
    "**(Module: Python Foundations for Big Data)**\n",
    "\n",
    "---\n",
    "- Materials in this module include resources collected from various open-source online repositories.\n",
    "- You are free to use, change and distribute this package.\n",
    "- If you found any issue/bug for this document, please submit an issue at [tulip-lab/sit742](https://github.com/tulip-lab/sit742/issues)\n",
    "\n",
    "\n",
    "Prepared by **SIT742 Teaching Team**\n",
    "\n",
    "--- \n",
    "\n",
    "\n",
    "## Session 2E: Function, Class and Object\n",
    "\n",
    "\n",
    "Functions  are reusable pieces of programs. They allow you to give a \n",
    "name to a block of statements, allowing you to run that block using \n",
    "the specified name anywhere in your program and any number of times. \n",
    "We have already used many built-in functions such as **range()**, \n",
    "**type()**. In the first part of this prac,  we will look closely at  how to define and use your own function, and how to use the functions in Python modules. This modules  come with Python as part of its standard library. \n",
    "\n",
    "\n",
    "\n",
    "When designing  programs around functions, we call this **procedure-oriented programming**. Another way of organizing your program is to combine data and functionality and wrap it inside something called an **object**. This is called the **object-oriented programming** paradigm. In the second part of this prac, you will see how to use\n",
    " Object-Oriented(OO) features provided by Python to  develop programs that are better suited to OO method. \n",
    " \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Content\n",
    "\n",
    "1. [Function](#cell_function)\n",
    "\n",
    "2. [Module](#cell_module)\n",
    "\n",
    "3. [Class and Object](#cell_class)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"cell_function\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Function##\n",
    "\n",
    "\n",
    "### Definition and use###\n",
    "\n",
    "While we can use the functions that come with Python, it is also possible \n",
    "to add new functions. A *function  definition* includes two parts:\n",
    "\n",
    "1.  a *header*, which begins with a keyword **def**, followed by a pair of parentheses which may enclose some names of variables, and by the final colon that ends the line. \n",
    "\n",
    "2. a *body* consisting of one or more Python statements. All the statements in the block has same indentation - 4 spaces is the python standard - from the header.\n",
    "\n",
    "Here we define a simple function. The function definition looks like this: "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "def say_hello():\n",
    "\tprint('Hello world!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the keyword **def** is followed by function name **say\\_hello**. The empty parentheses indicate that it has no parameters. Its body only contains one single statement, which print a text **Hello world**.\n",
    "\n",
    "After defining a function, we need to *call*  a function to make it run. Since the **say\\_hello** function have an empty parameter list, the function calls do not take any arguments. Notice, however, that the parentheses are still required in the *function call*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def say_hello():\n",
    "    print('Hello world!')\n",
    "\n",
    "say_hello()\n",
    "say_hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we wanted to repeat this text for three times, we could simply call function **say\\_hello()** one more time. Or we could  write a new function **hello\\_threetimes()**:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "def hello_threetimes():\n",
    "    say_hello()\n",
    "    say_hello()\n",
    "    say_hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we put the above code fragments  together with the previous, we can  call the function Hello_threetimes() afterwards to check the result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def say_hello():\n",
    "    print('Hello world!')\n",
    "\n",
    "def hello_threetimes():\n",
    "    say_hello()\n",
    "    say_hello()\n",
    "    say_hello()\n",
    "\n",
    "hello_threetimes()\n",
    "print('Done!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How this works:\n",
    "\n",
    "\n",
    "1. This program contains two function definitions: \n",
    " \t**say\\_hello()**, **hello\\_threetimes()** the statements\n",
    " \tinside the function do not get executed until the function is called. \n",
    " \t\n",
    "2. You can call the same function repeatedly, and also have one \n",
    " \tfunction call another. In this case, **hello\\_threetimes** \n",
    " \tcalls **say\\_hello**. \n",
    " \t\n",
    "3. The first function contains one statement, and the second three \n",
    " \tstatements. All the statement inside the functions are indented by four \n",
    " \tspaces. Since the  next statement is not indented, Python knows that it \n",
    " \tis not part of the functions\n",
    " \t\n",
    "4. You have to create a function before you can execute it, which\n",
    " \t means the function has to be defined before the first time it is called. \n",
    " \t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parameters and arguments###\n",
    "\n",
    "Most functions require arguments, values that control how the function does \n",
    "its job. For example, Python has a built-in function for computing the absolute value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(-5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the arguments of **abs** function are **5** and **-5**. \n",
    "\n",
    "We can use expression as arguments as well. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 30\n",
    "b = 55\n",
    "abs(a-b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some functions take more than one arguments. For example, the built-in \n",
    "function **pow** takes two arguments: the base and the exponent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pow(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pow(7, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inside the function, the variables that are get assigned to the values  \n",
    "are called *parameters*. \n",
    "\n",
    "Here is an example of a user-defined function that has one parameter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_twice(param):\n",
    "    print(param + ' ' + param)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function takes a single *argument* and assigns it to the \n",
    "*parameter* named **param**. \n",
    "\n",
    "To test the function,  we call this function as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_twice('Hi')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_twice('Hi' * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with built-in functions, we can use an \n",
    "expression **'Hi' * 3** as an argument for **print\\_twice**.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables and parameters are local###\n",
    "When you create a local variable inside a function, it only exists \n",
    "inside the function, and you can not use it outside. In this case, we say the **scope** of the variable\n",
    "is within the function. For example, \n",
    "if we run the following code, we will get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cat_twice(part1, part2):\n",
    "    cat = part1 + part2\n",
    "    print(cat)\n",
    "    print(cat)\n",
    "\n",
    "str1 = 'Good'\n",
    "str2 = 'Morning'\n",
    "cat_twice(str1, str2)\n",
    "print(cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens:\n",
    "- The function **cat\\_twice** takes two arguments, concatenates \n",
    "them, and then prints the result twice.\n",
    "\n",
    "- After defining the function, we call the function with **str1**\n",
    " and **str2**, and then try to print variable **cat**. However,\n",
    "  when **cat\\_twice** terminates, **cat** is destroyed. If we \n",
    "  try to print it, we get an error. \n",
    "\n",
    "- Parameter are also local.  If we try to use **part1** and **part2** outside of function **cat\\_twice**, Python will \n",
    "complain as well.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Return values ###\n",
    "\n",
    "\n",
    "A lot of  built-in functions, such as **abs()**, **max()**, have \n",
    "produced results. Calling each of these functions generates a value, which \n",
    "can be assign to a variable or used in an expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bigger = max(3,5)\n",
    "bigger"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = abs(3 - 11) + 10\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also write our own functions that return values. Here is an example  \n",
    "**area**, which returns the area of a circle with the given **radius**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def area(radius):\n",
    "    temp = 3.14159 * radius ** 2\n",
    "    return temp\n",
    "\n",
    "print(area(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **return** statement means: Return immediate from this function \n",
    "and use the following expression as a return value. For above example, we \n",
    "can also use an expression as return value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def area(radius):\n",
    "    return 3.14159 * radius ** 2\n",
    "\n",
    "print(area(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the flow of execution can not reach a statement if it  \n",
    " appears after a **return** statement. This kind of code is called\n",
    "  *dead code*.\n",
    "\n",
    "A Python function returns a special value **None** whenever they do not\n",
    " return another value. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def absolute_value(x):\n",
    "    if x < 0:\n",
    "        return -x\n",
    "    elif x > 0:\n",
    "        return x\n",
    "\n",
    "print(absolute_value(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Note that if **x** equals to 0, neither condition is true, and the \n",
    " function ends without hitting a **return** statement. In this case, \n",
    " the return value is **None**. \n",
    " \n",
    " **None** is the unique value of a type called the **NoneType**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Docstrings###\n",
    "\n",
    "*Docstring* is an important tool that you should make use of, \n",
    "since it helps to document the program better and makes it easier to \n",
    "understand.\n",
    "The following example   add **docstring** to the **cat\\_twice** function.\n",
    "You can   save the script  as **cat\\_twice.py**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cat_twice(part1, part2):\n",
    "    \"\"\" Concatenates part1 and part 2, and \n",
    "    prints the result twice.\n",
    "    \"\"\"\n",
    "    cat = part1 + part2\n",
    "    print(cat)\n",
    "    print(cat) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This docstring is a triple-quoted string. The docstring contain the essential \n",
    "information for using the function. It explains what the function does, and what\n",
    "effect each parameter has on the behavior of the function. Note that docsting \n",
    "also applies to modules and classes.\n",
    "\n",
    "If you have used **help()** in Python, then you have already seen the usage \n",
    "of deocstings! What it does is just fetch the docstring of that function and display \n",
    "it for you. \n",
    "\n",
    "Try the following command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(cat_twice)     # function name used as an argument in  help() function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Writing this kind of documentation is an important part of program development. \n",
    "If you are having a hard time explaining one of your functions, that might be \n",
    "a sign that the design of your function could be improved."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<a id = \"cell_module\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Module\n",
    "\n",
    " \n",
    " \n",
    "### Math module\n",
    "\n",
    "A *module* is a file that contains a collection of related functions.  \n",
    "The **math** module  in Python  provides most of the familiar mathematical \n",
    "functions.  As can be seen in Prac 7,  with **csv** module, we have to import \n",
    "the module before we can use it. \n",
    "\n",
    "\t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **import** statement creates a module object named **math**. The\n",
    " module object contains the functions and variables defined in the module. To \n",
    " access one of the functions, you have to specify the name of the module and \n",
    " the name of the function, separated by a dot. \n",
    "\n",
    "Try the following function in the **math** module under interactive mode:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.pi      # Variable pi from the module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\t>>> math.floor(3.4) \n",
    "\t            # Return the largest integer value less than or equal to 3.4\n",
    "\t>>> math.floor(-3.4)\n",
    "\t>>> math.sqrt(5)   # Return the square root of 5 \n",
    "\t>>> math.pow(2,4)  # Return 2 raised to the power 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For information on other  functions defined in the **math** module,  \n",
    "type **help(math)** under interactive mode. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import with \"from\"\n",
    "Python provides two ways to import modules, we have already seen one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "print(math.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you try to access **pi** directly, you get an error. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, you can import an object like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can access **pi** directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or you can use the following statement to import *everything*\n",
    "from the module. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import *\n",
    "cos(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The advantage of importing everything from the math module is that your \n",
    "code can be more concise. The disadvantage is that there might be \n",
    "conflicts between names defined in different modules, or between a \n",
    "name from a module and one of your variable. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"cell_class\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Class and object \n",
    "\n",
    "In this section, we will start by introducing how to define and use a class.  We will then look at the difference between class and object variables, and finally discuss one of the most important concepts in OO programming, **inheritance**. \n",
    "\n",
    "\n",
    "Class and objects are two main aspects of OO programming. A **class** creates a new type, whereas **objects** are *instances* of the class.  Object can store data using ordinary variables that *belong* to the object. Variables that belong to an object or class are referred to as *attributes*.  Objects can also have functionality that is bound to it by defining functions that belong to a class. Such functions are called **methods** of the class. It is important to differentiate between functions and variables which are independent and those which belong to a class or object. \n",
    "\n",
    "A class is created using the **class** keyword. The attributes and methods of the class are listed in an indented block. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 Classes\n",
    "The simplest class possible is shown in the following example. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    pass    # An empty block\n",
    "\n",
    "p = Person()\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How it works:\n",
    "\n",
    "1.  We create a new class using the **class** statement. Then an indented block of statements is used to form the body of the class. Note the **pass** statement indicates an empty block in this case. \n",
    "2.  We then create an object of this class using the name of \n",
    "the class followed by a pair of parentheses. We check the type of the variable by simply printing it. The message tells us that we have an instance of the **Person** class. \n",
    "3.  Note that the address of the computer memory where the object is stored is also printed. The address will have a different value on your computer. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2  Methods\n",
    "\n",
    "Classes/objects can have **methods** just like functions. \n",
    "The difference is that the definition of method is indented and included in the class definition. \n",
    "In addition, all the class methods have an extra **self** variable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def say_hi(self):\n",
    "        print('Hi, how are you doing?')\n",
    "\n",
    "p = Person()\n",
    "p.say_hi()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How it works:\n",
    "\n",
    "As mentioned, class method have one specific difference from ordinary functions. \n",
    "They must have a parameter **self** as first item in the parameter list. \n",
    "When you call the method, however, you do not give a value for this parameter. \n",
    "Instead, Python will provide it. \n",
    "\n",
    "If you have a class **MyClass** and its object called **myobject**. \n",
    "When you call a method  **myobject.method(arg1, arg2)**, \n",
    "it is automatically converted by *Python* into **MyClass.method(myobject, arg1, arg2)**. \n",
    "This is all the special **self** is about. \n",
    "\n",
    "\n",
    "There are many methods that have special significance in Python classes. \n",
    "The **init** method is run as soon as an object of a class is instantiated. You can add any initialization for the class object  to this method. Notice the double underscores both at the beginning and at the end of the name. \n",
    "\n",
    "The following example demonstrates **init** method of the **Person** class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    def say_hi(self):\n",
    "        print('Hi, ' + self.name + ', how are you doing?')\n",
    "\n",
    "p = Person(\"James Bond\")\n",
    "p.say_hi()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How it works:\n",
    "1. We define the **init** method and pass a parameter name along with the usual self. In the method, a new attribute **name** is created. Notice that the dotted notion **self.name** means this variable is part of an object, while the other **name** is a local variable. By using dotted notation, there is no confusion between the two variables. \n",
    "2. We do not need to explicitly call the init method. Instead, the arguments is passed following the class name when creating a new instance of the class. This is the special significance of this method. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"cell_variable\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3. Class and Object variables\n",
    "\n",
    "\n",
    "We have discussed about the class method, i.e. functionality part of classes and objects. Now let us look at the data part. \n",
    "The data part, i.e. attributes, are just ordinary variables that are only valid within the context of these classes and objects only.\n",
    "\n",
    "There are two types of attributes - **class variables** and **object variables** which are classified by  whether the class or the object owns the variables respectively. \n",
    "\n",
    "Class variables are shared, and can be accessed by *all instances of that class*. \n",
    "When anyone object makes a change to a class variable, the change will be seen by all the other instances. \n",
    "\n",
    "Object variables are owned by *each individual instance* of the class. Each object has its own copy of the attribute. The following example  demonstrates the difference between class variable and object variable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Robot:\n",
    "    \"\"\"Represents a robot, with a name.\"\"\"\n",
    "    # A class variable, counting the number of robots\n",
    "    population = 0\n",
    "\n",
    "    def __init__(self, name):\n",
    "        \"\"\"Initializes the data.\"\"\"\n",
    "        self.name = name\n",
    "        print(\"(Initializing %s)\" % (self.name))\n",
    "        # When this person is created, the robot\n",
    "        # adds to the population\n",
    "        Robot.population += 1\n",
    "\n",
    "    def die(self):\n",
    "        \"\"\"I am dying.\"\"\"\n",
    "        print(\"%s is being destroyed!\" % self.name)\n",
    "        Robot.population -= 1\n",
    "        if Robot.population == 0:\n",
    "            print(\"%s was the last one.\" % self.name)\n",
    "        else:\n",
    "            print(\"There are still %d robots working.\" % Robot.population)\n",
    "\n",
    "    def say_hi(self):\n",
    "        \"\"\"Greeting by the robot.\n",
    "        Yeah, they can do that.\"\"\"\n",
    "        print(\"Greetings, my masters call me %s\" % self.name)\n",
    "\n",
    "    @classmethod\n",
    "    def how_many(cls):\n",
    "        \"\"\"Prints the current population.\"\"\"\n",
    "        print(\"We have %d robots.\" % cls.population)\n",
    "\n",
    "droid1 = Robot(\"R2-D2\")\n",
    "droid1.say_hi()\n",
    "Robot.how_many()\n",
    "droid2 = Robot(\"C-3PO\")\n",
    "droid2.say_hi()\n",
    "Robot.how_many()\n",
    "\n",
    "print(\"\\nRobots can do some work here.\\n\")\n",
    "print(\"Robots have finished their work. So let's destroy them.\")\n",
    "droid1.die()\n",
    "droid2.die()\n",
    "Robot.how_many()\n",
    "print(Robot.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How it works:\n",
    "\n",
    "1.  **population** belongs to the **Robot** class and hence is a class variable. Therefore, we refer to the **population** variable as **Robot.population**. \n",
    "\n",
    "2.  The **name** variable belongs to the **Robot** class and hence is a class variable. As a result, we refer to variable **name** as **self.name** in the methods of the object. \n",
    "\n",
    "3.  The **how_many** is a method that belongs to the class instead of to the object. We define it as *classmethod*. We use a decorator **@classmethod** to mark the **how_many** method as a class method. In the **die** method, we simply decrease the **Robot.population** count by 1.\n",
    "\n",
    "4.  The value of **self.name** is specific to each object which indicates the nature object variables. \n",
    "\n",
    "5.  We also see the use of *docstring* for classes as well as methods. We can access the class **docstring** at runtime using **Robot.\\_\\_doc\\_\\_** and the method *docstring* as **Robot.say_hi. \\_\\_doc\\_\\_**\n",
    "\n",
    "\n",
    "\n",
    "      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"cell_inheritance\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4. Inheritance\n",
    "\n",
    "*Inheritance* helps reuse of code, and is one of the most important features of object oriented programming. Inheritance can be best imagined as implementing a type and subtype relationship between classes. \n",
    "\n",
    "Suppose you need to write a program to keep track of the information of the teachers and students. They have some common characteristics such as name and age, while also have specific characteristics such as salary for teachers, and marks for students. \n",
    "\n",
    "Instead of creating two independent classes for each type, a better way is to create a common class call **SchoolMember**, \n",
    "and then have the **Teacher** and **Student** classes inherit from this class. \n",
    "There are many advantages to this approach. \n",
    "If we add/change any functionality in **SchoolMember**, \n",
    "this is automatically reflected in the subtypes. \n",
    "However, changes in the subtypes do not affect other subtypes. \n",
    "\n",
    "Another advantage is that we   can refer to a **Teacher** \n",
    "or **Student** object as a **SchoolMember** object. \n",
    "This is called *polymorphism* where a sub-type can\n",
    "be substituted in any situation where a parent type is expected,\n",
    "i.e. the object can be\n",
    "treated as an instance of the parent class. \n",
    "\n",
    "With inheritance, we can reuse the code of the parent class and do not need to repeat it in the different class. The **SchoolMember** class in this situation is called the *base class* or *super class*. The **Teacher** and **Student** classes are called the *subclasses*. \n",
    "\n",
    "This example shows how to define and use superclass and subclass.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SchoolMember:\n",
    "    '''Represents any school member.'''\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        print('(Initialized SchoolMember: %s)' % self.name)\n",
    "\n",
    "    def tell(self):\n",
    "        '''Tell my details.'''\n",
    "        print('Name: %s Age: %d' % (self.name, self.age))\n",
    "        \n",
    "class Teacher(SchoolMember):\n",
    "    '''Represents a teacher.'''\n",
    "    def __init__(self, name, age, salary):\n",
    "        SchoolMember.__init__(self, name, age)\n",
    "        self.salary = salary\n",
    "        print('(Initialized Teacher: %s)' % self.name)\n",
    "\n",
    "    def tell(self):\n",
    "        SchoolMember.tell(self)\n",
    "        print('Salary:  %d ' % self.salary)\n",
    "class Student(SchoolMember):\n",
    "    '''Represents a student.'''\n",
    "    def __init__(self, name, age, marks):\n",
    "        SchoolMember.__init__(self, name, age)\n",
    "        self.marks = marks\n",
    "        print('(Initialized Student: %s)' % self.name)\n",
    "\n",
    "    def tell(self):\n",
    "        SchoolMember.tell(self)\n",
    "        print('Marks: %d' % self.marks)\n",
    "        \n",
    "t = Teacher('Dr. Zhu', 35, 50000)\n",
    "s = Student('John Smith', 22, 75)\n",
    "# prints a blank line\n",
    "print('\\n')\n",
    "members = [t, s]\n",
    "for member in members:\n",
    "    # Works for both Teachers and Students\n",
    "    member.tell()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How it works:\n",
    "\n",
    "1. To use inheritance, we specify the base class name in the tuple following the class name in the definition,  e.g. **def Teacher(SchoolMember)**. \n",
    "We also need to explicitly call the  **init** method of based class  in the **init** method of subclass. \n",
    "Note that *Python* does not automatically call the constructor of the base class. \n",
    "2. When we use the **tell** method of the **SchoolMember** class, \n",
    "we can treat instances of **Teacher** or **Student** as instances of the **SchoolMember**. \n",
    "3. When the **tell** method of **Teacher** class is called. \n",
    "Python actually starts to look for methods in the actual type, i.e. **Teacher** class. If it could not find the method, it then looks at the methods belonging to its base class, \n",
    "i.e. **SchoolMember** class.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"cell_task\"></a>"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}