notebooks/exercises/Advanced Object oriented programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Object-oriented programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebooks contains assingments that are more complex. They are aimed at students who already know about [object- oriented Programming](https://en.wikipedia.org/wiki/Object-oriented_programming) from prior experience and who are familiar with the concepts but now how OOP is done on Python.\n",
    "\n",
    "The scope of this introduction is insufficient to give a good tutorial on OOP as a whole.\n",
    "\n",
    "Our first example is an example of composition. We create a Company that consists a list of Persons and an account balance.\n",
    "\n",
    "Then after we structure our classes with desired behaviour we can use them quite freely.\n",
    "\n",
    "Create a class called Person for storing the following information about a person:\n",
    "- name\n",
    "\n",
    "Create a method say_hi that returns the string \"Hi, I'm \" + the person's name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name):\n",
    "        pass\n",
    "    \n",
    "    def say_hi(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the following code to test that you have created the person correctly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "persons = []\n",
    "joe = Person(\"Joe\")\n",
    "jane = Person(\"Jane\")\n",
    "persons.append(joe)\n",
    "persons.append(jane)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now create a class Employee that **inherits** the class Person. \n",
    "In addition to a name, Employees have a title (string), \n",
    "salary (number) and an account_balance (number).\n",
    "\n",
    "**Override** the say_hi method to say \"Hi I'm \" + name + \" and i work as a \" + title"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the reference to Person on the line below means that the object inherits \n",
    "# Employee\n",
    "class Employee(Person):\n",
    "    def __init__(self, \n",
    "                 name, \n",
    "                 salary, \n",
    "                 title=\"Software Specialist\", \n",
    "                 account_balance=0):\n",
    "        # this calls the constructor of Person class\n",
    "        super().__init__(name)\n",
    "        # you still need to implement the rest\n",
    "        pass\n",
    "        \n",
    "    def say_hi(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every employee is also a person. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "persons = []\n",
    "joe = Person(\"Joe\")\n",
    "jane = Person(\"Jane\")\n",
    "persons.append(joe)\n",
    "persons.append(jane)\n",
    "emp1 = Employee(\"Jack\", 3000)\n",
    "emp2 = Employee(\"Jill\", 3000)\n",
    "persons.append(emp1)\n",
    "persons.append(emp2)\n",
    "for person in persons:\n",
    "    print(person.say_hi())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now create a class called Company, which has a name \n",
    "and a list of Employee objects called `employees` and an \n",
    "account balance for the company.\n",
    "\n",
    "Make a method `payday(self)` that will go through \n",
    "the list of employees and deduct their salary from \n",
    "the corporate account and add it to the employee \n",
    "account. Before you start deducting money compute the sum of salaries and make sure it is higher than the account balance. If it is not, raise an instance of the NotEnoughMoneyError. \n",
    "\n",
    "Make a method `layoff(self)` that will remove\n",
    "one employe from the list of employees. If there are no more employees raise a NoMoreEmployeesException."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NotEnoughMoneyError(Exception):\n",
    "    pass\n",
    "\n",
    "class NoMoreEmployeesError(Exception):\n",
    "    pass\n",
    "\n",
    "class Company(object):\n",
    "    def __init__(self, title, employees = [], account_balance=0):\n",
    "        pass\n",
    "        \n",
    "\n",
    "    def payday(self):\n",
    "       pass\n",
    "\n",
    "    def layoff(self):\n",
    "       pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, you've worked this far just creating the model, let's put it to use.\n",
    "\n",
    "Make a method `smart_payday(company)`. The method should attempt to call the payday method of the company. If the call raises a NotEnoughMoneyException lay off a worker and then try again. Don't catch the NoMoreEmployeesException as that should be handled at a higher level.\n",
    "\n",
    "You will probably need to use a while loop to implement the re-trying until a condition is met."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def smart_payday(company):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a bit of test code\n",
    "names_and_salaries = [\n",
    "    (\"Jane\", 3000), \n",
    "    (\"Joe\", 2000),\n",
    "    (\"Jill\", 2000),\n",
    "    (\"Jack\", 1500)\n",
    "]\n",
    "\n",
    "workers = [Employee(name, salary) \\\n",
    "           for name, salary in names_and_salaries]\n",
    "scs = Company(\"SCS\", employees=workers, account_balance=12000)\n",
    "\n",
    "smart_payday(scs)\n",
    "print(scs.account_balance)\n",
    "print(len(scs.employees))\n",
    "smart_payday(scs)\n",
    "print(scs.account_balance)\n",
    "print(len(scs.employees))\n",
    "print(scs.employees)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Observe how printing the employees list is not very informative? Adding a magic method called `__repr__` will help with that."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extra: more Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following method, it will raise errors randomly. This type of failure is pretty common for IO-related tasks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class RandomException(Exception):\n",
    "    pass\n",
    "    \n",
    "\n",
    "def do_wonky_stuff():\n",
    "    import random\n",
    "    if random.random() > 0.5:\n",
    "        raise RandomException(\"this exception happened randomly\")\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wrap a call to ``do_wonky_stuff`` with a try-except clause."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "do_wonky_stuff()\n",
    "print(\"yay it worked\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK, now let's go even deeper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReallyRandomException(Exception):\n",
    "    pass\n",
    "\n",
    "def do_really_wonky_stuff():\n",
    "    import random\n",
    "    val = random.random()\n",
    "    if val > 0.75:\n",
    "        raise RandomException(\"this exception happened randomly\")\n",
    "    elif val < 0.15:\n",
    "        raise ReallyRandomException(\"This exception is actually quite rare\")\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wrap do_really_wonky_stuff in a try-except -clause with two excepts. In the rarer of the excepts print out something so you'll if it's your lucky day.\n",
    "\n",
    "In real life you'd probably want to handle different errors in a different way, or at least log or inform the user of what caused the error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "do_really_wonky_stuff()\n"
   ]
  }
 ],
 "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.4.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}