hw11.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# CIS024C - Summer 2018\n",
    "\n",
    "## Homework 11\n",
    "\n",
    "Homework 11 covers object oriented programming in Python\n",
    "\n",
    "The below sites have some interesting and useful information on working with files\n",
    "\n",
    "https://drive.google.com/open?id=1OrcpXEmhvgcJxSlchIBsvmXST0lG_uKx\n",
    "http://www.tutorialspoint.com/python/python_classes_objects.htm\n",
    "\n",
    "You will need to download this notebook and use this as a starting point for your homework. You will just need to fill in the content of each code-block (cell) and execute. Once you have completed all the exercises, you will need to save and upload this to your github repository under a folder called hw10.\n",
    "\n",
    "Note also the exercises build on top of one another so you might be able to do the next exercise if you have not completed the previous exercise.\n",
    "\n",
    "Post any questions you have on our Slack at **cis-024c1.slack.com**\n",
    "\n",
    "Slides\n",
    "\n",
    "https://docs.google.com/presentation/d/1AigvCKV1yb3PrrcT5xt3IqyAwGpv6IKMNWYUiQ2Oy6k/edit?usp=sharing\n",
    "\n",
    "**Please refer back to hw1 and slack for instructions on how to setup your computer for developing using Python.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helpful Jupyter Commands\n",
    "\n",
    "Below are some useful commands to know when using Jupyter\n",
    "\n",
    "1. You can add a new cell by clicking on the \"+\" icon on top.\n",
    "2. You can delete a cell by selecting that cell and clicking on the \"scissors\" icon on top.\n",
    "3. You can execute a cell by either pressing shift+enter or selecting the \"play\" button on top.\n",
    "4. You can create a new file in Jupyter via the File menu->New Notebook option. Make sure to select Python 2 when creating your notebook.\n",
    "5. Also, for your code blocks make sure that Code is selected instead of another option like Markdown.\n",
    "6. Use the Enter key to go to the next line in a cell to enter the next statement.\n",
    "7. You can clear results by clicking on the Cell menu item and selecting Current Output->Clear or All Output->Clear depending on whether you are trying to just clear the output for one cell or for all cells.\n",
    "8. In case your program has crashed for some reason (infinite loop, for example), you can restart your Python session by select Kernel in the menu and selecting Restart.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Check Python Version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Python 3.6.5 :: Anaconda, Inc.\n"
     ]
    }
   ],
   "source": [
    "!python --version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 1 - Testing your knowledge of object oriented programming concepts **\n",
    "\n",
    "Answer the below questions\n",
    "\n",
    "1. Why do we need classes?\n",
    "2. What is encapsulation?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<< Double click this cell and enter your result >>\n",
    "1. We need classes so that we can create blueprints and then we can make many objects out of that same blueprint. A class is special because it can make both attributes and actions for the objects.\n",
    "2. Encapsulation is making a variable or method inside a class private so you don't accidently call it from outside a class. You put two uncderscores before the name of the variable or function and it becomes private. It is still possible to call the private function outside the class with a special syntax as making it private is to stop *accidental* use outside the function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Exercise 2 - Class creation **\n",
    "\n",
    "Create a Python class named **Employee** with the following attributes and methods\n",
    "\n",
    "Data members\n",
    "```\n",
    "1. employeeName  - type string\n",
    "2. employeeAge  - type int\n",
    "3. employeeSalary - type float\n",
    "```\n",
    "\n",
    "Methods:\n",
    "```\n",
    "1. getEmployee - returns employee name\n",
    "2. getEmployeeAge - gets the employee age\n",
    "3. getEmployeeSalary - returns the employee salary\n",
    "4. __init__ - initialize method accepts the name, age and salary of the employee\n",
    "```\n",
    "\n",
    "Create an object of type Employee and initialize with arbitrary values. Invoke the get methods and display the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "### YOUR CODE GOES BELOW\n",
    "class Employee(object):\n",
    "    def __init__(self, name, age, salary):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.salary = salary\n",
    "    \n",
    "    def get_emp(self):\n",
    "        return self.name\n",
    "    \n",
    "    def get_emp_age(self):\n",
    "        return self.age\n",
    "    \n",
    "    def get_emp_salary(self):\n",
    "        return self.salary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John\n",
      "30\n",
      "100000.0\n"
     ]
    }
   ],
   "source": [
    "emp = Employee(\"John\", 30, 100000.00)\n",
    "print(emp.get_emp())\n",
    "print(emp.get_emp_age())\n",
    "print(emp.get_emp_salary())\n",
    "### END CODE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 3 - Private members\n",
    "\n",
    "In the above **Employee** class make the employeeName, employeeAge and employeeSalary private so that their access is restricted to only within the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "### YOUR CODE GOES BELOW\n",
    "class Employee(object):\n",
    "    def __init__(self, name, age, salary):\n",
    "        self.__name = name\n",
    "        self.__age = age\n",
    "        self.__salary = salary\n",
    "    \n",
    "    def get_emp(self):\n",
    "        return self.__name\n",
    "    \n",
    "    def get_emp_age(self):\n",
    "        return self.__age\n",
    "    \n",
    "    def get_emp_salary(self):\n",
    "        return self.__salary\n",
    "### END CODE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 4 - Adding setters and working with a list of Employees\n",
    "\n",
    "In the **Employee** class add the following methods\n",
    "\n",
    "```\n",
    "1. setEmployeeAge - accepts age and sets it in the object\n",
    "2. setEmployeeName - accepts employee name and sets it in the object\n",
    "3. setEmployeeSalary - accepts employee salary and sets it i nthe object\n",
    "```\n",
    "\n",
    "Create a list of employees called employeeList. Initialize the list with three objects of type Employee. Initialize the object with the values \"None\" for employeeName, 0 for employeeAge and 0 for employeeSalary.\n",
    "\n",
    "Loop  through each employee in the employeeList. Each time, request the user to enter the name, age and salary of a different employee. Use the set methods to set the name, age and salary for each employee in the employeeList.\n",
    "\n",
    "Loop through each employee in the employeeList. Display the name, age and salary of each employee."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "### YOUR CODE GOES BELOW\n",
    "class Employee(object):\n",
    "    def __init__(self, name, age, salary):\n",
    "        self.__name = name\n",
    "        self.__age = age\n",
    "        self.__salary = salary\n",
    "    \n",
    "    def get_emp(self):\n",
    "        return self.__name\n",
    "    \n",
    "    def get_emp_age(self):\n",
    "        return self.__age\n",
    "    \n",
    "    def get_emp_salary(self):\n",
    "        return self.__salary\n",
    "    \n",
    "    def set_emp_name(self, name):\n",
    "        self.__name = name\n",
    "    \n",
    "    def set_emp_age(self, age):\n",
    "        self.__age = age\n",
    "    \n",
    "    def set_emp_salary(self, salary):\n",
    "        self.__salary = salary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter name of employee 1: Sam\n",
      "Enter age of employee 1: 28\n",
      "Enter salary of employee 1: 85000\n",
      "\n",
      "\n",
      "Enter name of employee 2: John\n",
      "Enter age of employee 2: 34\n",
      "Enter salary of employee 2: 112000.00\n",
      "\n",
      "\n",
      "Enter name of employee 3: Lisa\n",
      "Enter age of employee 3: 40\n",
      "Enter salary of employee 3: 105000\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Sam 28 85000.0\n",
      "John 34 112000.0\n",
      "Lisa 40 105000.0\n"
     ]
    }
   ],
   "source": [
    "emp_list = [Employee(None, 0, 0), Employee(None, 0, 0), Employee(None, 0, 0)]\n",
    "\n",
    "for emp in emp_list:\n",
    "    name = input(\"Enter name of employee %d: \" % (emp_list.index(emp) + 1))\n",
    "    age = int(input(\"Enter age of employee %d: \" % (emp_list.index(emp) + 1)))\n",
    "    salary = float(input(\"Enter salary of employee %d: \" % (emp_list.index(emp) + 1)))\n",
    "    \n",
    "    emp.set_emp_name(name)\n",
    "    emp.set_emp_age(age)\n",
    "    emp.set_emp_salary(salary)\n",
    "    \n",
    "    print(\"\\n\")\n",
    "\n",
    "print(\"\\n\\n\")  \n",
    "\n",
    "for emp in emp_list:\n",
    "    print(emp.get_emp(), emp.get_emp_age(), emp.get_emp_salary())\n",
    "### END CODE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 5 -  Creating a Python calculator class\n",
    "\n",
    "Create a Python class called Calculator. \n",
    "\n",
    "The class has the following data members\n",
    "\n",
    "```\n",
    "1. number1 - type float\n",
    "2. number2 - type float\n",
    "```\n",
    "\n",
    "The class must have the below methods\n",
    "\n",
    "```\n",
    "1. add - adds two numbers and returns the result\n",
    "2. subtract - subtracts the first number from the second number and returns the result\n",
    "3. multiply - multiply two numbers and returns the result\n",
    "4. divide - divide the first number by the second number and returns the result\n",
    "5. __init__ - accepts two numbers and uses those numbers to initialize number1 and number2 respectively\n",
    "```\n",
    "\n",
    "Create an object of the Calculator class. Initialize it with any two arbitrary numbers. Invoke the methods add, subtract, multiple and divide and display the result\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "### YOUR CODE GOES \n",
    "class Calculator(object):\n",
    "    def __init__(self, num1, num2):\n",
    "        self.num1 = num1\n",
    "        self.num2 = num2\n",
    "    \n",
    "    def add(self):\n",
    "        return self.num1 + self.num2\n",
    "    \n",
    "    def subtract(self):\n",
    "        return self.num1 - self.num2\n",
    "    \n",
    "    def multiply(self):\n",
    "        return self.num1 * self.num2\n",
    "    \n",
    "    def divide(self):\n",
    "        return self.num1 / self.num2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "5\n",
      "50\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "calc = Calculator(10, 5)\n",
    "\n",
    "print(calc.add())\n",
    "print(calc.subtract())\n",
    "print(calc.multiply())\n",
    "print(calc.divide())\n",
    "### END CODE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optional Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "In the next two problems, you’ll be building an address book using object-­‐oriented programming in Python. To begin, you’ll define a Person class. You’ll use this class in the next problem to build your address book – each entry in your address book will be an instance of the Person class.\n",
    "\n",
    "To begin, define the    init    and    str    methods for the Person class. Read the Python documentation if needed to help you understand what    init__ and    str \t need to do.\n",
    "\n",
    "Here’s an example interaction in the Python shell demonstrating how your class should work after implementing these two methods:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Emily = Person(“Zhang”, “Emily”, “5559358150”, “emzhang@mit.edu”)\n",
    "print Emily\n",
    "Zhang, Emily -- Phone Number: 5559358150 -- Email Address(es): emzhang@mit.edu\n",
    "Wesley = Person(“Graybill”, “Wesley”, “5551940325”, [‘wgray496@mit.edu’, ‘wdgraybill@gmail.com’])\n",
    "print Wesley\n",
    "Graybill, Wesley -- Phone Number: 5551940325 -- Email Address(es): wgray496@mit.edu, wdgraybill@gmail.com"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "### YOUR CODE GOES \n",
    "class Person(object):\n",
    "    def __init__(self, last_name, first_name, phone_number, email_address):\n",
    "        self.name = last_name + \", \" + first_name\n",
    "        self.phone = phone_number\n",
    "        self.email = email_address\n",
    "    \n",
    "    def __str__(self):\n",
    "        result = self.name + \" -- Phone Number: \" + str(self.phone) + \" -- Email Address(es): \"\n",
    "        \n",
    "        if type(self.email) is list:\n",
    "            for email in self.email:\n",
    "                if email == self.email[-1]:\n",
    "                    result += email\n",
    "                else:\n",
    "                    result += email + \", \"\n",
    "        else:\n",
    "            result += self.email\n",
    "        \n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zhang, Emily -- Phone Number: 5559358150 -- Email Address(es): emzhang@mit.edu\n"
     ]
    }
   ],
   "source": [
    "Emily = Person(\"Zhang\", \"Emily\", \"5559358150\", \"emzhang@mit.edu\")\n",
    "print(Emily)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Graybill, Wesley -- Phone Number: 5551940325 -- Email Address(es): wgray496@mit.edu, wgraybill@gmail.com\n"
     ]
    }
   ],
   "source": [
    "Wesley = Person(\"Graybill\", \"Wesley\", \"5551940325\", ['wgray496@mit.edu', 'wgraybill@gmail.com'])\n",
    "print(Wesley)\n",
    "### END CODE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this problem, you will use your Person class from the previous problem to create an address book for storing the contacts of your friends and family. It should allow you to search the address book for a friend, and return their contact information.\n",
    "\n",
    "Begin by defining an   init   method. Don’t forget about Python's built-­‐in dictionary data type.\n",
    "\n",
    "Next, write a method add_contact that allows you to add a new person to the address book.\n",
    "\n",
    "Finally, write a method lookup_contact that looks up a contact by last name. The method should accept the last name as an argument, and print each contact that matches the last name on a new line. As an additional challenge, extend this method to allow users to optionally specify a first name to narrow down the results when multiple contacts have the same last name. To learn more about optional arguments in Python, search for terms such as “optional arguments in Python” and “default arguments in Python”.\n",
    "\n",
    "For example, suppose the contact book contains entries for both Ali Kamil, and his wife Sama Kamil. The following is an example output:\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    ">>> a = AddressBook()\n",
    ">>> a.add_person(Person(“Kamil”, “Ali”, … ))\n",
    ">>> a.add_person(Person(“Kamil”, “Sama”, … ))\n",
    ">>> a.lookup_contact(“Kamil”) Kamil, Ali -- Phone Number: … Kamil, Sama -- Phone Number: …\n",
    ">>> a.lookup_contact(“Kamil”, “Ali”)\n",
    "Kamil, Ali -- Phone Number: …\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "### YOUR CODE GOES \n",
    "\n",
    "\n",
    "### END CODE"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}