W5L12_Writing Our Own Classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Writing Our Own Classes (aka how to define our own objects!)\n",
    "\n",
    "Just like we can write our own function defintions, we can also write our own classes. A class is to an object as a function definition is to a function. The class defines the object. By defining the class, we can specify which attribute and methods the object will have.\n",
    "\n",
    "We will take this step by step. Let's first understand the basic syntax. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Class Keyword\n",
    "In the below cell, we will write a very simple class called `Dog`. Just as a function definition has to start with the `def` keyword, a class definition starts with the `class` keyword. This is then followed by the class name, and then a semicolon. Notice that there are no parentheses before the semicolon. We can also define a docstring, which we can access as usual"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    '''An empty class called Dog'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Just an example of accessing the docstring.\n",
    "Dog?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating An Instance Of An Object\n",
    "To create an instance of an object, we just execute the class, this will return an instance of the object. Think of the class as the blueprint for making an object. Our `Dog` class will be the instructions/blueprint for creating a dog object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "An empty class called Dog\n",
      "<class '__main__.Dog'>\n"
     ]
    }
   ],
   "source": [
    "my_dog = Dog()\n",
    "print(my_dog.__doc__)\n",
    "print(type(my_dog))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The __init__ method\n",
    "\n",
    "In the above example, we created an empty class that was not very exciting. We want to build beyond that and the first step to do so is to learn about a method called the `__init__` method. This is a special method that is run every time an instance of the object is created. This allows us to provide initial instructions to a new object - usually these instructions specify the initial data that is part of the object. The `__init__` function is the initializer function and it must be called `__init__` to be recognized as the initializer function by python.\n",
    "\n",
    "In the example below, we build on our `Dog` class, but this time we specify we include and `__init__` method. The method takes three arguments, `self`, `name`, and `breed`. The `self` argument is very important and is passed to most methods. The `self` variable points to the instance of the object and allows the object to interact with its self. (The will make more sense in the lecture).  The `name` and `breed` arguments will be passe to the class wen we create our object, and they will be used to set the `name` and `breed` **properties** (aka attributes) of the object.\n",
    "\n",
    "Note: The double underscore before and after the name indicate that is a special function recognized by python.  This is also try for `__doc__` and `__name__` (these are special attribute names that are specifically recognized by python)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    '''The Dog class'''\n",
    "    def __init__(self, name, breed):\n",
    "        '''Set the name and breed of the dog'''\n",
    "        self.name = name\n",
    "        self.breed = breed\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dog = Dog('Rufflies', 'Puli')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rufflies\n",
      "Puli\n"
     ]
    }
   ],
   "source": [
    "print(my_dog.name)\n",
    "print(my_dog.breed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lucy\n",
      "Poodle\n"
     ]
    }
   ],
   "source": [
    "neighbors_dog = Dog('Lucy', 'Poodle')\n",
    "print(neighbors_dog.name)\n",
    "print(neighbors_dog.breed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding More Methods:\n",
    "Below we add more methods. Let's add a `bark` method and a `eat` method (as well as a `energy` attribute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    '''The Dog class'''\n",
    "    def __init__(self, name, breed):\n",
    "        '''Initialize the Dog object'''\n",
    "        self.name = name\n",
    "        self.breed = breed\n",
    "        self.energy = 0\n",
    "    def bark(self):\n",
    "        '''Bark!'''\n",
    "        print('Woof Woof')\n",
    "    def eat(self):\n",
    "        '''Add 1 unit of energy'''\n",
    "        self.energy += 1\n",
    "    def play(self):\n",
    "        '''If energy is zero, let the owner know! Otherwise play fetch!'''\n",
    "        if self.energy == 0:\n",
    "            print('Dog looks at its food bowl....')\n",
    "        else:\n",
    "            self.energy -= 1\n",
    "            print('Dog plays fetch with you!')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# instatiate the dog object\n",
    "my_dog = Dog('Rufflies', 'Puli')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof Woof\n"
     ]
    }
   ],
   "source": [
    "# have the dog bark\n",
    "my_dog.bark()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before eating:  0\n",
      "Before eating:  1\n",
      "Dog plays fetch with you!\n",
      "Dog looks at its food bowl....\n",
      "Dog plays fetch with you!\n"
     ]
    }
   ],
   "source": [
    "# have the dog eat and play\n",
    "print('Before eating: ', my_dog.energy)\n",
    "my_dog.eat()\n",
    "print('Before eating: ', my_dog.energy)\n",
    "my_dog.play()\n",
    "my_dog.play()\n",
    "my_dog.eat()\n",
    "my_dog.play()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Updating Properties\n",
    "\n",
    "So far, we have been creating properties that we can easily set and update.  For example, there is no reason we can't change the name of a the dog object after we have created it. See the example below.\n",
    "\n",
    "Sometimes we do not want this we do not want to directly \"expose\" attributes to the outside world. We can address this with the `property` decorator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Terrier\n",
      "Lab\n"
     ]
    }
   ],
   "source": [
    "aunts_dog = Dog('Lola', 'Terrier')\n",
    "print(aunts_dog.breed)\n",
    "aunts_dog.breed = 'Lab'\n",
    "print(aunts_dog.breed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Property Decorator\n",
    "\n",
    "The property decorator allows to write special methods for getting, setting, and deleting a class property. Keep in mind that you DO NOT need to use this for every property in your class. You should only use the `property` decortor when it is needed. Simple is better. This is the python way.\n",
    "\n",
    "In the below example, we use the `property` decorator on the method `breed`. This method is the method used to return the `breed` property. We can access the `breed` property just like we would with any other property, i.e. `my_dog.breed`, but the function allows us to handle any processing before the property is returned (if needed).  There is still an object property called `_breed` that actually holds the underlying value.  The leading underscore is a convention that lets the user know that `_breed` should be considered a private property and not directly accessed - even though python has no way to actually restrict access."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    '''The Dog class'''\n",
    "    def __init__(self, name, breed):\n",
    "        '''Initialize the Dog object'''\n",
    "        self.name = name\n",
    "        self._breed = breed\n",
    "        self.energy = 0\n",
    "        \n",
    "    @property\n",
    "    def breed(self):\n",
    "        return self._breed\n",
    "    \n",
    "    def bark(self):\n",
    "        '''Bark!'''\n",
    "        print('Woof Woof')\n",
    "    def eat(self):\n",
    "        '''Add 1 unit of energy'''\n",
    "        self.energy += 1\n",
    "    def play(self):\n",
    "        '''If energy is zero, let the owner know! Otherwise play fetch!'''\n",
    "        if self.energy == 0:\n",
    "            print('Dog looks at its food bowl....')\n",
    "        else:\n",
    "            self.energy -= 1\n",
    "            print('Dog plays fetch with you!')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Terrier\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "can't set attribute",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-21-70c146e08a33>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0maunts_dog\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmy_dog\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDog\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Lola'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Terrier'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maunts_dog\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbreed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0maunts_dog\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbreed\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Lab'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maunts_dog\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: can't set attribute"
     ]
    }
   ],
   "source": [
    "aunts_dog = my_dog = Dog('Lola', 'Terrier')\n",
    "print(aunts_dog.breed)\n",
    "aunts_dog.breed = 'Lab'\n",
    "print(aunts_dog.breed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define Getter, Setter, and Deleter Methods For A Property\n",
    "\n",
    "We can also specify special setter and deleter methods. Note that we do this by first using the `property` decorator on the method that will be the getter method for the attribute. Note that the name of this method is, by definition, the name of the property. We then can define special setter and deleter methods by applying a decorator that python has specially created for this property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    '''The Dog class'''\n",
    "    def __init__(self, name, breed):\n",
    "        '''Initialize the Dog object'''\n",
    "        self.name = name\n",
    "        self._breed = breed\n",
    "        self.energy = 0\n",
    "    \n",
    "    @property\n",
    "    def breed(self):\n",
    "        return self._breed\n",
    "    \n",
    "    @breed.setter\n",
    "    def breed(self, value):\n",
    "        print(\"breed cannot be changed\")\n",
    "        \n",
    "    @breed.deleter\n",
    "    def breed(self):\n",
    "        print(\"breed cannot be deleted\")\n",
    "    \n",
    "    def bark(self):\n",
    "        '''Bark!'''\n",
    "        print('Woof Woof')\n",
    "    def eat(self):\n",
    "        '''Add 1 unit of energy'''\n",
    "        self.energy += 1\n",
    "    def play(self):\n",
    "        '''If energy is zero, let the owner know! Otherwise play fetch!'''\n",
    "        if self.energy == 0:\n",
    "            print('Dog looks at its food bowl....')\n",
    "        else:\n",
    "            self.energy -= 1\n",
    "            print('Dog plays fetch with you!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Terrier\n",
      "breed cannot be changed\n",
      "breed cannot be deleted\n"
     ]
    }
   ],
   "source": [
    "aunts_dog = my_dog = Dog('Lola', 'Terrier')\n",
    "print(aunts_dog.breed)\n",
    "aunts_dog.breed = 'Lab'\n",
    "del aunts_dog.breed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Property Decorator Allows Us To Have Dynamic Attributes\n",
    "The property decorator can also allow us to have properties that are dynamically calculated. Notice how the age property below is actually calculated dynamically everytime it is called."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "\n",
    "class Dog:\n",
    "    '''The Dog class'''\n",
    "    def __init__(self, name, breed, birthday):\n",
    "        '''Initialize the Dog object'''\n",
    "        self.name = name\n",
    "        self.breed = breed\n",
    "        self.birthday = birthday\n",
    "        self.energy = 0\n",
    "    \n",
    "    @property\n",
    "    def age(self):\n",
    "        '''Return the age, calculated from the current date nad the dogs\n",
    "        birthday'''\n",
    "        return (date.today() - self.birthday).total_seconds()/(60*60*24*365)\n",
    "        \n",
    "    def bark(self):\n",
    "        '''Bark!'''\n",
    "        print('Woof Woof')\n",
    "    def eat(self):\n",
    "        '''Add 1 unit of energy'''\n",
    "        self.energy += 1\n",
    "    def play(self):\n",
    "        '''If energy is zero, let the owner know! Otherwise play fetch!'''\n",
    "        if self.energy == 0:\n",
    "            print('Dog looks at its food bowl....')\n",
    "        else:\n",
    "            self.energy -= 1\n",
    "            print('Dog plays fetch with you!')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2016-01-01\n"
     ]
    }
   ],
   "source": [
    "my_dogs_birthday = date(year=2016, month=1, day=1)\n",
    "print(my_dogs_birthday)\n",
    "my_dog = Dog('Rufflies', 'Puli', my_dogs_birthday)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.882191780821918"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dog.age"
   ]
  },
  {
   "attachments": {
    "Success.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Success.png](attachment:Success.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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
}