7. Exercises¶

We can represent a rectangle by knowing three things: the location of its lower left corner, its width, and its height. Create a class definition for a Rectangle class using this idea. For instance, to create a Rectangle object at location (4,5) with width 6 and height 5, we would do the following:
loc = Point(4, 5) r = Rectangle(loc, 6, 5)
class Point: def __init__(self, init_x, init_y): """ Create a new point at the given coordinates. """ self.x = init_x self.y = init_y def get_x(self): return self.x def get_y(self): return self.y def distance_from_origin(self): return ((self.x ** 2) + (self.y ** 2)) ** 0.5 def __repr__(self): return "x=" + str(self.x) + ", y=" + str(self.y)
class Point: def __init__(self, init_x, init_y): """ Create a new point at the given coordinates. """ self.x = init_x self.y = init_y def get_x(self): return self.x def get_y(self): return self.y def distance_from_origin(self): return ((self.x ** 2) + (self.y ** 2)) ** 0.5 def __repr__(self): return "x=" + str(self.x) + ", y=" + str(self.y) class Rectangle: """Rectangle class using Point, width and height""" def __init__(self, init_p, init_w, init_h): self.location = init_p self.width = init_w self.height = init_h def __repr__(self): return "I'm a rectangle with width {} and height {}".format(self.width, self.height) def main(): loc = Point(4, 5) r = Rectangle(loc, 6, 5) print(r) if __name__ == "__main__": main()
Add the following accessor methods to the Rectangle class: get_width and get_height.
class Point: def __init__(self, init_x, init_y): """ Create a new point at the given coordinates. """ self.x = init_x self.y = init_y def get_x(self): return self.x def get_y(self): return self.y def distance_from_origin(self): return ((self.x ** 2) + (self.y ** 2)) ** 0.5 def __repr__(self): return "x=" + str(self.x) + ", y=" + str(self.y)
Add a method area to the Rectangle class that returns the area of any instance:
r = Rectangle(Point(0, 0), 10, 5) testEqual(r.area(), 50)
class Point: def __init__(self, init_x, init_y): """ Create a new point at the given coordinates. """ self.x = init_x self.y = init_y def get_x(self): return self.x def get_y(self): return self.y def distance_from_origin(self): return ((self.x ** 2) + (self.y ** 2)) ** 0.5 def __repr__(self): return "x=" + str(self.x) + ", y=" + str(self.y) from test import testEqual r = Rectangle(Point(0, 0), 10, 5) testEqual(r.area(), 50)
from test import testEqual class Point: def __init__(self, init_x, init_y): """ Create a new point at the given coordinates. """ self.x = init_x self.y = init_y def get_x(self): return self.x def get_y(self): return self.y def distance_from_origin(self): return ((self.x ** 2) + (self.y ** 2)) ** 0.5 def __repr__(self): return "x=" + str(self.x) + ", y=" + str(self.y) class Rectangle: """Rectangle class using Point, width and height""" def __init__(self, init_p, init_w, init_h): self.location = init_p self.width = init_w self.height = init_h def __repr__(self): return "I'm a rectangle with width {} and height {}".format(self.width, self.height) def area(self): return self.width * self.height r = Rectangle(Point(0, 0), 10, 5) testEqual(r.area(), 50) r1 = Rectangle(Point(0,0), 4, 5) testEqual(r1.area(), 20) r2 = Rectangle(Point(0,0), 12, 3) testEqual(r2.area(), 36)
Write a perimeter method in the Rectangle class so that we can find the perimeter of any rectangle instance:
```
r = Rectangle(Point(0, 0), 10, 5)
testEqual(r.perimeter(), 30)
```
class Point: def __init__(self, init_x, init_y): """ Create a new point at the given coordinates. """ self.x = init_x self.y = init_y def get_x(self): return self.x def get_y(self): return self.y def distance_from_origin(self): return ((self.x ** 2) + (self.y ** 2)) ** 0.5 def __repr__(self): return "x=" + str(self.x) + ", y=" + str(self.y) from test import testEqual r = Rectangle(Point(0, 0), 10, 5) testEqual(r.perimeter(), 30)
Write a transpose method in the Rectangle class that swaps the width and the height of any rectangle instance:
r = Rectangle(Point(100, 50), 10, 5) testEqual(r.width, 10) testEqual(r.height, 5) r.transpose() testEqual(r.width, 5) testEqual(r.height, 10)
class Point: def __init__(self, init_x, init_y): """ Create a new point at the given coordinates. """ self.x = init_x self.y = init_y def get_x(self): return self.x def get_y(self): return self.y def distance_from_origin(self): return ((self.x ** 2) + (self.y ** 2)) ** 0.5 def __repr__(self): return "x=" + str(self.x) + ", y=" + str(self.y) from test import testEqual r = Rectangle(Point(100, 50), 10, 5) testEqual(r.width, 10) testEqual(r.height, 5) r.transpose() testEqual(r.width, 5) testEqual(r.height, 10)
from test import testEqual class Point: def __init__(self, init_x, init_y): """ Create a new point at the given coordinates. """ self.x = init_x self.y = init_y def get_x(self): return self.x def get_y(self): return self.y def distance_from_origin(self): return ((self.x ** 2) + (self.y ** 2)) ** 0.5 def __repr__(self): return "x=" + str(self.x) + ", y=" + str(self.y) class Rectangle: """Rectangle class using Point, width and height""" def __init__(self, init_p, init_w, init_h): self.location = init_p self.width = init_w self.height = init_h def __repr__(self): return "I'm a rectangle with width {} and height {}".format(self.width, self.height) def transpose(self): temp = self.width self.width = self.height self.height = temp r = Rectangle(Point(100, 50), 10, 5) testEqual(r.width, 10) testEqual(r.height, 5) r.transpose() testEqual(r.width, 5) testEqual(r.height, 10)
Write a new method called contains in the Rectangle class to test if a Point falls within the rectangle. For this exercise, assume that a rectangle at (0,0) with width 10 and height 5 has open upper bounds on the width and height, i.e. it stretches in the x direction from [0 to 10), where 0 is included but 10 is excluded, and from [0 to 5) in the y direction. So it does not contain the point (10, 2). These tests should pass:
```
r = Rectangle(Point(0, 0), 10, 5)
testEqual(r.contains(Point(0, 0)), True)
testEqual(r.contains(Point(3, 3)), True)
testEqual(r.contains(Point(3, 7)), False)
testEqual(r.contains(Point(3, 5)), False)
testEqual(r.contains(Point(3, 4.99999)), True)
testEqual(r.contains(Point(-3, -3)), False)
```
from test import testEqual class Point: def __init__(self, init_x, init_y): """ Create a new point at the given coordinates. """ self.x = init_x self.y = init_y def get_x(self): return self.x def get_y(self): return self.y def distance_from_origin(self): return ((self.x ** 2) + (self.y ** 2)) ** 0.5 def __repr__(self): return "x=" + str(self.x) + ", y=" + str(self.y) r = Rectangle(Point(0, 0), 10, 5) testEqual(r.contains(Point(0, 0)), True) testEqual(r.contains(Point(3, 3)), True) testEqual(r.contains(Point(3, 7)), False) testEqual(r.contains(Point(3, 5)), False) testEqual(r.contains(Point(3, 4.99999)), True) testEqual(r.contains(Point(-3, -3)), False)
Write a new method called diagonal that will return the length of the diagonal that runs from the lower left corner to the opposite corner.
class Point: def __init__(self, init_x, init_y): """ Create a new point at the given coordinates. """ self.x = init_x self.y = init_y def get_x(self): return self.x def get_y(self): return self.y def distance_from_origin(self): return ((self.x ** 2) + (self.y ** 2)) ** 0.5 def __repr__(self): return "x=" + str(self.x) + ", y=" + str(self.y) from test import testEqual r = Rectangle(Point(0, 0), 10, 5) testEqual(r.diagonal(), 11.1803398875) r1 = Rectangle(Point(0,0), 12, 4) testEqual(r1.diagonal(), 12.6491106407) r2 = Rectangle(Point(0,0), 1,2) testEqual(r2.diagonal(), 2.2360679775)
from test import testEqual class Point: def __init__(self, init_x, init_y): """ Create a new point at the given coordinates. """ self.x = init_x self.y = init_y def get_x(self): return self.x def get_y(self): return self.y def distance_from_origin(self): return ((self.x ** 2) + (self.y ** 2)) ** 0.5 def __repr__(self): return "x=" + str(self.x) + ", y=" + str(self.y) class Rectangle: """Rectangle class using Point, width and height""" def __init__(self, init_p, init_w, init_h): self.location = init_p self.width = init_w self.height = init_h def __repr__(self): return "I'm a rectangle with width {} and height {}".format(self.width, self.height) def diagonal(self): d = (self.width ** 2 + self.height ** 2) ** 0.5 return d r = Rectangle(Point(0, 0), 10, 5) testEqual(r.diagonal(), 11.1803398875) r1 = Rectangle(Point(0,0), 12, 4) testEqual(r1.diagonal(), 12.6491106407) r2 = Rectangle(Point(0,0), 1,2) testEqual(r2.diagonal(), 2.2360679775)
There are some games where we put a rectangular “bounding box” around our sprites in the game. We can then do collision detection between, say, bombs and spaceships, by comparing whether their rectangles overlap anywhere.

Write a function to determine whether two rectangles collide. Hint: this might be quite a tough exercise! Think carefully about all the cases as you code.

Graded Lesson Assignment¶

The code below contains a Chatbot class. A Chatbot is an object that can engage in rudimentary conversation with a human. You will be asked to define a subclass that inherits from this Chatbot superclass.

First, run the code below to talk to the chatbot. Then look over the code to make sure you understand it.

Your job is to make a subclass called BoredChatbot that inherits from Chatbot, but acts a little differently, in the following way:

A bored chatbot has a short attention span. When the human says something that is longer than 20 characters, it should respond by saying:

“zzz... Oh excuse me, I dozed off reading your essay.”
If, on the other hand, the human says something with a length of 20 characters or less, then the bored chatbot should respond just like a normal chatbot would.

Note that we are requiring you to use inheritance. Your new BoredChatbot class must be a subclass of the Chatbot class, and your subclass should only implement the things that make it distinct. (See the Inheritance chapter for a review of how this works.)

When you think your code is correct, test it yourself by creating a few different instances and printing their responses to various inputs.