CS51A - Spring 2022

CS51A - Spring 2022 - Class 16

Example code in this lecture

   optional_parameters.py
   queue.py
   stack.py
   fruit.py
   rectangle3.py
   rectangle2.py

Lecture notes

administrative

optional parameters
   - In some cases, it may make sense to be able to call a function with a different number of parameters
      - if we call it with less, some of the parameters have a default value
      - if we call it with more, we can assign those values
   - we've seen a few examples of this already:
      - range(10) vs. range(1,10)
      - l = [1, 2, 3]
         - l.pop() vs l.pop(1)
   - These are called "optional parameters"
   - look at the optional function in optional_parameters.py code
      - to specify an optional parameter, you declare them like normal parameters, but give them a default value using '='
      - optional has two optional parameters, so we can call it with 1, 2, or 3 arguments

         >>> optional(10)
         10
         >>> optional(10, 2)
         12
         >>> optional(10, 2, 4)
         42

      - specifying parameters by name

         >>> optional(10, multiplier=4)
         40

classes: a "class" is the blueprint describing what data and methods an object will have

look at the Queue class in queue.py code
   - has 5 methods (constructor, str, and three other methods
   - what data does it keep, i.e. what are the instance variables?
      - just self.queue, which is a list
   - constructor
      - the constructor has an optional parameter and can be called with either zero parameters or with a list:

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

      - if it's given a list as a parameter it *copies* it using slicing (:) and saves that away in the instance variable
         - why copy it?
            - to avoid aliasing!
            - otherwise, the instance variables (self.queue) would reference the same list as was passed in (a bad thing!)

   - look at add and remove. What is this class?
      - way of storing data
         - implemented like a line
         - 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

   - 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 underneath the covers, this is still just a list
   - 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 Stack class in stack.py code
   - what does it do?
      - same basic interface as the Queue class
         - constructor and str methods
         - is_empty
         - a method to add things (sometimes called push)
         - a method to remove things (sometimes called pop)

   - the difference is that stacks add and remove things from the *same* end of the list
      - 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, if we add the same elements as we did before, we get them in the opposite order
      >>> 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 run:

      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

   - Look at Fruit class in fruit.py code

Look at the Rectangle class in rectangle3.py code
   - Another version of the Rectancle class that we saw last week
   - Like the code from rectangle2.py code, we keep track of the x,y coordinates of the lower left-hand 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 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.