Classes_and_Objects.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MSDS 430 Module 9 Python Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\"> In this assignment you will complete the following exercises and submit your <b>notebook</b> and <b>html file</b> to Canvas. Your files should include all output, i.e. run each cell and save your file before submitting.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\"> In this exercise, we will go over a brief introduction to the following topics related to Object-Oriented Programming (OOP) in Python:\n",
    "\n",
    "<li>Classes & Objects</li>\n",
    "<li>Instances</li>\n",
    "<li>Methods</li>\n",
    "\n",
    "Reference: https://docs.python.org/3/tutorial/classes.html </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes & Objects\n",
    "\n",
    "In simple terms, an object comprises of data elements in addition to some functionality (or code). \n",
    "An object definition for this new data structure is called a `class`.  Another way of looking at is that a class definition gives you a template or blueprint of an object.\n",
    "\n",
    "The data elements that are part of the object are called `attributes` and the functions that are within the code are called `methods`. In this notebook, we will go through the steps of defining a new object, creating new instances and then manipulating them.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example Class\n",
    "In this example we use the `class` keyword to define the data (called attributes) and the code (called methods) that will make up an object definition called **Circle**. The `class` keyword includes the name of the class Circle and begins an indented block of code where we include the **attributes** and **methods**.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi\n",
    "\n",
    "# Class keyword followed by name of the class 'Circle'\n",
    "class Circle:\n",
    "    \n",
    "    # The class methods (or functions) follow \n",
    "    \n",
    "    # The 'magic' method  __init__ provides initial values for the instance variables\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"Circle: radius::\" + str(self.radius)\n",
    "\n",
    "    def area(self):\n",
    "        print(\"Area = \",round(pi*(self.radius**2),1))\n",
    "\n",
    "    def circumference(self):\n",
    "        print(\"Circumference = \",round(2*pi*(self.radius),1))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, the `class` keyword defines a new class named **Circle**. The code indented under class is part of the class Circle. The class has one attribute radius and three methods `__init__`, area and circumference.\n",
    "\n",
    "### `__init__` \n",
    "\n",
    "In a class definition you can initialize or set the attributes within that class by using a special method called `__init__()`. This method is executed after the class is instantiated. Inside the methods of a class the first parameter is a special value called `self`. This parameter is the instance the method is called on. Using `self` you can make changes to attributes of the instance. In the above example the radius attribute of the instance is set to the radius that is passed in as the second parameter by the following line of code\n",
    "````\n",
    "self.radius = radius\n",
    "````\n",
    "\n",
    "**Note: `self` is not a keyword or reserved word in Python. It is a convention that you must follow.**\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `__str__`\n",
    "\n",
    "\n",
    "This is the method you will define when you want to implement a readable version of the object. It is needed if you want to get a string version of the object using `str` or when you try to `print` the object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The special methods that are **always surrounded by double underscores (e.g. `__init__` or `__str__`)** are called **Magic Methods**. These are special methods that you can define to add specific functionality to your classes. \n",
    "\n",
    "By default classes have some built-in magic methods. But, some of them you have to provide your own implementations so that you get the results you are looking for.\n",
    "\n",
    "For a more comprehensive list of Magic commands visit: https://rszalski.github.io/magicmethods/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instances \n",
    "\n",
    "Once you have defined a class you can instantiate it to get an object (an instance) of that type. Lets see what it looks like with an example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example**\n",
    "\n",
    "Lets create an instance of class Circle (or a Circle object) that has a radius of 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "c1 = Circle(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c1 is a Circle object with a radius of 5.\n",
    "\n",
    "Lets suppose we want to find out what radius does this instance c1 have. We can access instance variables directly by using the dot notation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c1.radius"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What if we wanted to see what type of object c1 is?**\n",
    "\n",
    "There are two ways:\n",
    "1. Use `type`<br/>\n",
    "2. Use  `__class__` <br/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Circle"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(c1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tells us that c1 is of type Circle.\n",
    "\n",
    "Lets try another way `__class__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Circle"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c1.__class__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets try printing this object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circle: radius::5\n"
     ]
    }
   ],
   "source": [
    "print(c1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How did print work?** \n",
    "\n",
    "A call to the print function invoked the magic method `__str__` to obtain a string version of the Circle object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " **How can you find out what methods and attributes are defined for an object?**  \n",
    " \n",
    " 1. `dir (function)`&nbsp;[both methods & attributes]\n",
    " 2. `getmembers()`&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[both methods & attributes]\n",
    " 3. `__dict__` &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[just attributes]\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. dir function\n",
    "\n",
    "The `__dir__` function gave us a list of metaclass methods along with defined mehods & attributes. But, if you want more details, the inspect module has a useful function `getmembers` \n",
    "\n",
    "Reference: https://docs.python.org/3/library/inspect.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'area',\n",
       " 'circumference',\n",
       " 'radius']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(c1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But, if you want more details, the inspect module has a useful function `getmembers` \n",
    "\n",
    "Reference: https://docs.python.org/3/library/inspect.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. getmembers()\n",
    "\n",
    "The `__dir__` function gave us a list of metaclass methods along with defined methods & attributes. But, if you want more details, the inspect module has a useful function `getmembers` \n",
    "\n",
    "Reference: https://docs.python.org/3/library/inspect.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('__class__', __main__.Circle),\n",
       " ('__delattr__',\n",
       "  <method-wrapper '__delattr__' of Circle object at 0x7f920888d850>),\n",
       " ('__dict__', {'radius': 5}),\n",
       " ('__dir__', <function Circle.__dir__()>),\n",
       " ('__doc__', None),\n",
       " ('__eq__', <method-wrapper '__eq__' of Circle object at 0x7f920888d850>),\n",
       " ('__format__', <function Circle.__format__(format_spec, /)>),\n",
       " ('__ge__', <method-wrapper '__ge__' of Circle object at 0x7f920888d850>),\n",
       " ('__getattribute__',\n",
       "  <method-wrapper '__getattribute__' of Circle object at 0x7f920888d850>),\n",
       " ('__gt__', <method-wrapper '__gt__' of Circle object at 0x7f920888d850>),\n",
       " ('__hash__', <method-wrapper '__hash__' of Circle object at 0x7f920888d850>),\n",
       " ('__init__',\n",
       "  <bound method Circle.__init__ of <__main__.Circle object at 0x7f920888d850>>),\n",
       " ('__init_subclass__', <function Circle.__init_subclass__>),\n",
       " ('__le__', <method-wrapper '__le__' of Circle object at 0x7f920888d850>),\n",
       " ('__lt__', <method-wrapper '__lt__' of Circle object at 0x7f920888d850>),\n",
       " ('__module__', '__main__'),\n",
       " ('__ne__', <method-wrapper '__ne__' of Circle object at 0x7f920888d850>),\n",
       " ('__new__', <function object.__new__(*args, **kwargs)>),\n",
       " ('__reduce__', <function Circle.__reduce__()>),\n",
       " ('__reduce_ex__', <function Circle.__reduce_ex__(protocol, /)>),\n",
       " ('__repr__', <method-wrapper '__repr__' of Circle object at 0x7f920888d850>),\n",
       " ('__setattr__',\n",
       "  <method-wrapper '__setattr__' of Circle object at 0x7f920888d850>),\n",
       " ('__sizeof__', <function Circle.__sizeof__()>),\n",
       " ('__str__',\n",
       "  <bound method Circle.__str__ of <__main__.Circle object at 0x7f920888d850>>),\n",
       " ('__subclasshook__', <function Circle.__subclasshook__>),\n",
       " ('__weakref__', None),\n",
       " ('area',\n",
       "  <bound method Circle.area of <__main__.Circle object at 0x7f920888d850>>),\n",
       " ('circumference',\n",
       "  <bound method Circle.circumference of <__main__.Circle object at 0x7f920888d850>>),\n",
       " ('radius', 5)]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import inspect\n",
    "inspect.getmembers(c1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. `__dict__`\n",
    "\n",
    "This is one simple way to find out all the attribute values of an instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'radius': 5}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c1.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Another Circle Object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Circle'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'radius': 20}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create another instance of the class \n",
    "c2 = Circle(20)\n",
    "\n",
    "# Print the type of c2 \n",
    "print(type(c2))\n",
    "\n",
    "# Display attributes of c2\n",
    "c2.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instance Methods\n",
    "\n",
    "In the Circle class the first method is a regular **instance** method. It takes one parameter, `self`, which points to an instance of Circle when the method is called. Through the `self` parameter, instance methods can access attributes and other methods on the same object.\n",
    "````\n",
    "    def area(self):\n",
    "        print(\"Area = \",round(pi*(self.radius**2),1))\n",
    "````\n",
    "\n",
    "**Note:** For methods, you need to provide any parameters in the parentheses `()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example**\n",
    "<br/>\n",
    "<br/>\n",
    "Lets see how we can call the method on the 2 Circle objects `c1` and `c2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area =  78.5\n"
     ]
    }
   ],
   "source": [
    "c1.area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area =  1256.6\n"
     ]
    }
   ],
   "source": [
    "c2.area()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly we can also calculate the circumference of `c1` and `c2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circumference =  31.4\n"
     ]
    }
   ],
   "source": [
    "c1.circumference()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circumference =  125.7\n"
     ]
    }
   ],
   "source": [
    "c2.circumference()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets see how we can apply these OOP concepts to a class definition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"><b>Problem 1 (10 pts.)</b>: Complete the class definition below along with the 'Test cases' that follow.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Illinois\n",
      "IL\n",
      "12.8\n",
      "Population of Illinois increased to 13.8 million.\n",
      "Population of Illinois decreased to 12.3 million.\n",
      "Name: Illinois, Population (in MM): 12.3, PostalCode: IL\n",
      "Name: California, Population (in MM): 39.54, PostalCode: CA\n"
     ]
    }
   ],
   "source": [
    "import logging\n",
    "\n",
    "class State:\n",
    "    \"\"\"A class representing a US state.\"\"\"\n",
    "        \n",
    "    def __init__(self, name, postalCode, population):\n",
    "        self.name = name\n",
    "        self.postalCode = postalCode # TODO: initialize the attribute postalCode \n",
    "        self.population = population # TODO: initialize the attribute population\n",
    "        \n",
    "        \n",
    "    \n",
    "    def __str__(self):\n",
    "        \"\"\"Readable version of the State object\"\"\"\n",
    "        return 'Name: ' + self.name + \", Population (in MM): \" + str(self.population) + \", PostalCode: \" + self.postalCode\n",
    "    \n",
    "    def increase_population(self, numPeople):\n",
    "        \"\"\"Increases the population of the state.\"\"\"\n",
    "        self.population += numPeople\n",
    "        print(\"Population of\",self.name,\"increased to\",self.population,\"million.\")\n",
    "        \n",
    "    def decrease_population(self, numPeople):\n",
    "        \"\"\"Decreases the population of the state.\"\"\"\n",
    "        try:\n",
    "            if (numPeople > self.population):\n",
    "                raise ValueError(\"decrease_population(self, numPeople): Invalid value for population reduction\")\n",
    "            else:\n",
    "                self.population -= numPeople # TODO: decrease the population by the value in variable numPeople\n",
    "                \n",
    "                \n",
    "                # Print new population\n",
    "                print(\"Population of\",self.name,\"decreased to\",self.population,\"million.\")\n",
    "        except Exception as e:\n",
    "            logging.exception(e)            \n",
    "\n",
    "# Test Cases             \n",
    "# Create an instance of State 'il' corresponding to Illinois, with a postal code of IL and a population of 12.8 million\n",
    "il = State(\"Illinois\",\"IL\",12.8)\n",
    "\n",
    "# print the name of object il \n",
    "print(il.name)\n",
    "\n",
    "# TODO: print the postalCode of il\n",
    "print(il.postalCode)\n",
    "\n",
    "# TODO: print the population of il\n",
    "print(il.population)\n",
    "\n",
    "# TODO: use the given method to increase the population of il by 1 million\n",
    "il.increase_population(1)\n",
    "\n",
    "# TODO: use the given method to decrease the population of il by 1.5 million\n",
    "il.decrease_population(1.5)\n",
    "# TODO: print the il State object\n",
    "print(il)\n",
    "# TODO: Create an instance of State 'ca' corresponding to California, with a postal code of CA and a population of 39.54 million\n",
    "ca = State(\"California\",'CA',39.54) \n",
    "# TODO: print the ca State object\n",
    "print(ca)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Methods & Static Methods \n",
    "\n",
    "We looked at instance methods a little earlier and worked through examples of how these are used. Now, we will explore class and static methods. \n",
    "\n",
    "\n",
    "**Class Methods**\n",
    "\n",
    "These methods are designated with a `@classmethod` decorator flag before the method definition. Instead of using the `self` parameter, class methods take a `cls` parameter that points to the class (**and not the object instance**) when the method is called. Though these methods can't modify an instance variable they can modify a class variable that applies across all instances. This will be easier to see in the example class `PizzaOrder` further below.\n",
    "\n",
    "**Static Methods**\n",
    "\n",
    "These methods are designated with a `@staticmethod` decorator flag before the method definition. This type of method doesnt require the `self` or `cls` parameter. So, static methods can neither modify the state of the object nor the state of the class. These methods are restricted in the  data they can access within the class.\n",
    "\n",
    "Lets take a look at both of these in the class `PizzaOrder` below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PizzaOrder:\n",
    "    \n",
    "    # class attribute 'size' of the pizza in inches\n",
    "    size = 12\n",
    "    \n",
    "    def __init__(self, toppings):\n",
    "        self.toppings = toppings\n",
    "    \n",
    "    def add_toppings(self, toppings):\n",
    "        \"\"\" add toppings to a pizza order\"\"\"\n",
    "        self.toppings.append(toppings)\n",
    "\n",
    "    def remove_toppings(self, toppings):\n",
    "        \"\"\" deletes toppings from a pizza order\"\"\"\n",
    "        self.toppings.remove(toppings)    \n",
    "    \n",
    "    @classmethod\n",
    "    def change_size(cls, new_size):\n",
    "        \"\"\"Class method: sets the pizza size for all orders\"\"\"\n",
    "        cls.size = new_size\n",
    "        \n",
    "    @staticmethod\n",
    "    def gimme_the_works():\n",
    "        \"\"\"Gimme the works\"\"\"\n",
    "        return PizzaOrder([\"Cheese\",\"Green Peppers\",\"Onions\",\"Olives\",\"Mushrooms\",\"Bacon\",\"Pepperoni\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example, a class **PizzaOrder** is used to unsurprisingly represent a Pizza order. You can order 12-inch pizzas only at this time, but you can add or remove toppings from your order (via the `add_toppings` and `remove_toppings` instance methods). \n",
    "\n",
    "The owner of the pizza company wanted to have the option of changing the size of the pizzas down the road. But, she wants to only provide pizzas of the same size. So, we have provided a class method `change_size`. In this method, notice that the first parameter is `cls` instead of `self`. This is because any changes made via a class method applies to all the existing and new instances of of the class. \n",
    "\n",
    "````\n",
    "    @classmethod\n",
    "    def change_size(cls, new_size):\n",
    "        \"\"\"Class method: sets the pizza size for all orders\"\"\"\n",
    "        cls.size = new_size\n",
    "````\n",
    "\n",
    "**Note: The use of `cls` as the first parameter in a class method is also a convention like the use of `self` in an instance method.**\n",
    "\n",
    "Lets see how we can use this class method this works with an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pizza size in first order is 12 inches and toppings are ['Pepperoni', 'Sausage']\n",
      "Pizza size in second order is 12 inches and toppings are ['Cheese', 'Mushrooms']\n"
     ]
    }
   ],
   "source": [
    "# Create two instances p1 and p2\n",
    "# p1 is an order for a pepperoni pizza while p2 is an order for cheese pizza\n",
    "p1 = PizzaOrder([\"Pepperoni\"])\n",
    "\n",
    "# Lets add a sausage topping to this one\n",
    "p1.add_toppings(\"Sausage\")\n",
    "\n",
    "# Lets get another pizza \n",
    "p2 = PizzaOrder([\"Cheese\"])\n",
    "\n",
    "# Add two new toppings\n",
    "p2.add_toppings(\"Green Peppers\")\n",
    "p2.add_toppings(\"Mushrooms\")\n",
    "\n",
    "# Hmm .. on second thought, skip the Green Pepper on the second pizza\n",
    "p2.remove_toppings(\"Green Peppers\")\n",
    "\n",
    "# Display the current size of these pizza orders\n",
    "print(\"Pizza size in first order is\", p1.size, \"inches and toppings are\",p1.toppings)\n",
    "print(\"Pizza size in second order is\", p2.size, \"inches and toppings are\",p2.toppings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No surprises here. Two orders were placed for single topping pizzas and these were created.\n",
    "\n",
    "We just got news that the pizza company can only make 16 inch pizzas. \n",
    "\n",
    "How would you do that? \n",
    "\n",
    "You have a couple of options <br/>\n",
    "**Option 1:** You can modify the `__init__` method to set the size to 16\n",
    "<br/>\n",
    "**Option 2:** You can invoke the class method `change_size` and pass in the new size as a parameter \n",
    "\n",
    "Lets say that you don't want to make any more changes to code. So, lets use the class method instead.\n",
    "\n",
    "A class method is called by `ClassName.classmethod(params)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pizza size in first order is 16 inches and toppings are ['Cheese', 'Onions', 'Green Peppers']\n"
     ]
    }
   ],
   "source": [
    "# Call class method change_size to change the pizza size to 16 \n",
    "PizzaOrder.change_size(16)\n",
    "\n",
    "p2 = PizzaOrder([\"Cheese\",\"Onions\",\"Green Peppers\"])\n",
    "\n",
    "# Display the current size of these pizza orders\n",
    "print(\"Pizza size in first order is\", p2.size, \"inches and toppings are\",p2.toppings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might have noticed that you didn't have to pass in the new pizza size to the instance p2. Using the class method you were able to change the size of all pizzas. \n",
    "\n",
    "Wait a minute, does this affect our earlier pizza orders?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pizza size in first order is 16 inches and toppings are ['Pepperoni', 'Sausage']\n",
      "Pizza size in second order is 16 inches and toppings are ['Cheese', 'Onions', 'Green Peppers']\n"
     ]
    }
   ],
   "source": [
    "# Display the current size of these pizza orders\n",
    "print(\"Pizza size in first order is\", p1.size, \"inches and toppings are\",p1.toppings)\n",
    "print(\"Pizza size in second order is\", p2.size, \"inches and toppings are\",p2.toppings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whoa! So, all **existing** and **new** pizza orders will be 16 inches. \n",
    "\n",
    "Thats how class methods work. In Problem 2, you will see another example of how class methods could be useful.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Static Methods\n",
    "\n",
    "Static methods are different from instance and class methods in that their definition doesnt require a `cls` or `self` parameter. So, these methods can't make any changes to class or instance variables.\n",
    "\n",
    "For the pizza company, we were offering people a pizza called \"The Works\". The `gimme_the_works` returns a PizzaOrder with all the possible toppings. \n",
    "\n",
    "````\n",
    "    @staticmethod\n",
    "    def gimme_the_works():\n",
    "        \"\"\"Gimme the works\"\"\"\n",
    "        return PizzaOrder([\"Cheese\",\"Green Peppers\",\"Onions\",\"Olives\",\"Mushrooms\",\"Bacon\",\"Pepperoni\"])\n",
    "````\n",
    "Lets see how we can use the static method in an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The toppings on this one are: ['Cheese', 'Green Peppers', 'Onions', 'Olives', 'Mushrooms', 'Bacon', 'Pepperoni']\n"
     ]
    }
   ],
   "source": [
    "special_pizza = PizzaOrder.gimme_the_works()\n",
    "\n",
    "# Display the toppings we got on the works\n",
    "print(\"The toppings on this one are:\", special_pizza.toppings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The key takeaway here is that the static methods can't make any changes to the state of an object or class i.e. to the class variables. You could use static methods for any functionality that is general purpose and something that wouldnt impact future or current objects.\n",
    "\n",
    "Now, you are ready to tackle Problem 2 in this week's assignment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"><b>Problem 2 (10 pts.)</b>: Complete the class definition below along with the 'Test cases' that follow.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6000\n",
      "YES! ** 4123455522223421 ** is a Visa Card!\n",
      "NO! ** 5123555222234213 ** is not a Visa Card!\n",
      "25\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "class CreditCard:\n",
    "    \"\"\"A Class to represent Credit Cards\"\"\"\n",
    "    # class attribute 'apr' initialized to 21%\n",
    "    apr = 21\n",
    "    limit = 10000\n",
    "    card_name = \"VISA\"\n",
    "    # TODO: initialize class attribute 'limit' to 10000\n",
    "    \n",
    "    # TODO: initialize class attribute 'card_name' to \"VISA\"\n",
    "    \n",
    "    def __init__(self, balance):\n",
    "        self.balance = balance\n",
    "        \n",
    "    def make_purchase(self, amount):\n",
    "        \"\"\" increase the balance by the purchase amount \"\"\"\n",
    "        self.balance += amount    \n",
    "    \n",
    "    def make_payment(self, amount):\n",
    "        self.balance -= amount\n",
    "        # TODO: reduce the balance by payment amount, \n",
    "        \n",
    "    \n",
    "    @classmethod\n",
    "    def change_apr(cls, new_apr):\n",
    "        cls.apr = new_apr      \n",
    "        \n",
    "    @staticmethod\n",
    "    def is_visa(cardnumber):\n",
    "        \"\"\"A very basic validation of a visa credit card number\"\"\"\n",
    "        first_digit = cardnumber[0]\n",
    "        if ((first_digit == \"4\") and (len(cardnumber)==16)):\n",
    "            print (\"YES! **\",cardnumber,\"** is a Visa Card!\")\n",
    "            return True\n",
    "        else:\n",
    "            print (\"NO! **\",cardnumber,\"** is not a Visa Card!\")\n",
    "            return False\n",
    "\n",
    "# Test Cases\n",
    "# Create a new CreditCard object 'cc1' with a balance of 5000\n",
    "cc1 = CreditCard(5000)\n",
    "\n",
    "# TODO: create a new CreditCard object 'cc2' with a balance of 2000\n",
    "cc2 = CreditCard(2000)\n",
    "# use an instance method to make a purchase of 1000 on 'cc1' \n",
    "cc1.make_purchase(1000)\n",
    "\n",
    "# TODO: use an instance method to make a payment of $500 for 'cc1'\n",
    "cc2.make_payment(500)\n",
    "# TODO: print the balance of 'cc1'\n",
    "print(cc1.balance)\n",
    "\n",
    "# call the static method is_visa to verify whether 4123455522223421 is a visa card\n",
    "CreditCard.is_visa(\"4123455522223421\") \n",
    "\n",
    "# TODO: call the static method is_visa to verify whether 5123555222234213 is a visa card\n",
    "CreditCard.is_visa('5123555222234213')\n",
    "# TODO: call the class method change_apr to change the APR to 25% \n",
    "CreditCard.change_apr(25)\n",
    "\n",
    "# Print the APR of cc1 and cc2 instances to verify that the APR's for all cards have changed\n",
    "print(cc1.apr)\n",
    "print(cc2.apr)\n",
    "# TODO: display the APR of the cc1 object\n",
    "\n",
    "# TODO: display the APR of the cc2 object\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.5"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}