module-2/week-2/day-1-oop-2/oop-2-enkeboll.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quick Review"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Boat():\n",
    "    _floats = True\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.sail = 1\n",
    "        self._has_captain = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can just as easily set it to false, even though you're not supposed to\n",
    "titanic = Boat()\n",
    "titanic._floats = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "titanic._floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "titanic._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "property"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "property(fget=None, fset=None, fdel=None)\n",
    "# fget is our getter method\n",
    "# fset is our setter method\n",
    "# fdel is our delete method\n",
    "\n",
    "# these can be positional arguments OR keyword arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Boat():\n",
    "    _floats = True\n",
    "\n",
    "    def floats_setter(self, new_value):\n",
    "        print('nope')\n",
    "\n",
    "    def floats_getter(self):\n",
    "        return self._floats\n",
    "\n",
    "    floats = property(floats_getter, floats_setter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "titanic = Boat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nope\n"
     ]
    }
   ],
   "source": [
    "titanic.floats = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "titanic.floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "titanic."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Property, Get, and Set with Decorators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ExampleClass(object):\n",
    "    def __init__(self):\n",
    "        self._x = None\n",
    "\n",
    "    @property    \n",
    "    def x(self):\n",
    "        return self._x * 5\n",
    "\n",
    "    @x.setter\n",
    "    def x(self, value):\n",
    "        if value < 0:\n",
    "            print (\"nope!\")\n",
    "        else:\n",
    "            self._x = value\n",
    "\n",
    "    @x.deleter\n",
    "    def x(self):\n",
    "        del self._x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nope!\n"
     ]
    }
   ],
   "source": [
    "x1 = ExampleClass()\n",
    "x1.x = -5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Celsius:\n",
    "    def __init__(self, temperature=0):\n",
    "        self._temperature = temperature\n",
    "\n",
    "    def to_fahrenheit(self):\n",
    "        return (self.temperature * 1.8) + 32\n",
    "\n",
    "    def to_kelvin(self):\n",
    "        return self.temperature - 273\n",
    "\n",
    "    @property\n",
    "    def temperature(self):\n",
    "        print(\"Getting value\")\n",
    "        return self._temperature\n",
    "\n",
    "    @temperature.setter\n",
    "    def temperature(self, value):\n",
    "        if value < -273:\n",
    "            raise ValueError(\"Temperature below -273 is not possible\")\n",
    "        print(\"Setting value\")\n",
    "        self._temperature = value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = Celsius(temperature=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting value\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.temperature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = Celsius()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting value\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.temperature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting value\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-273"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.to_kelvin()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Static Methods and Class Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A static method is a method that you define in a class but doesn't take a default argument.\n",
    "\n",
    "Remember how functions normally take one argument \"self\" <- this is an instance method.\n",
    "\n",
    "The way you differentiate is by using the @staticmethod decorator.\n",
    "\n",
    "This is useful for having a collection of very general functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ExampleClass:\n",
    "    @staticmethod\n",
    "    def some_function(x):\n",
    "        return x + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "example_instance = ExampleClass()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_instance.some_function(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ExampleClass.some_function(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "#let's try this without the @staticmethod decorator\n",
    "#think for a minute about what you think is going to happen if I follow the exact same steps\n",
    "class ExampleClass:\n",
    "    def some_function(x):\n",
    "        return x + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "example_instance = ExampleClass()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "some_function() takes 1 positional argument but 2 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-43-f5c9917d495a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mexample_instance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msome_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: some_function() takes 1 positional argument but 2 were given"
     ]
    }
   ],
   "source": [
    "example_instance.some_function(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "^^^we expect this error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#class methods are useful for calling back to an attribute you define to the class itself rather than the instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "\n",
    "class Date(object):\n",
    "    def __init__(self, Year, Month, Day):\n",
    "        self.year  = Year\n",
    "        self.month = Month\n",
    "        self.day   = Day\n",
    "\n",
    "    def __str__(self):\n",
    "        return 'Date({}, {}, {})'.format(self.year, self.month, self.day)\n",
    "\n",
    "    def set_date(self, y, m, d):\n",
    "        self.year = y\n",
    "        self.month = m\n",
    "        self.day = d\n",
    "\n",
    "    @classmethod\n",
    "    def from_str(cls, date_str):\n",
    "        '''Call as\n",
    "           d = Date.from_str('2013-12-30')\n",
    "        '''\n",
    "        print(cls)\n",
    "        year, month, day = map(int, date_str.split('-'))\n",
    "        return cls(year, month, day)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_date = Date('2000','1','1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Date'>\n"
     ]
    }
   ],
   "source": [
    "d = Date.from_str('2013-12-30')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Date'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.Date at 0x11aecf1d0>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_date.from_str('2013-12-30')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If they work the same, why would we have any difference here??\n",
    "\n",
    "Think about this for a minute.\n",
    "\n",
    "There IS a reason."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "@staticmethod function is nothing more than a function defined inside a class. It is callable without instantiating the class first. It’s definition is immutable via inheritance.\n",
    "\n",
    "@classmethod function also callable without instantiating the class, but its definition follows Sub class, not Parent class, via inheritance. That’s because the first argument for @classmethod function must always be cls (class)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In other words, inheritance works differently for each.  Not going to go into examples for that now but I can share some useful documentation I found.\n",
    "\n",
    "https://rapd.wordpress.com/2008/07/02/python-staticmethod-vs-classmethod/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "\n",
    "\n",
    "class Shape:\n",
    "    def __init__(self, num_sides):\n",
    "        self.num_sides = num_sides\n",
    "\n",
    "    @property\n",
    "    def sides(self):\n",
    "        return [randint(1, 10) for i in range(self.num_sides)]\n",
    "    \n",
    "    def find_area(self):\n",
    "        raise NotImplemented\n",
    "\n",
    "\n",
    "class Triangle(Shape):\n",
    "    def __init__(self):\n",
    "        super().__init__(3)\n",
    "\n",
    "    def find_area(self):\n",
    "        a, b, c = self.sides\n",
    "        # calculate the semi-perimeter\n",
    "        s = (a + b + c) / 2\n",
    "        area = (s*(s-a)*(s-b)*(s-c)) ** 0.5\n",
    "        print(f'The area of the triangle is {area}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The area of the triangle is 7.644442425710328\n"
     ]
    }
   ],
   "source": [
    "t = Triangle()\n",
    "t.find_area()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Domain Model - Building Object Relations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Card():\n",
    "\n",
    "    _all_cards = ['Ace', 'King', 'Queen', 'Jack']\n",
    "\n",
    "    def __init__(self, name):\n",
    "        Card._all_cards.append(name)\n",
    "        # note that we're using the class name\n",
    "\n",
    "    @classmethod\n",
    "    def all_cards(cls):\n",
    "        return(cls._all_cards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ace', 'King', 'Queen', 'Jack', 'two_of_clubs', 'two_of_diamonds']"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Card.all_cards()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Card at 0x11b023630>"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Card('two_of_diamonds')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# can we do this with static methods????\n",
    "\n",
    "class Card():\n",
    "    \n",
    "    _all_cards = ['Ace','King','Queen','Jack']\n",
    "    \n",
    "    def __init__(self,name):\n",
    "        Card._all_cards.append(name)\n",
    "        #note that we're using the class name\n",
    "    \n",
    "    @staticmethod\n",
    "    def all_cards():\n",
    "        return(Card._all_cards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Card.all_cards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "two_of_clubs = Card('two of clubs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ace', 'King', 'Queen', 'Jack', 'two of clubs']"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Card.all_cards()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "have them do this but instead _all_cards contains \n",
    "the objects themselves.\n",
    "Instantiate ace, king, queen, jack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "so for this example, we say many cards belong to one overall Card class"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}