Discussion 10: Classes & Inheritance🖨️
Attendance
Your TA will come around during discussion to check you in. You can start on the worksheet before being checked in; you don't need to wait for your TA to get started.
If you didn't attend for a good reason (such as being sick), fill out this form (within 2 weeks of your discussion): attendance form
Getting Started
Say your name and share a favorite place on the Berkeley campus or surrounding city that you've discovered. Try to pick a place that others might not have been yet. (But if the room you're in now is your favorite place on campus, that's ok too.)
Hint
McCone Hall has a nice view from the 5th floor balcony.
Classes
Q1: Keyboard
Overview: A keyboard has a button for every letter of the alphabet. When a
button is pressed, it outputs its letter by calling an output function (such
as print). Whether that letter is uppercase or lowercase depends on how many
times the caps lock key has been pressed.
First, implement the Button class, which takes a lowercase letter (a
string) and a one-argument output function, such as Button('c', print).
The press method of a Button calls its output attribute (a function) on
its letter attribute: either uppercase if caps_lock has been pressed an odd
number of times or lowercase otherwise. The press method also increments
pressed and returns the button that was pressed. Hint: 'hi'.upper()
evaluates to 'HI'.
Second, implement the Keyboard class. A Keyboard has a dictionary called
keys containing a Button (with its letter as its key) for each letter in
LOWERCASE_LETTERS. It also has a list of the letters typed, which may be a
mix of uppercase and lowercase letters.
The type method takes a string word containing only lowercase letters. It
invokes the press method of the Button in keys for each letter in word,
which adds a letter (either lowercase or uppercase depending on caps_lock) to
the Keyboard's typed list. Important: Do not use upper or letter in
your implementation of type; just call press instead. Do not use append in
your implementation of type either; you must mutate the list typed only
using press.
Read the doctests and talk about:
- Why it's possible to press a button repeatedly with
.press().press().press(). - Why pressing a button repeatedly sometimes prints on only one line and sometimes prints multiple lines.
- Why
bored.typedhas 10 elements at the end.
Discussion Time: Before anyone types anything, have a conversation
describing the type of each attribute and how it will be used. Start with
Button: how will letter and output be used? Then discuss Keyboard: how
will typed and keys be used? How will new letters be added to the list
called typed each time a Button in keys is pressed? Call the staff if
you're not sure! Once everyone understands the answers to these questions, you
can try writing the code together.
LOWERCASE_LETTERS = 'abcdefghijklmnopqrstuvwxyz'
class CapsLock:
def __init__(self):
self.pressed = 0
def press(self):
self.pressed += 1
class Button:
"""A button on a keyboard.
>>> f = lambda c: print(c, end='') # The end='' argument avoids a new line
>>> k, e, y = Button('k', f), Button('e', f), Button('y', f)
>>> s = e.press().press().press()
eee
>>> caps = Button.caps_lock
>>> t = [x.press() for x in [k, e, y, caps, e, e, k, caps, e, y, e, caps, y, e, e]]
keyEEKeyeYEE
>>> u = Button('a', print).press().press().press()
A
A
A
"""
caps_lock = CapsLock()
def __init__(self, letter, output):
assert letter in LOWERCASE_LETTERS
self.letter = letter
self.output = output
self.pressed = 0
def press(self):
"""Call output on letter (maybe uppercased), then return this button."""
self.pressed += 1
"*** YOUR CODE HERE ***"
Button Hint: Uppercasing
Since self.letter is always lowercase, use self.letter.upper() to produce
the uppercase version.
Button Hint: Caps Lock
The number of times caps_lock has been pressed is either
self.caps_lock.pressed or Button.caps_lock.pressed.
Button Hint: Output
The output attribute is a function that can be called:
self.output(self.letter) or self.output(self.letter.upper()). You do not
need to return the result.
class Keyboard:
"""A keyboard.
>>> Button.caps_lock.pressed = 0 # Reset the caps_lock key
>>> bored = Keyboard()
>>> bored.type('hello')
>>> bored.typed
['h', 'e', 'l', 'l', 'o']
>>> bored.keys['l'].pressed
2
>>> Button.caps_lock.press()
>>> bored.type('hello')
>>> bored.typed
['h', 'e', 'l', 'l', 'o', 'H', 'E', 'L', 'L', 'O']
>>> bored.keys['l'].pressed
4
"""
def __init__(self):
self.typed = []
self.keys = ... # Try a dictionary comprehension!
def type(self, word):
"""Press the button for each letter in word."""
assert all([w in LOWERCASE_LETTERS for w in word]), 'word must be all lowercase'
"*** YOUR CODE HERE ***"
Keyboard Hint: Keys
The keys can be created using a dictionary comprehension:
self.keys = {c: Button(c, ...) for c in LOWERCASE_LETTERS}. The call to
Button should take c and an output function that appends to self.typed,
so that every time one of these buttons is pressed, it appends a letter to
self.typed.
Keyboard Hint: Type
Call the press method of self.keys[w] for each w in word. When you call
press, the Button is already set up (in the Keyboard.__init__ method) to
output to the typed list of this Keyboard.
Description Time: Describe how new letters are added to typed each time a
Button in keys is pressed. Instead of just reading your code, say what it
does (e.g., "When the button of a keyboard is pressed ..."). One short sentence
is enough.
Inheritance
To avoid redefining attributes and methods for similar classes, we can write a
single base class from which more specialized classes inherit. For
example, we can write a class called Pet and define Dog as a subclass of
Pet:
class Pet:
def __init__(self, name, owner):
self.is_alive = True # It's alive!!!
self.name = name
self.owner = owner
def eat(self, thing):
print(self.name + " ate a " + str(thing) + "!")
def talk(self):
print(self.name)
class Dog(Pet):
def talk(self):
super().talk()
print('This Dog says woof!')
Inheritance represents a hierarchical relationship between two or more classes
where one class is a more specific version of the other: a dog is a pet.
(We use "is a" to describe this sort of relationship in OOP languages, not
to refer to the Python is operator.)
Since Dog inherits from Pet, the Dog class also inherits the Pet class's
methods, so we don't have to redefine __init__ or eat. We do want each Dog
to talk in a Dog-specific way, so we override the talk method.
We can use super() to refer to the superclass of self, and access any
superclass method as if we were an instance of the superclass. For example,
super().talk() in the Dog class calls the talk method from the Pet
class, but passes in the Dog instance as self.
Q2: Bear
Implement the SleepyBear and WinkingBear classes so that calling their
print method matches the doctests. Use as little code as possible and try not
to repeat any logic from Eye or Bear. Each blank can be filled with just two
short lines.
class Eye:
"""An eye.
>>> Eye().draw()
'0'
>>> print(Eye(False).draw(), Eye(True).draw())
0 -
"""
def __init__(self, closed=False):
self.closed = closed
def draw(self):
if self.closed:
return '-'
else:
return '0'
class Bear:
"""A bear.
>>> Bear().print()
? 0o0?
"""
def __init__(self):
self.nose_and_mouth = 'o'
def next_eye(self):
return Eye()
def print(self):
left, right = self.next_eye(), self.next_eye()
print('? ' + left.draw() + self.nose_and_mouth + right.draw() + '?')
class SleepyBear(Bear):
"""A bear with closed eyes.
>>> SleepyBear().print()
? -o-?
"""
"*** YOUR CODE HERE ***"
class WinkingBear(Bear):
"""A bear whose left eye is different from its right eye.
>>> WinkingBear().print()
? -o0?
"""
def __init__(self):
"*** YOUR CODE HERE ***"
def next_eye(self):
"*** YOUR CODE HERE ***"
Hint: Inheritance
A subclass can override a method like next_eye just by defining it again. If the
subclass defines its own method, but still needs the parent's version, you can
call the parent's method with super().method_name(...).