Lessons/Object_Oriented_Programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Object Oriented Programming\n",
    "\n",
    "## [An Introduction to Classes and Inheritance](http://www.jesshamrick.com/2011/05/18/an-introduction-to-classes-and-inheritance-in-python/)\n",
    "\n",
    "### What is a Class?\n",
    "\n",
    "Data structures like lists and strings are extremely useful, but sometimes they are not enough to represent something you are trying to implement. For example, if you needed to keep track of a bunch of pets. We could represent a pet using a list by specifying the first element of the list as the pet’s name and the second element of the list as the pet’s species. This is very arbitrary and nonintuitive, however – how do you know which element is supposed to be which?\n",
    "\n",
    "**Classes give us the ability to create more complicated data structures that contain arbitrary content**. We can create a ```Pet``` class that keeps track of the name and species of the pet in usefully named **attributes** called ``name`` and ``species``, respectively.\n",
    "\n",
    "### What is an Instance?\n",
    "\n",
    "Before we get into creating a class itself, we need to understand an important distinction. **A class is something that just contains structure** – it defines how something should be laid out or structured, but does not actually fill in the content (It is like a form with the charactestistics that the objects or isntances can have). For example, a ``Pet`` class may say that a pet needs to have a ``name`` and a ``species``, but it will not actually say what the pet’s name or species is.\n",
    "\n",
    "This is where instances come in. An **instance** is a specific copy of the class that does **contain all of the content**. For example, if I create a pet ``polly``, with name \"Polly\" and species \"Parrot\", **then ``polly`` is an instance of Pet**.\n",
    "\n",
    "This can sometimes be a very difficult concept to master, so let’s look at it from another angle. Let’s say that the government has a particular tax form that it requires everybody to fill out. Everybody has to fill out the same type of form, but the content that people put into the form differs from person to person. A **class** is like the form (format): it specifies what content should exist. Your copy of the form with your specific information if like an **instance** of the class: it specifies what the content actually is.\n",
    "\n",
    "<img src=\"ClassInstance.jpg\" alt=\"jupyter\" style=\"width: 500px;\"/> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Keeping Track of Pets\n",
    "\n",
    "Now that we have an idea of what a class is and what the difference between a class and an instance is, let’s look at a real class!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Pet(object):\n",
    "    def __init__(self, name, species):\n",
    "        self.name = name\n",
    "        self.species = species\n",
    "        \n",
    "        \n",
    "    def getName(self):\n",
    "        return self.name\n",
    "    \n",
    "    \n",
    "    def getSpecies(self):\n",
    "        return self.species\n",
    "    \n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"{0} is a {1}\".format(self.name, self.species)\n",
    "        # return \"%s is a %s\" % (self.name, self.species)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Line 1\n",
    "This is the basic incant for creating a class. The first word, ```class```, indicates that we are creating a class. The second word, ```Pet```, indicates the name of the class. The word in parentheses, ```object```, is the class that ```Pet``` is inheriting from. We’ll get more into inheritance below, so for now all you need to know is that object is a special variable in Python that you should include in the parentheses when you are creating a new class.\n",
    "\n",
    "#### Lines 3-5\n",
    "When we create a new pet, we need to initialise (that is, specify) it with a ```name``` and a ```species```. The ```__init__``` method (method is just a special term for functions that are part of a class) is a special Python function that is called when an **instance of a class is first created**. For example, when running the code ```polly = Pet(\"Polly\", \"Parrot\")```, the ```__init__``` method is called with values ```polly```, ```\"Polly\"```, and ```\"Parrot\"``` for the variables ```self```, ```name```, and ```species```, ```respectively```.\n",
    "\n",
    "The ```self``` variable **is the instance of the class**. Remember that instances have the structure of the class but that the values within an instance may vary from instance to instance. So, we want to specify that our instance (```self```) **has different values in it than some other possible instance**. That is why we say ```self.name = name``` instead of ```Pet.name = name```.\n",
    "\n",
    "You might have noticed that the ```__init__``` method (as well as other methods in the ```Pet``` class) have this ```self``` variable, but that when you call the method (e.g. ```polly = Pet(\"Polly\", \"Parrot\")```), you only have to pass in two values. Why don’t we have to pass in the ```self``` parameter? This phenomena is a special behavior of Python: when you call a method of an instance, **Python automatically figures out what self should be (from the instance) and passes it to the function**. In the case of ```__init__```, Python first creates ```self``` and then passes it in. We’ll talk a little bit more about this below when we discuss the ```getName``` and ```getSpecies``` methods.\n",
    "\n",
    "#### Lines 7-11\n",
    "\n",
    "We can also **define methods to get the contents of the instance**. The ```getName``` method takes an instance of a ```Pet``` as a parameter and looks up the pet’s name. Similarly, the ```getSpecies``` method takes an instance of a Pet as a parameter and looks up the pet’s species. Again, we require the ```self``` parameter so that the function knows which instance of Pet to operate on: **it needs to be able to find out the content**.\n",
    "\n",
    "As mentioned before, we don’t actually have to pass in the ```self``` parameter because Python automatically figures it out. To make it a little bit clearer as to what is going on, we can look at two different ways of calling ```getName```. The first way is the standard way of doing it: ```polly.getName()```. The second, while not conventional, is equivalent: ```Pet.getName(polly)```. Note how in the second example we had to pass in the instance because **we did not call the method via the instance. Python can’t figure out what the instance is if it doesn’t have any information about it**.\n",
    "\n",
    "To drive the difference between instances and classes home, we can look at an explicit example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "polly = Pet(\"Polly\", \"Parrot\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Polly is a Parrot\n"
     ]
    }
   ],
   "source": [
    "print \"Polly is a {}\".format(polly.getSpecies())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Polly is a Parrot\n"
     ]
    }
   ],
   "source": [
    "print \"Polly is a {}\".format(Pet.getSpecies(polly))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unbound method getSpecies() must be called with Pet instance as first argument (got nothing instead)",
     "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-c961d9df7100>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# As we explained above, we have to provide the instancebecause we didn't call the method\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# via the isntance. Python can't figure out what the instance is.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mprint\u001b[0m \u001b[0;34m\"Polly is a {}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mPet\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetSpecies\u001b[0m\u001b[0;34m(\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: unbound method getSpecies() must be called with Pet instance as first argument (got nothing instead)"
     ]
    }
   ],
   "source": [
    "# As we explained above, we have to provide the instancebecause we didn't call the method\n",
    "# via the isntance. Python can't figure out what the instance is. \n",
    "print \"Polly is a {}\".format(Pet.getSpecies())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lines 13-14\n",
    "\n",
    "This ```__str__``` method is a special function that **is defined for all classes in Python** (you have have noticed that methods beginning and ending with a double underscore are special). You can specify your own version of any built-in method, known as overriding the method. By overriding the ```__str__``` method specifically, we can define the behavior when we try to print an instance of the Pet class using the print keyword.\n",
    "\n",
    "### Using Classes\n",
    "\n",
    "Let’s look at some examples of using the Pet class!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Polly'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "polly.getName()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Parrot'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "polly.getSpecies()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Polly is a Parrot\n"
     ]
    }
   ],
   "source": [
    "print polly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ginger = Pet(\"Ginger\", \"Cat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ginger'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ginger.getName()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Cat'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ginger.getSpecies()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ginger is a Cat\n"
     ]
    }
   ],
   "source": [
    "print ginger"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "clifford = Pet(\"Cliford\", \"Dog\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Cliford'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clifford.getName()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Dog'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clifford.getSpecies()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cliford is a Dog\n"
     ]
    }
   ],
   "source": [
    "print clifford"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subclasses\n",
    "\n",
    "Sometimes just defining a single class (like ```Pet```) is not enough. For example, some pets are dogs and most dogs like to chase cats, and maybe we want to keep track of which dogs do or do not like to chase cats. Birds are also pets but they generally don’t like to chase cats. We can make another class that is a ```Pet``` but is also specifically a ```Dog```, for example: this gives us the structure from ```Pet``` but also any structure we want to specify for ```Dog```.\n",
    "\n",
    "```\n",
    "            Chase cats \n",
    "           /\n",
    "Pets-Dogs-| \n",
    "     |\n",
    "     Cat\n",
    "     \\     \\Do not chase cats\n",
    "      \\\n",
    "       \\___hate Dogs      \n",
    "```      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Dog(Pet):\n",
    "    def __init__(self, name, chase_cats):\n",
    "        Pet.__init__(self, name, \"Dog\")\n",
    "        self.chase_cats = chase_cats\n",
    "        \n",
    "        \n",
    "    def chaseCats(self):\n",
    "        return self.chase_cats "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to specify that all ```Dogs``` have species \"Dog\", and also whether or not the dog likes to chase cats. To do this, we need to define our own initialization function (recall that this is known as overriding). We also need to call the parent class initialization function, though, because we still want the ```name``` and ```species``` fields to be initialized. If we did not have line 4, then we could still call the methods getName and getSpecies. However, because ```Pet.__init__``` was never called, the name and species fields were never created, so calling ```getName``` or ```getSpecies``` would throw an error.\n",
    "\n",
    "We can define a similar subclass for cats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Cat(Pet):\n",
    "    def __init__(self, name, hates_dogs):\n",
    "        Pet.__init__(self, name, \"Cat\")\n",
    "        self.hates_dogs = hates_dogs\n",
    "    \n",
    "    def hatesDog(self):\n",
    "        return self.hates_dogs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A Closer Look at Inheritance\n",
    "\n",
    "Let’s examine the difference between ```Dog``` and ```Pet```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mister_pet = Pet(\"Mister\", \"Dog\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mister_dog = Dog(\"Tuti\", True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mister_cat = Cat(\"Garfield\", True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function used below, **isinstance**, is a special function that checks to see if an **instance is an instance of a certain type of class**. Here we can see that __mister_pet__ is an __instance of Pet, but not Dog__, while __mister_dog is an instance of both Pet and Dog__:\n",
    "\n",
    "**Superclass(Pet)--> Subclass(Dog, Cat)**  The instances of the subclasses are instances of the superclass. Therefore, the methods of the superclass apply to the subclass but not the other way around. \n",
    "\n",
    "**Superclass(Pet)-->** The instances of the Superclass belong just to the Superclass (like mister_pet)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(mister_pet, Pet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(mister_pet, Dog)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(mister_dog, Pet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(mister_dog, Dog)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(mister_cat, Pet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(mister_cat, Cat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(mister_cat, Dog)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because __mister_pet__ is a ```Pet```, but not a ```Dog``` (in Dog class), we can’t call ```chasesCats``` on it because the ```Pet``` class has no ```chasesCats``` method. We can, however, call ```chasesCat```s on __mister_dog__, because it is defined for the ```Dog``` **class**. Conversely, we can call the ```getName``` method on both __mister_pet__ and __mister_dog__ because they are both instances of ```Pet```, even though ```getName``` is not explicitly defined in the ```Dog``` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Pet' object has no attribute 'chaseCat'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-81-2eebb934467b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmister_pet\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchaseCat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Pet' object has no attribute 'chaseCat'"
     ]
    }
   ],
   "source": [
    "mister_pet.chaseCat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mister_dog.chaseCats()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tuti'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mister_dog.getName()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Dog'"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mister_dog.getSpecies()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mister'"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mister_pet.getName()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cats and Dogs\n",
    "\n",
    "Now let’s create some cats and dogs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# True = chase cats or hate Dogs\n",
    "fido = Dog(\"Fido\", True)\n",
    "caty = Cat(\"Caty\", True)\n",
    "pulpo = Dog(\"Pulpo\", False)\n",
    "sea = Cat(\"Sea\", False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fido is a Dog\n"
     ]
    }
   ],
   "source": [
    "print fido"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Caty is a Cat , Pulpo is a Dog ' Sea is a Cat\n"
     ]
    }
   ],
   "source": [
    "print caty, \",\", pulpo, \"'\", sea "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fido chase cats: True, because is a Dog\n"
     ]
    }
   ],
   "source": [
    "print \"{0} chase cats: {1}, because is a {2}\".format(fido.getName(), fido.chaseCats(), fido.getSpecies())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Caty chase cats: True, because is a Cat\n"
     ]
    }
   ],
   "source": [
    "print \"{0} hate dogs: {1}, because is a {2}\".format(caty.getName(), caty.hatesDog(), caty.getSpecies())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pulpo hate dogs:False\n"
     ]
    }
   ],
   "source": [
    "print \"{0} hate dogs:{1}\".format(pulpo.getName(), pulpo.chaseCats(), pulpo.getSpecies())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sea chase cats:False\n"
     ]
    }
   ],
   "source": [
    "print \"{0} chase cats:{1}\".format(sea.getName(), sea.hatesDog(), sea.getSpecies())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[More exmaples](http://www.jesshamrick.com/blog/)\n",
    "\n",
    "[Jeff Knupp's Post](https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/)\n",
    "\n",
    "[Mozilla's Post](https://developer.mozilla.org/en-US/Learn/Python/Quickly_Learn_Object_Oriented_Programming)\n",
    "\n",
    "[Tutorial's Point](http://www.tutorialspoint.com/python/python_classes_objects.htm)\n",
    "\n",
    "[Official Documentation](https://docs.python.org/2/tutorial/classes.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}