Week 9: Classes and Object-Orientation

• Chapter 10.10–10.13
• Chapter 17

• Chapter 18

Objects encapsulate state and behavior; the underlying metaphor is that the program is built up out of tiny computers that communicate with each other along well-defined interfaces, and no object needs to (nor can) know anything about the internal state and behavior of any other. This style of program design is called "object orientation"; for a while it was seen as an unalloyed good, and nowadays it is considered one reasonable approach among several. It's pervasive in Python and Java, so we will explore it this week in 51a.

For example, a list is an object with methods like append and reverse:

>>> l = [1, 2, 3, 4]
>>> l.append(5)
>>> l
[1, 2, 3, 4, 5]
>>> l.reverse()
>>> l
[5, 4, 3, 2, 1]

The most important thing to remember about code is from Abelson and Sussman's Structure and Interpretation of Computer Programs: "Programs must be written for people to read, and only incidentally for computers to execute." What do you think this means?

It's easy to get bogged down in making your program fast, or to make it work in a very mechanistic way where the flow of control is difficult for people to understand. Objects can help us with that in two main ways: like modules, they serve as a way to organize functionality so it's easy to know where to find it (operations on strings live in the str class); they also hide details of how operations are implemented, so we can send the same message to multiple different types of objects without worrying how they're implemented (or use an object with behavior and state without knowing what variables are packaged up inside of it). You've been using for example lists, strings, and dictionaries in exactly these ways all along!

Look at the Queue class in queue.py.

• How many methods does it have and what do they do? How many parameters do you need to instantiate a Queue?

  >>> q = Queue()
  >>> print(q)
  The queue contains: []
  >>> q = Queue([1, 2, 3, 4])
  >>> print(q)
  The queue contains: [1, 2, 3, 4]
  

  • What would this code print out? Why?

    >>> l = [1,2,3]
    >>> q = Queue(l)
    >>> l.append(4)
    >>> print(q)
    

• Look at the add and remove methods. What is this class for?
  • It's just a way of storing data
    • A "queue" in the sense of a line at the grocery store
    • first things to be added are the first things to be removed
    • sometimes called FIFO (first in first out)
  • add adds elements to the back of the list
  • remove removes elements from the front of the list
  • If we only get elements out using remove, and only add them using add, then we can only use this in that oldest-to-newest order.

• Example usage:

  >>> q = Queue()
  >>> q.add(1)
  >>> q.add(10)
  >>> q.add(2)
  >>> print(q)
  The queue contains: [1, 10, 2]
  >>> q.remove()
  1
  >>> q.remove()
  10
  >>> q.remove()
  2
  

• is_empty
  • just checks if the queue has anything in it
• notice that internally, this is still just a list
  • We get to use Python's well-tested and efficient list collection….
  • But by hiding the list in the class, we have:
    • provided a clear small set of methods that defines how we can interact with the object (the queue)
    • hid the implementation details from whoever uses it
      • we used a list, but could have used something else
      • in a similar way, we could have added to the front of the list and removed from the back and still achieved exactly the same functionality

Look at the Stack class in stack.py.

• How many methods does it have and what do they do? How is this similar to and different from Queue?
  • Stacks add and remove things from the same end of the list.
• In a stack, we tend to use the names push and pop for add and remove.
  • think of it like a stack of plates
    • the last plate that you put on top
    • will be the first one to be removed
    • sometimes called LIFO (last in first out)

• For example:

  >>> s = Stack()
  >>> s.add(1)
  >>> s.add(10)
  >>> s.add(2)
  >>> s.remove()
  2
  >>> s.remove()
  10
  >>> s.remove()
  1
  

We're going to design a Fruit class. It will have the following constructor and methods:

def __init__(self, name, color):
    self.name = name
    self.color = color
    self.eaten = False
    self.age = 0

• is_eaten takes zero arguments and returns a boolean indicating whether or not the fruit is eaten
• eat takes zero arguments and "eats" the fruit
• allergy_check takes a color and returns true if the fruits color is the same as the input color, false otherwise
• age_fruit takes zero arguments and ages the fruit by a day
• __str__ prints out a string version of the fruit

• For example, if we ran:

  fruit = Fruit("banana", "yellow")
  print(fruit)
  print(fruit.allergy_check("red"))
  fruit.age_fruit()
  print(fruit)
  print(fruit.is_eaten())
  fruit.eat()
  print(fruit.is_eaten())
  

  • We would get:

    yellow banana that is 0 days old
    False
    yellow banana that is 1 days old
    False
    True
    

• When you're done, check your version against fruit.py.

• Look at the Rectangle class in rectangle3.py
  • Another version of the Rectangle class that we saw earlier
  • Like in rectangle2.py, we keep track of the x,y coordinates of the top-left corner and the width and height

• If we print out the rectangle we see the position of the rectangle and the area:

  >>> r = Rectangle(0, 0, 10, 20)
  >>> print(r)
  >>> Rectangle at (0, 0) with area: 200
  

  • In the __str__ method, we call the area method
• Anytime you want to call another method from within the class you write self.method_name, e.g. self.area()
  • The equals method takes one parameter as input. What is the parameter?
    • Another rectangle!
    • equals is a method we wrote that takes one parameter, another rectangle, as input
    • in the body of the method then there are two rectangles:
    • self
    • another_rectangle
    • We can access the instance variables of the parameter rectangle (another_rectangle) in the same way we can self.