Python Classes and inheritance Week 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction: Class Inheritance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Classes can “inherit” methods and class variables from other classes. We’ll see the mechanics of how this works in subsequent sections. First, however, let’s motivate why this might be valuable. It turns out that inheritance doesn’t let you do anything that you couldn’t do without it, but it makes some things a lot more elegant. You will also find it’s useful when someone else has defined a class in a module or library, and you just want to override a few things without having to reimplement everything they’ve done.\n",
    "\n",
    "Consider our Tamagotchi game. Suppose we wanted to make some different kinds of pets that have the same structure as other pets, but have some different attributes or behave a little differently. For example, suppose that dog pets should show their emotional state a little differently than cats or act differently when they are hungry or when they are asked to fetch something.\n",
    "\n",
    "You could implement this by making an instance variable for the pet type and dispatching on that instance variable in various methods.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randrange\n",
    "\n",
    "class Pet():\n",
    "    boredom_decrement = 4\n",
    "    hunger_decrement = 6\n",
    "    boredom_threshold = 5\n",
    "    hunger_threshold = 10\n",
    "    sounds = ['Mrrp']\n",
    "    def __init__(self, name = \"Kitty\", pet_type=\"dog\"):\n",
    "        self.name = name\n",
    "        self.hunger = randrange(self.hunger_threshold)\n",
    "        self.boredom = randrange(self.boredom_threshold)\n",
    "        self.sounds = self.sounds[:]  # copy the class attribute, so that when we make changes to it, we won't affect the other Pets in the class\n",
    "        self.pet_type = pet_type\n",
    "\n",
    "    def clock_tick(self):\n",
    "        self.boredom += 1\n",
    "        self.hunger += 1\n",
    "\n",
    "    def mood(self):\n",
    "        if self.hunger <= self.hunger_threshold and self.boredom <= self.boredom_threshold:\n",
    "            if self.pet_type == \"dog\": # if the pet is a dog, it will express its mood in different ways from a cat or any other type of animal\n",
    "                return \"happy\"\n",
    "            elif self.pet_type == \"cat\":\n",
    "                return \"happy, probably\"\n",
    "            else:\n",
    "                return \"HAPPY\"\n",
    "        elif self.hunger > self.hunger_threshold:\n",
    "            if self.pet_type == \"dog\": # same for hunger -- dogs and cats will express their hunger a little bit differently in this version of the class definition\n",
    "                return \"hungry, arf\"\n",
    "            elif self.pet_type == \"cat\":\n",
    "                return \"hungry, meeeeow\"\n",
    "            else:\n",
    "                return \"hungry\"\n",
    "        else:\n",
    "            return \"bored\"\n",
    "\n",
    "    def __str__(self):\n",
    "        state = \"     I'm \" + self.name + \". \"\n",
    "        state += \" I feel \" + self.mood() + \". \"\n",
    "        return state\n",
    "\n",
    "    def hi(self):\n",
    "        print(self.sounds[randrange(len(self.sounds))])\n",
    "        self.reduce_boredom()\n",
    "\n",
    "    def teach(self, word):\n",
    "        self.sounds.append(word)\n",
    "        self.reduce_boredom()\n",
    "\n",
    "    def feed(self):\n",
    "        self.reduce_hunger()\n",
    "\n",
    "    def reduce_hunger(self):\n",
    "        self.hunger = max(0, self.hunger - self.hunger_decrement)\n",
    "\n",
    "    def reduce_boredom(self):\n",
    "        self.boredom = max(0, self.boredom - self.boredom_decrement)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Inheriting Variables and Methods.\n",
    "\n",
    "from random import randrange\n",
    "\n",
    "# Here's the original Pet class\n",
    "class Pet():\n",
    "    boredom_decrement = 4\n",
    "    hunger_decrement = 6\n",
    "    boredom_threshold = 5\n",
    "    hunger_threshold = 10\n",
    "    sounds = ['Mrrp']\n",
    "    def __init__(self, name = \"Kitty\"):\n",
    "        self.name = name\n",
    "        self.hunger = randrange(self.hunger_threshold)\n",
    "        self.boredom = randrange(self.boredom_threshold)\n",
    "        self.sounds = self.sounds[:]  # copy the class attribute, so that when we make changes to it, we won't affect the other Pets in the class\n",
    "\n",
    "    def clock_tick(self):\n",
    "        self.boredom += 1\n",
    "        self.hunger += 1\n",
    "\n",
    "    def mood(self):\n",
    "        if self.hunger <= self.hunger_threshold and self.boredom <= self.boredom_threshold:\n",
    "            return \"happy\"\n",
    "        elif self.hunger > self.hunger_threshold:\n",
    "            return \"hungry\"\n",
    "        else:\n",
    "            return \"bored\"\n",
    "\n",
    "    def __str__(self):\n",
    "        state = \"     I'm \" + self.name + \". \"\n",
    "        state += \" I feel \" + self.mood() + \". \"\n",
    "        # state += \"Hunger %d Boredom %d Words %s\" % (self.hunger, self.boredom, self.sounds)\n",
    "        return state\n",
    "\n",
    "    def hi(self):\n",
    "        print(self.sounds[randrange(len(self.sounds))])\n",
    "        self.reduce_boredom()\n",
    "\n",
    "    def teach(self, word):\n",
    "        self.sounds.append(word)\n",
    "        self.reduce_boredom()\n",
    "\n",
    "    def feed(self):\n",
    "        self.reduce_hunger()\n",
    "\n",
    "    def reduce_hunger(self):\n",
    "        self.hunger = max(0, self.hunger - self.hunger_decrement)\n",
    "\n",
    "    def reduce_boredom(self):\n",
    "        self.boredom = max(0, self.boredom - self.boredom_decrement)\n",
    "\n",
    "# Here's the new definition of class Cat, a subclass of Pet.\n",
    "class Cat(Pet): # the class name that the new class inherits from goes in the parentheses, like so.\n",
    "    sounds = ['Meow']\n",
    "\n",
    "    def chasing_rats(self):\n",
    "        return \"What are you doing, Pinky? Taking over the world?!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     I'm Fido.  I feel happy. \n",
      "Mrrp\n",
      "     I'm Fido.  I feel happy. \n",
      "     I'm Fluffy.  I feel happy. \n",
      "Meow\n",
      "     I'm Fluffy.  I feel happy. \n",
      "What are you doing, Pinky? Taking over the world?!\n"
     ]
    }
   ],
   "source": [
    "p1 = Pet(\"Fido\")\n",
    "print(p1) # we've seen this stuff before!\n",
    "\n",
    "p1.feed()\n",
    "p1.hi()\n",
    "print(p1)\n",
    "\n",
    "cat1 = Cat(\"Fluffy\")\n",
    "print(cat1) # this uses the same __str__ method as the Pets do\n",
    "\n",
    "cat1.feed() # Totally fine, because the cat class inherits from the Pet class!\n",
    "cat1.hi()\n",
    "print(cat1)\n",
    "\n",
    "print(cat1.chasing_rats())\n",
    "\n",
    "#print(p1.chasing_rats()) # This line will give us an error. The Pet class doesn't have this method!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meow\n",
      "     I'm Fluffy.  I feel happy. \n",
      "What are you doing, Pinky? Taking over the world?!\n",
      "Meow\n",
      ":D :D :D\n",
      "Mrrp\n"
     ]
    }
   ],
   "source": [
    "class Cheshire(Cat): # this inherits from Cat, which inherits from Pet\n",
    "\n",
    "    def smile(self): # this method is specific to instances of Cheshire\n",
    "        print(\":D :D :D\")\n",
    "\n",
    "# Let's try it with instances.\n",
    "cat1 = Cat(\"Fluffy\")\n",
    "cat1.feed() # Totally fine, because the cat class inherits from the Pet class!\n",
    "cat1.hi() # Uses the special Cat hello.\n",
    "print(cat1)\n",
    "\n",
    "print(cat1.chasing_rats())\n",
    "\n",
    "new_cat = Cheshire(\"Pumpkin\") # create a Cheshire cat instance with name \"Pumpkin\"\n",
    "new_cat.hi() # same as Cat!\n",
    "new_cat.chasing_rats() # OK, because Cheshire inherits from Cat\n",
    "new_cat.smile() # Only for Cheshire instances (and any classes that you make inherit from Cheshire)\n",
    "\n",
    "# cat1.smile() # This line would give you an error, because the Cat class does not have this method!\n",
    "\n",
    "# None of the subclass methods can be used on the parent class, though.\n",
    "p1 = Pet(\"Teddy\")\n",
    "p1.hi() # just the regular Pet hello\n",
    "#p1.chasing_rats() # This will give you an error -- this method doesn't exist on instances of the Pet class.\n",
    "#p1.smile() # This will give you an error, too. This method does not exist on instances of the Pet class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We are Siamese if you please. We are Siamese if you don’t please.\n"
     ]
    }
   ],
   "source": [
    "new_cat = Cheshire(\"Pumpkin\")\n",
    "class Siamese(Cat):\n",
    "    def song(self):\n",
    "        print(\"We are Siamese if you please. We are Siamese if you don’t please.\")\n",
    "another_cat = Siamese(\"Lady\")\n",
    "another_cat.song()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "Alice Smith (29)\n",
      "29\n"
     ]
    }
   ],
   "source": [
    "CURRENT_YEAR = 2019\n",
    "class Person:\n",
    "    def __init__(self, name, year_born):\n",
    "        self.name = name\n",
    "        self.year_born = year_born\n",
    "    def getAge(self):\n",
    "        return CURRENT_YEAR - self.year_born\n",
    "    def __str__(self):\n",
    "        return '{} ({})'.format(self.name, self.getAge())\n",
    "\n",
    "class Student(Person):\n",
    "    def __init__(self, name, year_born):\n",
    "        Person.__init__(self, name, year_born)\n",
    "        self.knowledge = 0\n",
    "    def study(self):\n",
    "        self.knowledge += 1\n",
    "        \n",
    "\n",
    "alice = Student('Alice Smith', 1990)\n",
    "alice.study()\n",
    "print(alice.knowledge)\n",
    "print(alice)\n",
    "print(alice.getAge())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "500\n",
      "Library : 2\n"
     ]
    }
   ],
   "source": [
    "                                    # Overriding Methods\n",
    "\n",
    "class Book():\n",
    "    def __init__(self, title, author):\n",
    "        self.title = title\n",
    "        self.author = author\n",
    "        \n",
    "    def __str__(self):\n",
    "        return '\"{}\" by {}'.format(self.title, self.author)\n",
    "\n",
    "class PaperBook(Book):\n",
    "    def __init__(self, title, author, numPages):\n",
    "        Book.__init__(self, title, author)\n",
    "        self.numPages = numPages\n",
    "        \n",
    "class EBook(Book):\n",
    "    def __init__(self, title, author, size):\n",
    "        Book.__init__(self, title, author)\n",
    "        self.size = size\n",
    "\n",
    "class Library:\n",
    "    def __init__(self):\n",
    "        self.books = []\n",
    "    def addBook(self, book):\n",
    "        self.books.append(book)\n",
    "    def getNumBooks(self):\n",
    "        return len(self.books)\n",
    "        \n",
    "myBook = EBook('The Odyssey', 'Homer', 2)\n",
    "myPaperBook = PaperBook('The Odyssey', 'Homer', 500)\n",
    "print(myBook.size)\n",
    "print(myPaperBok.numPages)\n",
    "\n",
    "aadl =Library()\n",
    "aadl.addBook(myBook)\n",
    "aadl.addBook(myPaperBook)\n",
    "\n",
    "print(\"Library :\",aadl.getNumBooks())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randrange\n",
    "\n",
    "# Here's the original Pet class\n",
    "class Pet():\n",
    "    boredom_decrement = 4\n",
    "    hunger_decrement = 6\n",
    "    boredom_threshold = 5\n",
    "    hunger_threshold = 10\n",
    "    sounds = ['Mrrp']\n",
    "    def __init__(self, name = \"Kitty\"):\n",
    "        self.name = name\n",
    "        self.hunger = randrange(self.hunger_threshold)\n",
    "        self.boredom = randrange(self.boredom_threshold)\n",
    "        self.sounds = self.sounds[:]  # copy the class attribute, so that when we make changes to it, we won't affect the other Pets in the class\n",
    "\n",
    "    def clock_tick(self):\n",
    "        self.boredom += 1\n",
    "        self.hunger += 1\n",
    "\n",
    "    def mood(self):\n",
    "        if self.hunger <= self.hunger_threshold and self.boredom <= self.boredom_threshold:\n",
    "            return \"happy\"\n",
    "        elif self.hunger > self.hunger_threshold:\n",
    "            return \"hungry\"\n",
    "        else:\n",
    "            return \"bored\"\n",
    "\n",
    "    def __str__(self):\n",
    "        state = \"     I'm \" + self.name + \". \"\n",
    "        state += \" I feel \" + self.mood() + \". \"\n",
    "        # state += \"Hunger %d Boredom %d Words %s\" % (self.hunger, self.boredom, self.sounds)\n",
    "        return state\n",
    "\n",
    "    def hi(self):\n",
    "        print(self.sounds[randrange(len(self.sounds))])\n",
    "        self.reduce_boredom()\n",
    "\n",
    "    def teach(self, word):\n",
    "        self.sounds.append(word)\n",
    "        self.reduce_boredom()\n",
    "\n",
    "    def feed(self):\n",
    "        self.reduce_hunger()\n",
    "\n",
    "    def reduce_hunger(self):\n",
    "        self.hunger = max(0, self.hunger - self.hunger_decrement)\n",
    "\n",
    "    def reduce_boredom(self):\n",
    "        self.boredom = max(0, self.boredom - self.boredom_decrement)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "grumpy; leave me alone\n",
      "randomly annoyed\n",
      "happy\n",
      "happy\n",
      "randomly annoyed\n",
      "randomly annoyed\n",
      "randomly annoyed\n",
      "happy\n",
      "randomly annoyed\n",
      "happy\n",
      "randomly annoyed\n",
      "happy\n"
     ]
    }
   ],
   "source": [
    "class Cat(Pet):\n",
    "    sounds = ['Meow']\n",
    "\n",
    "    def mood(self):\n",
    "        if self.hunger > self.hunger_threshold:\n",
    "            return \"hungry\"\n",
    "        if self.boredom <2:\n",
    "            return \"grumpy; leave me alone\"\n",
    "        elif self.boredom > self.boredom_threshold:\n",
    "            return \"bored\"\n",
    "        elif randrange(2) == 0:\n",
    "            return \"randomly annoyed\"\n",
    "        else:\n",
    "            return \"happy\"\n",
    "\n",
    "class Dog(Pet):\n",
    "    sounds = ['Woof', 'Ruff']\n",
    "\n",
    "    def mood(self):\n",
    "        if (self.hunger > self.hunger_threshold) and (self.boredom > self.boredom_threshold):\n",
    "            return \"bored and hungry\"\n",
    "        else:\n",
    "            return \"happy\"\n",
    "\n",
    "c1 = Cat(\"Fluffy\")\n",
    "d1 = Dog(\"Astro\")\n",
    "\n",
    "c1.boredom = 1\n",
    "print(c1.mood())\n",
    "c1.boredom = 3\n",
    "for i in range(10):\n",
    "    print(c1.mood())\n",
    "print(d1.mood())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randrange\n",
    "\n",
    "# Here's the original Pet class\n",
    "class Pet():\n",
    "    boredom_decrement = 4\n",
    "    hunger_decrement = 6\n",
    "    boredom_threshold = 5\n",
    "    hunger_threshold = 10\n",
    "    sounds = ['Mrrp']\n",
    "    def __init__(self, name = \"Kitty\"):\n",
    "        self.name = name\n",
    "        self.hunger = randrange(self.hunger_threshold)\n",
    "        self.boredom = randrange(self.boredom_threshold)\n",
    "        self.sounds = self.sounds[:]  # copy the class attribute, so that when we make changes to it, we won't affect the other Pets in the class\n",
    "\n",
    "    def clock_tick(self):\n",
    "        self.boredom += 1\n",
    "        self.hunger += 1\n",
    "\n",
    "    def mood(self):\n",
    "        if self.hunger <= self.hunger_threshold and self.boredom <= self.boredom_threshold:\n",
    "            return \"happy\"\n",
    "        elif self.hunger > self.hunger_threshold:\n",
    "            return \"hungry\"\n",
    "        else:\n",
    "            return \"bored\"\n",
    "\n",
    "    def __str__(self):\n",
    "        state = \"     I'm \" + self.name + \". \"\n",
    "        state += \" I feel \" + self.mood() + \". \"\n",
    "        # state += \"Hunger %d Boredom %d Words %s\" % (self.hunger, self.boredom, self.sounds)\n",
    "        return state\n",
    "\n",
    "    def hi(self):\n",
    "        print(self.sounds[randrange(len(self.sounds))])\n",
    "        self.reduce_boredom()\n",
    "\n",
    "    def teach(self, word):\n",
    "        self.sounds.append(word)\n",
    "        self.reduce_boredom()\n",
    "\n",
    "    def feed(self):\n",
    "        self.reduce_hunger()\n",
    "\n",
    "    def reduce_hunger(self):\n",
    "        self.hunger = max(0, self.hunger - self.hunger_decrement)\n",
    "\n",
    "    def reduce_boredom(self):\n",
    "        self.boredom = max(0, self.boredom - self.boredom_decrement)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Arf! Thanks!\n"
     ]
    }
   ],
   "source": [
    "from random import randrange\n",
    "\n",
    "class Dog(Pet):\n",
    "    sounds = ['Woof', 'Ruff']\n",
    "\n",
    "    def feed(self):\n",
    "        Pet.feed(self)\n",
    "        print(\"Arf! Thanks!\")\n",
    "\n",
    "d1 = Dog(\"Astro\")\n",
    "\n",
    "d1.feed()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "chirp\n",
      "chirp\n",
      "Polly wanna cracker\n",
      "Polly wanna cracker\n",
      "chirp\n"
     ]
    }
   ],
   "source": [
    "class Bird(Pet):\n",
    "    sounds = [\"chirp\"]\n",
    "    def __init__(self, name=\"Kitty\", chirp_number=2):\n",
    "        Pet.__init__(self, name) # call the parent class's constructor\n",
    "        # basically, call the SUPER -- the parent version -- of the constructor, with all the parameters that it needs.\n",
    "        self.chirp_number = chirp_number # now, also assign the new instance variable\n",
    "\n",
    "    def hi(self):\n",
    "        for i in range(self.chirp_number):\n",
    "            print(self.sounds[randrange(len(self.sounds))])\n",
    "        self.reduce_boredom()\n",
    "\n",
    "b1 = Bird('tweety', 5)\n",
    "b1.teach(\"Polly wanna cracker\")\n",
    "b1.hi()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\" style=\"color: red\">Tamagotchi Revisited</h1>\n",
    "Using what we know about class inheritance, we can make a new version of the Tamagotchi game, where you can adopt different types of pets that are slightly different from one another.\n",
    "\n",
    "And now we can play the Tamagotchi game with some small changes, such that we can adopt different types of pets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "        Quit\n",
      "        Adopt <petname_with_no_spaces> <pet_type - choose dog, cat, lab, poodle, bird, or another unknown pet type>\n",
      "        Greet <petname>\n",
      "        Teach <petname> <word>\n",
      "        Feed <petname>\n",
      "\n",
      "        Choice: Adopt TOm\n",
      "\n",
      "     I'm TOm.  I feel happy. \n",
      "\n",
      "        Quit\n",
      "        Adopt <petname_with_no_spaces> <pet_type - choose dog, cat, lab, poodle, bird, or another unknown pet type>\n",
      "        Greet <petname>\n",
      "        Teach <petname> <word>\n",
      "        Feed <petname>\n",
      "\n",
      "        Choice: Quit\n",
      "Exiting...\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "sys.setrecursionlimit(600000)\n",
    "# sys.setExecutionLimit(60000)\n",
    "from random import randrange\n",
    "\n",
    "class Pet(object):\n",
    "    boredom_decrement = 4\n",
    "    hunger_decrement = 6\n",
    "    boredom_threshold = 5\n",
    "    hunger_threshold = 10\n",
    "    sounds = ['Mrrp']\n",
    "    def __init__(self, name = \"Kitty\"):\n",
    "        self.name = name\n",
    "        self.hunger = randrange(self.hunger_threshold)\n",
    "        self.boredom = randrange(self.boredom_threshold)\n",
    "        self.sounds = self.sounds[:]  # copy the class attribute, so that when we make changes to it, we won't affect the other Pets in the class\n",
    "\n",
    "    def clock_tick(self):\n",
    "        self.boredom += 1\n",
    "        self.hunger += 1\n",
    "\n",
    "    def mood(self):\n",
    "        if self.hunger <= self.hunger_threshold and self.boredom <= self.boredom_threshold:\n",
    "            return \"happy\"\n",
    "        elif self.hunger > self.hunger_threshold:\n",
    "            return \"hungry\"\n",
    "        else:\n",
    "            return \"bored\"\n",
    "\n",
    "    def __str__(self):\n",
    "        state = \"     I'm \" + self.name + \". \"\n",
    "        state += \" I feel \" + self.mood() + \". \"\n",
    "        # state += \"Hunger %d Boredom %d Words %s\" % (self.hunger, self.boredom, self.sounds)\n",
    "        return state\n",
    "\n",
    "    def hi(self):\n",
    "        print(self.sounds[randrange(len(self.sounds))])\n",
    "        self.update_boredom()\n",
    "\n",
    "    def teach(self, word):\n",
    "        self.sounds.append(word)\n",
    "        self.update_boredom()\n",
    "\n",
    "    def feed(self):\n",
    "        self.update_hunger()\n",
    "\n",
    "    def update_hunger(self):\n",
    "        self.hunger = max(0, self.hunger - self.hunger_decrement)\n",
    "\n",
    "    def update_boredom(self):\n",
    "        self.boredom = max(0, self.boredom - self.boredom_decrement)\n",
    "\n",
    "class Cat(Pet):\n",
    "    sounds = ['Meow']\n",
    "\n",
    "    def mood(self):\n",
    "        if self.hunger > self.hunger_threshold:\n",
    "            return \"hungry\"\n",
    "        if self.boredom <2:\n",
    "            return \"grumpy; leave me alone\"\n",
    "        elif self.boredom > self.boredom_threshold:\n",
    "            return \"bored\"\n",
    "        elif randrange(2) == 0:\n",
    "            return \"randomly annoyed\"\n",
    "        else:\n",
    "            return \"happy\"\n",
    "\n",
    "class Dog(Pet):\n",
    "    sounds = ['Woof', 'Ruff']\n",
    "\n",
    "    def mood(self):\n",
    "        if (self.hunger > self.hunger_threshold) and (self.boredom > self.boredom_threshold):\n",
    "            return \"bored and hungry\"\n",
    "        else:\n",
    "            return \"happy\"\n",
    "\n",
    "    def feed(self):\n",
    "        Pet.feed(self)\n",
    "        print(\"Arf! Thanks!\")\n",
    "\n",
    "class Bird(Pet):\n",
    "    sounds = [\"chirp\"]\n",
    "    def __init__(self, name=\"Kitty\", chirp_number=2):\n",
    "        Pet.__init__(self, name) # call the parent class's constructor\n",
    "        # basically, call the SUPER -- the parent version -- of the constructor, with all the parameters that it needs.\n",
    "        self.chirp_number = chirp_number # now, also assign the new instance variable\n",
    "\n",
    "    def hi(self):\n",
    "        for i in range(self.chirp_number):\n",
    "            print(self.sounds[randrange(len(self.sounds))])\n",
    "        self.update_boredom()\n",
    "\n",
    "class Lab(Dog):\n",
    "    def fetch(self):\n",
    "        return \"I found the tennis ball!\"\n",
    "\n",
    "    def hi(self):\n",
    "        print(self.fetch())\n",
    "        print(self.sounds[randrange(len(self.sounds))])\n",
    "\n",
    "class Poodle(Dog):\n",
    "    def dance(self):\n",
    "        return \"Dancin' in circles like poodles do.\"\n",
    "\n",
    "    def hi(self):\n",
    "        print(self.dance())\n",
    "        Dog.hi(self)\n",
    "\n",
    "def whichone(petlist, name):\n",
    "    for pet in petlist:\n",
    "        if pet.name == name:\n",
    "            return pet\n",
    "    return None # no pet matched\n",
    "\n",
    "pet_types = {'dog': Dog, 'lab': Lab, 'poodle': Poodle, 'cat': Cat, 'bird': Bird}\n",
    "def whichtype(adopt_type=\"general pet\"):\n",
    "    return pet_types.get(adopt_type.lower(), Pet)\n",
    "\n",
    "def play():\n",
    "    animals = []\n",
    "\n",
    "    option = \"\"\n",
    "    base_prompt = \"\"\"\n",
    "        Quit\n",
    "        Adopt <petname_with_no_spaces> <pet_type - choose dog, cat, lab, poodle, bird, or another unknown pet type>\n",
    "        Greet <petname>\n",
    "        Teach <petname> <word>\n",
    "        Feed <petname>\n",
    "\n",
    "        Choice: \"\"\"\n",
    "    feedback = \"\"\n",
    "    while True:\n",
    "        action = input(feedback + \"\\n\" + base_prompt)\n",
    "        feedback = \"\"\n",
    "        words = action.split()\n",
    "        if len(words) > 0:\n",
    "            command = words[0]\n",
    "        else:\n",
    "            command = None\n",
    "        if command == \"Quit\":\n",
    "            print(\"Exiting...\")\n",
    "            return\n",
    "        elif command == \"Adopt\" and len(words) > 1:\n",
    "            if whichone(animals, words[1]):\n",
    "                feedback += \"You already have a pet with that name\\n\"\n",
    "            else:\n",
    "                # figure out which class it should be\n",
    "                if len(words) > 2:\n",
    "                    Cl = whichtype(words[2])\n",
    "                else:\n",
    "                    Cl = Pet\n",
    "                # Make an instance of that class and append it\n",
    "                animals.append(Cl(words[1]))\n",
    "        elif command == \"Greet\" and len(words) > 1:\n",
    "            pet = whichone(animals, words[1])\n",
    "            if not pet:\n",
    "                feedback += \"I didn't recognize that pet name. Please try again.\\n\"\n",
    "                print()\n",
    "            else:\n",
    "                pet.hi()\n",
    "        elif command == \"Teach\" and len(words) > 2:\n",
    "            pet = whichone(animals, words[1])\n",
    "            if not pet:\n",
    "                feedback += \"I didn't recognize that pet name. Please try again.\"\n",
    "            else:\n",
    "                pet.teach(words[2])\n",
    "        elif command == \"Feed\" and len(words) > 1:\n",
    "            pet = whichone(animals, words[1])\n",
    "            if not pet:\n",
    "                feedback += \"I didn't recognize that pet name. Please try again.\"\n",
    "            else:\n",
    "                pet.feed()\n",
    "        else:\n",
    "            feedback+= \"I didn't understand that. Please try again.\"\n",
    "\n",
    "        for pet in animals:\n",
    "            pet.clock_tick()\n",
    "            feedback += \"\\n\" + pet.__str__()\n",
    "\n",
    "play()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.2 64-bit",
   "language": "python",
   "name": "python38264bitfaf40753a0cb4fcaa4c2c4a2ac090f23"
  },
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}