22.6. Exercises

For exercises, you can expand the Tamagotchi game even further. Try these out.

Here’s all the code we just saw for our new and improved game, with a few additions. You can run this and play the game again.

1. 1. Change the above code to allow you to adopt a Tiger pet (that you’re about to create). HINT: look at the whichtype function, and think about what’s happening in the code for that function.

   2. Now, modify the code to define a new class, Tiger. The Tiger class should inherit from the Cat class, but its default meow count should be 5, not 3, and it should have an extra instance method, roar, that prints out the string ROOOOOAR!.

   3. Next, modify the code so that when the hi method is called for the Tiger class, the roar method is called. HINT: You’ll have to call one instance method inside another, and you’ll have to redefine a method for the Tiger class. See the overriding methods section.

   4. Now, modify the code to define another new class, Retriever. This class should inherit from Lab. It should be exactly like Lab, except instead of printing just I found the tennis ball! when the fetch method is called, it should say I found the tennis ball! I can fetch anything!.

   5. Add your own new pets and modifications as you like – remember, to use them in the game, you’ll also have to alter the whichtype function so they can be used in game play. Otherwise, you’ll have different classes that may work just fine, but you won’t see the effects in the game, since the code that actually makes the game play is found in the second half of the provided code (look for the while loop!).

   from random import randrange class Pet(): boredom_decrement = 4 hunger_decrement = 6 boredom_threshold = 5 hunger_threshold = 10 sounds = ['Mrrp'] def __init__(self, name = "Kitty"): self.name = name self.hunger = randrange(self.hunger_threshold) self.boredom = randrange(self.boredom_threshold) 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 def clock_tick(self): self.boredom += 1 self.hunger += 1 def mood(self): if self.hunger <= self.hunger_threshold and self.boredom <= self.boredom_threshold: return "happy" elif self.hunger > self.hunger_threshold: return "hungry" else: return "bored" def __str__(self): state = " I'm " + self.name + ". " state += " I feel " + self.mood() + ". " # state += "Hunger %d Boredom %d Words %s" % (self.hunger, self.boredom, self.sounds) return state def hi(self): print(self.sounds[randrange(len(self.sounds))]) self.reduce_boredom() def teach(self, word): self.sounds.append(word) self.reduce_boredom() def feed(self): self.reduce_hunger() def reduce_hunger(self): self.hunger = max(0, self.hunger - self.hunger_decrement) def reduce_boredom(self): self.boredom = max(0, self.boredom - self.boredom_decrement) class Dog(Pet): # in the Dog class, Dog pets should express their hunger and boredom differently than generic Pets def mood(self): if self.hunger <= self.hunger_threshold and self.boredom <= self.boredom_threshold: return "happy, arf! Happy" elif self.hunger > self.hunger_threshold: return "hungry already, arrrf" else: return "bored, so you should play with me" class Cat(Pet): # in the Cat class, cats express their hunger and boredom a little differently, too. They also have an extra instance, variable meow_count. def __init__(self, name="Fluffy", meow_count=3): Pet.__init__(self, name) self.meow_count = meow_count def hi(self): for i in range(self.meow_count): print(self.sounds[randrange(len(self.sounds))]) self.reduce_boredom() def mood(self): if self.hunger <= self.hunger_threshold and self.boredom <= self.boredom_threshold: return "happy, I suppose" elif self.hunger > self.hunger_threshold: return "mmmm...hungry" else: return "a bit bored" class Lab(Dog): def fetch(self): return "I found the tennis ball!" def hi(self): print(self.sounds[randrange(len(self.sounds))] + self.fetch()) class Poodle(Dog): def dance(self): return "Dancin' in circles like poodles do." def hi(self): print(self.dance()) Dog.hi(self) class Bird(Pet): sounds = ["chirp"] def __init__(self, name="Kitty", chirp_number=2): Pet.__init__(self, name) # call the parent class's constructor # basically, call the SUPER -- the parent version -- of the constructor, with all the parameters that it needs. self.chirp_number = chirp_number # now, also assign the new instance variable def hi(self): for i in range(self.chirp_number): print(self.sounds[randrange(len(self.sounds))]) self.reduce_boredom() def whichone(petlist, name): for pet in petlist: if pet.name == name: return pet return None # no pet matched pet_types = {'dog': Dog, 'lab': Lab, 'poodle': Poodle, 'cat': Cat, 'bird': Bird} def whichtype(adopt_type="general pet"): return pet_types.get(adopt_type.lower(), Pet) def play(): animals = [] option = "" base_prompt = """ Quit Adopt <petname_with_no_spaces> <adopt_type - choose dog, cat, lab, poodle, or another unknown pet type> Greet <petname> Teach <petname> <word> Feed <petname> Choice: """ feedback = "" while True: action = input(feedback + "\n" + base_prompt) feedback = "" words = action.split() if len(words) > 0: command = words[0] else: command = None if command == "Quit": print("Exiting...") return elif command == "Adopt" and len(words) > 1: if whichone(animals, words[1]): feedback += "You already have a pet with that name\n" else: # figure out which class it should be if len(words) > 2: Cl = whichtype(words[2]) else: Cl = Pet # Make an instance of that class and append it animals.append(Cl(words[1])) elif command == "Greet" and len(words) > 1: pet = whichone(animals, words[1]) if not pet: feedback += "I didn't recognize that pet name. Please try again.\n" print() else: pet.hi() elif command == "Teach" and len(words) > 2: pet = whichone(animals, words[1]) if not pet: feedback += "I didn't recognize that pet name. Please try again." else: pet.teach(words[2]) elif command == "Feed" and len(words) > 1: pet = whichone(animals, words[1]) if not pet: feedback += "I didn't recognize that pet name. Please try again." else: pet.feed() else: feedback+= "I didn't understand that. Please try again." for pet in animals: pet.clock_tick() feedback += "\n" + pet.__str__() import sys sys.setExecutionLimit(60000) play()

22.6.1. Contributed Exercises

If this is a homework problem instead of an example in the text then the assignment text should go here. The assignment text ends with the line containing four tilde ~

print("hello world") ==== print("Hidden code, such as unit tests come after the four = signs")

Copy and paste all the code from the wvu_inheritance_car question.

In the Car class, override the __str()__ class. The new version of the function should return the make, model, and year along with the engine size like “2015 Dodge Journey with 3.6L engine”.

For the car instance you created, set the engine_size property to the size of the car’s engine.

class Vehicle: year = None make = None model = None def __init__(self, year, make, model): self.year = year self.make = make self.model = model def __str__(self): return "{} {} {}".format(self.year, self.make, self.model) def __repr__(self): return self.__str__() def print_vehicle(self): print(self.__str__()) ====

Copy and paste all the code from the wvu_inheritance_override question.

Create a constructor (__init__()) function for the Car class. It should accept the year, make, model, and engine size as parameters. Have your function store the engine size, and then call the Vehicle class’s constructor store the year, make, and model.

Update your code to specify the engine size for your car using its constructor rather than setting it separately afterwards.

class Vehicle: year = None make = None model = None def __init__(self, year, make, model): self.year = year self.make = make self.model = model def __str__(self): return "{} {} {}".format(self.year, self.make, self.model) def __repr__(self): return self.__str__() def print_vehicle(self): print(self.__str__()) ====

Create a new class called Car that inherits from the existing Vehicle class. Add a class variable named engine_size to your new class with a value of None.

Create an instance of the new Car class to represent a car with the year, make, and model of your choice.

Use your car’s print_vehicle() method to print details about the car.

class Vehicle: year = None make = None model = None def __init__(self, year, make, model): self.year = year self.make = make self.model = model def __str__(self): return "{} {} {}".format(self.year, self.make, self.model) def __repr__(self): return self.__str__() def print_vehicle(self): print(self.__str__()) ====

Think about cases where you might want to use classes with inheritance, like if you have a generic type (beverage) and then a more specific type (pop). Write a parent class, one or more subclasses, and the variables and methods you need to represent and use your items.

====

Write a new class named Dog to inherit from the Pet class. The new class should have a class variable named breed with a default value of Unknown. Dog’s constructor must allow users to specify the dog’s name, age, and breed. To remind yourselves how a class inherits from a super class and how it invokes its constructors please see Section 22.4. To make this work you need to add at most 4-5 lines.

class Pet: name = None age = 0 def __init__(self, name, age): self.name = name self.age = age def dog_info(self): return "The pet {} is {} years old.".format(self.name, self.age) ==== from unittest.gui import TestCaseGui class myTests(TestCaseGui): def testOne(self): self.assertEqual('Test Breed', Dog(name='Test Dog', age=5, breed='Test Breed').breed, 'Constructor for class works.') self.assertIsInstance(Dog(name='Test Dog', age=5, breed='Test Breed'), Pet, 'Breed inherits properly.') myTests().main()

Q-1: Consider the classes below. Which method(s) can be called on instances of type D?

class A(object):
    def x(self):
        print("X")

class B(A):
    def y(self):
        print("Y")

class C(A):
    def x(self):
        print("x")
    def z(self):
        print("Z")

class D(B):
    def z(self):
        print("z")

• z
• D is a subclass of B, which is a subclass of A. Therefore instances of class D may use methods from class D, B, or A. This includes the methods z, y, and x (respectively).
• x and z
• D is a subclass of B, which is a subclass of A. Therefore instances of class D may use methods from class D, B, or A. This includes the methods z, y, and x (respectively).
• y and z
• D is a subclass of B, which is a subclass of A. Therefore instances of class D may use methods from class D, B, or A. This includes the methods z, y, and x (respectively).
• x, y, and z
• D is a subclass of B, which is a subclass of A. Therefore instances of class D may use methods from class D, B, or A. This includes the methods z, y, and x (respectively).

Q-1: Consider the classes below:

class A(object):
    def x(self):
        print("X")

class B(A):
    def y(self):
        print("Y")

class C(A):
    def x(self):
        print("x")
    def z(self):
        print("Z")

class D(B):
    def z(self):
        print("z")

What is the output of the following code?

my_instance = C()
my_instance.x()

• x
• C is a subclass of A. The method 'x' in class A has been overridden in class C.
• X
• C is a subclass of A. The method 'x' in class A has been overridden in class C.
• self
• C is a subclass of A. The method 'x' in class A has been overridden in class C.
• None of the above
• C is a subclass of A. The method 'x' in class A has been overridden in class C.

You have attempted of activities on this page