Week 06 - Classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 06 - Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Drill"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "When a user uses `readlines()` to fetch the text lines from a `.txt` file, what is the data type returned?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "source": [
    "String `str` type. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "Write a code that will find out which person has the highest score. The data are given below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wendy has the highest mark of 25.\n"
     ]
    }
   ],
   "source": [
    "# Solution\n",
    "with open('files/score.txt') as f: \n",
    "    data = f.readlines()\n",
    "for i in range(len(data)): \n",
    "    data[i] = data[i].rstrip()\n",
    "    data[i] = data[i].split('\\t')\n",
    "for i in range(len(data)):    # Convert scores into integer\n",
    "    for j in range(len(data[i])):\n",
    "        data[i][1] = int(data[i][1])\n",
    "        \n",
    "highest_mark = data[0][1]\n",
    "highest = data[0][0]\n",
    "for i in range(len(data)): \n",
    "    for j in range(len(data[i])): \n",
    "        if data[i][1] > highest_mark: \n",
    "            highest_mark = data[i][1]\n",
    "            highest = data[i][0]\n",
    "print('{} has the highest mark of {}.'.format(highest, highest_mark))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class of Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Class is a concept in object oriented programming, which represents the groups of objects. Examples of objects could be \n",
    "* students (of a class)\n",
    "* apple (of the many fruits)\n",
    "* orange (of the many fruits)\n",
    "\n",
    "Our main goal in object oriented programming is to simulate their behaviour and compute complex results from this. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The main syntax of a class in Python is \n",
    "```python\n",
    "class Agent: \n",
    "    def _init__(self): \n",
    "        self.id = 0\n",
    "```\n",
    "These are the main features from above: \n",
    "* A class starts with the reserved keyword `class` then the name of the class. \n",
    "* By convention, the first letter of the class name is capitalised. \n",
    "* A method called `__init__()` to create an object. This is called a **constructor**. \n",
    "    * The constructor starts with the first parameter called `self`. \n",
    "    * `self` represents the object itself. \n",
    "    * Can be other names, but `self` is by convention. \n",
    "* `self.id` is the `id` of the person. This is an __attribute__ of the person. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So in this class we will be simulating a __voting system__. So in this case, we need to create 2 classes: \n",
    "* People\n",
    "* Voting\n",
    "\n",
    "Let's start with the class of people. First, we should think about what are the attributes of each person. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ Brainstorm 5 attributes of a person. With 2 attributes that will contribute to the voting system. \n",
    "\n",
    "After that, write a constructor for the class `People`. The constructor is ready for you. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class People: \n",
    "    def __init__(self, name, age): \n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.opinion = 0\n",
    "        # Write your code below\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Later, we will add more attributes. However, all attributes must be included in the original constructor above. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A class itself represents the concept. For example, the `class` of people represents the features of a person. In programming, we do not manipulate the class in the main code. Rather, we play around with the people. \n",
    "\n",
    "Since we have created the `class` People, we need to create a person to use later. This is by \n",
    "* creating a variable\n",
    "* create a class object and assign to it\n",
    "\n",
    "An example would this \n",
    "```python\n",
    "person01 = People('Sally', 12)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write the code that will create a person named `'Tom'` and he is $12$ years old. Make sure if you have other parameters, fill them as well. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "person_2 = People('Tom', 12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your code below \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write the code that will create a person named `'Robert'` and he is  $16$  years old. Make sure if you have other parameters, fill them as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "person_3 = People('Robert', 16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your code below \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write a code that will print a person's name. The object is given to you. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "person_4 = People('Ra', 27)\n",
    "print(person_4.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "person_4 = People('Ra', 27)\n",
    "# Your code below"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Everything is a Object Oriented"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From week 1, we talked about data types. Can we do this with the objects we have created above? Yes, we can. In fact, you will see that the type of each person are `People`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Try yourself\n",
    "type(person_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact everything, including integers and floats are objects in Python. They have their attributes and that is why they can by computed. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exericse:__ Think about what attributes define integers or floats? You can extend this to Booleans (i.e. they are part of the class of integers in Python). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "In previous weeks, we have looked into functions. Functions are templates to automate the program. When a function is inside the class, we call them __methods__. For example, people can vote and this is a method inside the class of `People`. In the `Vote` class, it can do many things to help the voting process. For example, \n",
    "* start voting period\n",
    "* count how many votes\n",
    "* close voting\n",
    "* find out who has not been voted\n",
    "\n",
    "In the following, let us create some of these methods. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "The first one is to let everyone vote. So we need to create a method in `People` called `vote()`. To do so, we need to make sure each person has an attribute called `self.voted` to represent whether they have voted or not. You will need to go back to the cell when the class `People` located and write \n",
    "```python \n",
    "self.voted = 0\n",
    "```\n",
    "in the constructor. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "So now, we can create the method. After the constructor (still within the class `People`), write \n",
    "```python \n",
    "def vote()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "At the end we will need to change the person to be voted, which we rely on the `return` keyword. This means the method becomes \n",
    "```python\n",
    "def vote(): \n",
    "    self.voted = 1\n",
    "    return self.voted\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "This means the person who interacts with the method will reveal they have voted. To use it, we write \n",
    "```python\n",
    "person_2.vote()\n",
    "```\n",
    "This means the person has voted, but not others if never using this method. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "__Exercise:__ Write a method called `can_vote()` under the class `People`. It will check if anyone is at age of $18$ or above in the list of people in the class `Vote`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "def can_vote(self): \n",
    "    for i in range(len(self.people)): \n",
    "        if self.people[i].age >= 18: \n",
    "            self.people_can_vote.append(self.people[i])   # Remmeber to add self.people_can_vote into Vote"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def can_vote(self): \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write a method called `vote()`  under the class `People`. It will allow people to express their opinions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "from random import randint\n",
    "def vote(self): \n",
    "    for i in range(len(self.people_can_vote)): \n",
    "        self.people_can_vote[i].opinion = randint(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "def vote(self): \n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Methods and Static Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most of the time we are writing methods that affects each instances. These are called __instance methods__. Often we would like to see how the collective behaviour works among instances and the class itself. So there is a concept of __class methods__ and __static methods__. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us use an example. \n",
    "```python\n",
    "count = 0\n",
    "\n",
    "@classmethod\n",
    "def get_count(cls): \n",
    "    People.count += 1\n",
    "        return People.count\n",
    "```\n",
    "In the example, once the `get_count` method is called, it will look at all the objects in the class `People` and count their instances. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create a class method, make sure you have a declarator right before each class methods. A declarator starts with a `@` symbol. In the following, we could declare a static method with `@staticmethod`. An example would be\n",
    "```python\n",
    "@staticmethod\n",
    "def is_human(): \n",
    "    return True\n",
    "```\n",
    "As you can see, a static method does not need any parameters. It means that this function does not need any information about the class, nor the instances. For example, given we know many human traits, a static method could be print today's date. Dates are irrelevant to the people nor the voting process. It will help to decide when is the voting date, but this is not a pre-requisite knowledge in order the voting process to work. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Getter and Setter Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "When we write a method, like the following\n",
    "```python\n",
    "def foo(self): \n",
    "    self.id = 1\n",
    "```\n",
    "We will actually change the `id` of the object. This might not happen in other languages but Python, since Python does not set variables as private. However, this could indesirable when someone accidentally change the information of the objects. \n",
    "\n",
    "Python variables are able to become private by including an underscore before the variable name. For example we use \n",
    "```python\n",
    "def __init__(self): \n",
    "    self.__id = 1\n",
    "```\n",
    "in our `People` class. So when we print the variable, it will raise an attribute error. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we can't print the variable in this way, what can we do? This is where the __getter__ and __setter__ methods come in. The getter method is where we read the variable name. For example, instead of calling the `id` we can write a getter method `get_id()` \n",
    "```python\n",
    "def get_id(self): \n",
    "    return self__id\n",
    "```\n",
    "\n",
    "If we need to change the values for one of the `id`, we could write a setter method such as \n",
    "```python\n",
    "def set_id(self): \n",
    "    self.__id = 2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods using Other Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can mix the objects from both classes together. To do this, we can either: \n",
    "* initiate the objects from the other class. \n",
    "* include a variable called `other` to represent the objects from the other class, or simply another object from the same class.\n",
    "\n",
    "For example, \n",
    "```python\n",
    "def some_method(self,other): \n",
    "    return self.id + other.id\n",
    "```\n",
    "will result in the `id` of $2$ agents added together. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write a class called `magic_numbers` and this class has only $1$ attribute called `n`. It is a random integer (`random.randint` may help you). Furthermore write a method called `add()` that will add both objects from the class `magic_numbers`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "from random import randint\n",
    "class Magic_numbers: \n",
    "    def __init__(self): \n",
    "        self.n = randint(0,1)\n",
    "    \n",
    "    def add(self,other):\n",
    "        return self.n+other.n\n",
    "\n",
    "n1 = Magic_numbers()\n",
    "print(n1)\n",
    "\n",
    "n2 = Magic_numbers()\n",
    "print(n2)\n",
    "\n",
    "print(Magic_numbers.add(n1,n2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write a method called `set_people()` under the class `Vote`. The prople objects are created under this method. It will then append the list of people objects created and include in the `people` attribute of `Vote` class. \n",
    "\n",
    "Write your code under the `Vote` class, not below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "from random import randint\n",
    "N = 100          # Population\n",
    "def set_people(self): \n",
    "    for i in range(N): \n",
    "        self.people.append(People('', randint(1,100)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "N = 100          # Population\n",
    "def set_people(self): \n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Subclass (Optional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Subclass (or _inheritance_) means there are some objects have extra attributes than another one. For example, `Candidates` are humans, but they have extra attributes make them as candidates. To write a subclass, we write with normal syntax and add the class that is inherited from in a braket afterwards. For example, \n",
    "```python\n",
    "class Candidate(People): \n",
    "```\n",
    "means the class `Candidate` is inherited from the class of `People`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ Brainstorm 3 attributes that a candidate has which is unique to all other people. Also think about a method that a candidate can use. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your code below\n",
    "class Candidate(People): \n",
    "    def __init__(self): \n",
    "        super(Candidate,self).__init__()\n",
    "        pass  # Replace this with your methods\n",
    "    \n",
    "    def some_methods(self):  # Replace this\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ The `id` attribute comes from the class `People`, what is the `id` of a candidate? Is there any or not? Test this by creating a candidate and print its `id`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inheritance is often used in object-oriented programming. Especially when sometimes the machine learning packages share some attributes together. It is however, from the users point of view it is hard to see and often we could miss out this mechanism. \n",
    "\n",
    "Before finish, inheritance is different to the case when we have the classes `People` and `Vote` combined together. Their attributes does not share but rather the objects entangled together. This means when thinking about constructing a software, it is important to think about what system are you trying to model. A class diagram would help, but it is out of scope this time (see further reading). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "In today, we have looked at: \n",
    "* Classes and objects\n",
    "* Methods\n",
    "* Write classes and objects into Json format\n",
    "* Subclass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further Reading\n",
    "\n",
    "* The code of tweepy steam listener comes from [https://tweepy.readthedocs.io/en/latest/streaming_how_to.html](https://tweepy.readthedocs.io/en/latest/streaming_how_to.html)\n",
    "* Class diagram [https://medium.com/@smagid_allThings/uml-class-diagrams-tutorial-step-by-step-520fd83b300b](https://medium.com/@smagid_allThings/uml-class-diagrams-tutorial-step-by-step-520fd83b300b)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": true,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}