Lab 8: Object Oriented Programming
Due at 11:59pm on Friday, 7/26/2019.
Starter Files
Download lab08.zip. Inside the archive, you will find starter files for the questions in this lab, along with a copy of the Ok autograder.
Submission
By the end of this lab, you should have submitted the lab with
python3 ok --submit
. You may submit more than once before the
deadline; only the final submission will be graded.
Check that you have successfully submitted your code on
okpy.org.
- To receive credit for this lab, you must complete Questions 1-3 and submit through Ok.
- If you would like to be checked off, make sure you sign yourself up on the queue in a lab. The questions are at the end of this page.
- The remaining questions are optional. It is recommended that you complete these problems in your own time.
- All starter code for this lab can be found in classes.py.
Topics
Consult this section if you need a refresher on the material for this lab. It's okay to skip directly to the questions and refer back here should you get stuck.
Object-Oriented Programming
In this lab we'll be diving into object-oriented programming (OOP), a model of programming that allows you to think of data in terms of "objects" with their own characteristics and actions, just like objects in real life! This is very powerful and allows you to create objects that are specific to your program - you can read up on all the details here.
OOP Example: Car
Class
Tiffany is running late, and needs to get from San Francisco to Berkeley before lecture starts. She'd take BART, but that will take too long. It'd be great if she had a car. A monster truck would be best, but a car will do -- for now...
In car.py
, you'll find a class called Car
. A class is a blueprint for
creating objects of that type. In this case, the Car
class statement tells us
how to create Car
objects.
Constructor
Let's build Tiffany a car! Don't worry, you won't need to do any
physical work -- the constructor will do it for you. The constructor of
a class is a function that creates an instance, or a single occurrence,
of the object outlined by the class. In Python, the constructor method is named
__init__
. Note that there must be two underscores on each side of init
.
The Car
class' constructor looks like this:
def __init__(self, make, model):
self.make = make
self.model = model
self.color = 'No color yet. You need to paint me.'
self.wheels = Car.num_wheels
self.gas = Car.gas
The __init__
method for Car
has three parameters. The first one, self
, is
automatically bound to the newly created Car
object. The second and third
parameters, make
and model
, are bound to the arguments passed to the
constructor, meaning when we make a Car
object, we must provide two arguments.
Don't worry about the code inside the body of the constructor for now.
Let's make our car. Tiffany would like to drive a Tesla Model S to
lecture. We can construct an instance of Car
with 'Tesla'
as the make
and
'Model S'
as the model
. Rather than calling __init__
explicitly, Python
allows us to make an instance of a class by using the name of the class.
>>> tiffanys_car = Car('Tesla', 'Model S')
Here, 'Tesla'
is passed in as the make
, and 'Model S' as the model
. Note
that we don't pass in an argument for self
, since its value is always the
object being created. An object is an instance of a class. In this case,
tiffanys_car
is now bound to a Car
object or, in other words, an instance
of the Car
class.
Attributes and Dot Notation
So how are the make
and model
of Tiffany's car actually stored? Let's talk
about attributes of instances and classes. Here's a snippet of the code in
car.py
with the instance and class attributes in the Car
class:
class Car(object):
num_wheels = 4
gas = 30
headlights = 2
size = 'Tiny'
def __init__(self, make, model):
self.make = make
self.model = model
self.color = 'No color yet. You need to paint me.'
self.wheels = Car.num_wheels
self.gas = Car.gas
def paint(self, color):
self.color = color
return self.make + ' ' + self.model + ' is now ' + color
def drive(self):
if self.wheels < Car.num_wheels or self.gas <= 0:
return 'Cannot drive!'
self.gas -= 10
return self.make + ' ' + self.model + ' goes vroom!'
def pop_tire(self):
if self.wheels > 0:
self.wheels -= 1
def fill_gas(self):
self.gas += 20
return 'Gas level: ' + str(self.gas)
In the first two lines of the constructor, the name self.make
is bound to the
first argument passed to the constructor and self.model
is bound to the
second. These are two examples of instance attributes. An instance attribute
is a quality or variable that is specific to an instance, and not the class itself!
Instance attributes are accessed using dot notation (separating the instance and
attribute with a period) with an instance. In this case, self
is bound to our
instance, so self.model
references our instance's model.
Our car has other instance attributes too, like color
and wheels
. As
instance attributes, the make, model, and color of tiffanys_car
do not affect
the make, model, and color of other cars.
On the other hand, a class attribute is a quality that is shared among all
instances of the class. For example, the Car
class has four class attributes
defined at the beginning of a class: num_wheels = 4
, gas = 30
, headlights =
2
and size = 'Tiny'
. The first says that all cars have 4
wheels.
You might notice in the __init__
method of the Car
class, the instance
attribute gas
is initialized to the value of Car.gas
, the class attribute.
Why don't we just use the class attribute, then? The reason is because each
Car
's gas
attribute needs to be able to change independently of each other.
If one Car
drives for a while, it should use up some gas
, and that Car
instance should reflect that by having a lower gas
value. However, all other
Car
s shouldn't lose any gas
, and changes to a class attribute will affect
all instances of the class.
Class attributes can also be accessed using dot notation, both on an instance
and on the class name itself. For example, we can access the class attribute
size
of Car
like this:
>>> Car.size
'Tiny'
And in the following line, we access tiffanys_car
's color
attribute:
>>> tiffanys_car.color
'No color yet. You need to paint me.'
Looks like we need to paint tiffanys_car
!
Methods
Let's use the paint
method from the Car
class. Methods are functions
that are specific to a class; only an instance of the class can use them. We've
already seen one method: __init__
! Think of methods as actions or abilities of
objects. How do we call methods on an instance? You guessed it, dot notation!
>>> tiffanys_car.paint('black')
'Tesla Model S is now black'
>>> tiffanys_car.color
'black'
Awesome! But if you take a look at the paint
method, it takes two parameters.
So why don't we need to pass two arguments? Just like we've seen with
__init__
, all methods of a class have a self
parameter to which Python
automatically binds the instance that is calling that method. Here,
tiffanys_car
is bound to self
so that the body of paint
can access its
attributes!
You can also call methods using the class name and dot notation; for example,
>>> Car.paint(tiffanys_car, 'red')
'Tesla Model S is now red'
Notice that unlike when we painted Tiffany's car black, this time
we had to pass in two arguments: one for self
and one for color
. This is
because when you call a method using dot notation from an instance, Python
knows what instance to automatically bind to self
. However, when you call a
method using dot notation from the class, Python doesn't know which instance of
Car
we want to paint, so we have to pass that in as well.
Inheritance
Tiffany's red Tesla is pretty cool, but he wants a bigger car!
How about we create a monster truck for him instead? In car.py
, we've defined
a MonsterTruck
class. Let's look at the code for MonsterTruck
:
class MonsterTruck(Car):
size = 'Monster'
def rev(self):
print('Vroom! This Monster Truck is huge!')
def drive(self):
self.rev()
return Car.drive(self)
Wow! The truck may be big, but the source code is tiny! Let's make sure that the truck still does what we expect it to do. Let's create a new instance of Tiffany's monster truck:
>>> tiffanys_truck = MonsterTruck('Monster Truck', 'XXL')
Does it behave as you would expect a Car
to? Can you still paint it? Is it
even drivable?
Well, the class MonsterTruck
is defined as class MonsterTruck(Car):
, meaning
its superclass is Car
. Likewise, the class MonsterTruck
is a subclass
of the Car
class. That means the MonsterTruck
class inherits all the
attributes and methods that were defined in Car
, including its constructor!
Inheritance makes setting up a hierarchy of classes easier because the amount of code you need to write to define a new class of objects is reduced. You only need to add (or override) new attributes or methods that you want to be unique from those in the superclass.
>>> tiffanys_car.size
'Tiny'
>>> tiffanys_truck.size
'Monster'
Wow, what a difference in size! This is because the class attribute size
of
MonsterTruck
overrides the size
class attribute of Car
, so all
MonsterTruck
instances are 'Monster'
-sized.
In addition, the drive
method in MonsterTruck
overrides the one in Car
.
To show off all MonsterTruck
instances, we defined a rev
method specific to
MonsterClass
. Regular Car
s cannot rev
! Everything else -- the
constructor __init__
, paint
, num_wheels
, gas
-- are inherited from Car
.
Required Questions
WWPD
Q1: Using the Car class
Here is the full definition of the Car
class from the
car example above in car.py
:
class Car(object):
num_wheels = 4
gas = 30
headlights = 2
size = 'Tiny'
def __init__(self, make, model):
self.make = make
self.model = model
self.color = 'No color yet. You need to paint me.'
self.wheels = Car.num_wheels
self.gas = Car.gas
def paint(self, color):
self.color = color
return self.make + ' ' + self.model + ' is now ' + color
def drive(self):
if self.wheels < Car.num_wheels or self.gas <= 0:
return 'Cannot drive!'
self.gas -= 10
return self.make + ' ' + self.model + ' goes vroom!'
def pop_tire(self):
if self.wheels > 0:
self.wheels -= 1
def fill_gas(self):
self.gas += 20
return 'Gas level: ' + str(self.gas)
Use Ok to test your knowledge with the following What would Python Display questions.
python3 ok -q car -u
If an error occurs, type Error. If nothing is displayed, type Nothing.
>>> tiffanys_car = Car('Tesla', 'Model S')
>>> tiffanys_car.model
______'Model S'
>>> tiffanys_car.gas = 10
>>> tiffanys_car.drive()
______'Tesla Model S goes vroom!'
>>> tiffanys_car.drive()
______'Cannot drive!'
>>> tiffanys_car.fill_gas()
______'Gas level: 20'
>>> tiffanys_car.gas
______20
>>> Car.gas
______30
>>> christophers_car = Car('Tesla', 'Model S')
>>> christophers_car.wheels = 2
>>> christophers_car.wheels
______2
>>> Car.num_wheels
______4
>>> christophers_car.drive()
______'Cannot drive!'
>>> Car.drive()
______Error (TypeError)
>>> Car.drive(christophers_car)
______'Cannot drive!'
For the following, we reference the MonsterTruck
class, also in car.py
:
class MonsterTruck(Car):
size = 'Monster'
def rev(self):
print('Vroom! This Monster Truck is huge!')
def drive(self):
self.rev()
return Car.drive(self)
>>> alexs_car = MonsterTruck('Monster', 'Batmobile')
>>> alexs_car.drive()
______Vroom! This Monster Truck is huge!
'Monster Batmobile goes vroom!'
>>> Car.drive(alexs_car)
______'Monster Batmobile goes vroom!'
>>> MonsterTruck.drive(alexs_car)
______Vroom! This Monster Truck is huge!
'Monster Batmobile goes vroom!'
>>> Car.rev(alexs_car)
______Error (AttributeError)
Magic: The Lambda-ing
In the next part of this lab, we will be implementing a card game!
You can start the game by typing:
python3 cardgame.py
This game doesn't work yet. If we run this right now, the code will
error, since we haven't implemented anything yet. When it's working, you
can exit the game and return to the command line with Ctrl-C
or Ctrl-D
.
This game uses several different files.
- Code for all the questions in this lab can be found in
classes.py
. - Some utility for the game can be found in
cardgame.py
, but you won't need to open or read this file. This file doesn't actually mutate any instances directly - instead, it calls methods of the different classes, maintaining a strict abstraction barrier. - If you want to modify your game later to add your own custom cards and decks,
you can look in
cards.py
to see all the standard cards and the default deck; here, you can add more cards and change what decks you and your opponent use. The cards were not created with balance in mind, so feel free to modify the stats and add/remove cards as desired.
Rules of the Game This game is a little involved, though not nearly as much as its namesake. Here's how it goes:
There are two players. Each player has a hand of cards and a deck, and at the start of each round, each player draws a card from their deck. If a player's deck is empty when they try to draw, they will automatically lose the game. Cards have a name, an attack stat, and a defense stat. Each round, each player chooses one card to play from their own hands. The card with the higher power wins the round. Each played card's power value is calculated as follows:
(player card's attack) - (opponent card's defense) / 2
For example, let's say Player 1 plays a card with 2000 ATK/1000 DEF and Player 2 plays a card with 1500 ATK/3000 DEF. Their cards' powers are calculated as:
P1: 2000 - 3000/2 = 2000 - 1500 = 500
P2: 1500 - 1000/2 = 1500 - 500 = 1000
so Player 2 would win this round.
The first player to win 8 rounds wins the match!
However, there are a few effects we can add (in the optional questions section) to make this game a bit more interesting. Cards are split into Tutor, TA, and Professor types, and each type has a different effect when they're played. All effects are applied before power is calculated during that round:
- A Tutor will cause the opponent to discard and re-draw the first 3 cards in their hand.
- A TA will swap the opponent card's attack and defense.
- An Instructor will add 300 attack and defense to all cards in the player's deck, and then add a copy of the opponent's card to both the player's deck and the player's hand.
These are a lot of rules to remember, so refer back here if you need to review them, and let's start making the game!
Q2: Making Cards
To play a card game, we're going to need to have cards, so let's make some!
We're gonna implement the basics of the Card
class first.
First, implement the Card
class constructor in classes.py
. This constructor
takes three arguments:
- the
name
of the card, a string - the
attack
stat of the card, an integer - the
defense
stat of the card, an integer
Each Card
instance should keep track of these values using instance attributes
called name
, attack
, and defense
.
You should also implement the power
method in Card
, which takes in another card as
an input and calculates the current card's power. Check the Rules section if you want
a refresher on how power is calculated.
class Card(object):
cardtype = 'Staff'
def __init__(self, name, attack, defense):
"""
Create a Card object with a name, attack,
and defense.
>>> staff_member = Card('staff', 400, 300)
>>> staff_member.name
'staff'
>>> staff_member.attack
400
>>> staff_member.defense
300
>>> other_staff = Card('other', 300, 500)
>>> other_staff.attack
300
>>> other_staff.defense
500
"""
"*** YOUR CODE HERE ***"
self.name = name
self.attack = attack
self.defense = defense
def power(self, other_card):
"""
Calculate power as:
(player card's attack) - (opponent card's defense)/2
where other_card is the opponent's card.
>>> staff_member = Card('staff', 400, 300)
>>> other_staff = Card('other', 300, 500)
>>> staff_member.power(other_staff)
150.0
>>> other_staff.power(staff_member)
150.0
>>> third_card = Card('third', 200, 400)
>>> staff_member.power(third_card)
200.0
>>> third_card.power(staff_member)
50.0
"""
"*** YOUR CODE HERE ***"
return self.attack - other_card.defense / 2
Use Ok to test your code:
python3 ok -q Card.__init__
python3 ok -q Card.power
Q3: Making a Player
Now that we have cards, we can make a deck, but we still need players to actually use them. We'll now fill in the implementation of thePlayer
class.
A Player
instance has three instance attributes:
name
is the player's name. When you play the game, you can enter your name, which will be converted into a string to be passed to the constructor.deck
is an instance of theDeck
class. You can draw from it using its.draw()
method.hand
is a list ofCard
instances. Each player should start with 5 cards in their hand, drawn from theirdeck
. Each card in the hand can be selected by its index in the list during the game. When a player draws a new card from the deck, it is added to the end of this list.
Complete the implementation of the constructor for Player
so that self.hand
is set to a list of 5 cards drawn from the player's deck
.
Next, implement the draw
and play
methods in the Player
class. The
draw
method draws a card from the deck and adds it to the
player's hand. The play
method removes and returns a card from the player's hand at the
given index.
Call
deck.draw()
when implementingPlayer.__init__
andPlayer.draw
. Don't worry about how this function works - leave it all to the abstraction!
class Player(object):
def __init__(self, deck, name):
"""Initialize a Player object.
A Player starts the game by drawing 5 cards from their deck. Each turn,
a Player draws another card from the deck and chooses one to play.
>>> test_card = Card('test', 100, 100)
>>> test_deck = Deck([test_card.copy() for _ in range(6)])
>>> test_player = Player(test_deck, 'tester')
>>> len(test_deck.cards)
1
>>> len(test_player.hand)
5
"""
self.deck = deck
self.name = name
"*** YOUR CODE HERE ***"
self.hand = [deck.draw() for _ in range(5)]
def draw(self):
"""Draw a card from the player's deck and add it to their hand.
>>> test_card = Card('test', 100, 100)
>>> test_deck = Deck([test_card.copy() for _ in range(6)])
>>> test_player = Player(test_deck, 'tester')
>>> test_player.draw()
>>> len(test_deck.cards)
0
>>> len(test_player.hand)
6
"""
assert not self.deck.is_empty(), 'Deck is empty!'
"*** YOUR CODE HERE ***"
self.hand.append(self.deck.draw())
def play(self, card_index):
"""Remove and return a card from the player's hand at the given index.
>>> from cards import *
>>> test_player = Player(standard_deck, 'tester')
>>> ta1, ta2 = TACard("ta_1", 300, 400), TACard("ta_2", 500, 600)
>>> tutor1, tutor2 = TutorCard("t1", 200, 500), TutorCard("t2", 600, 400)
>>> test_player.hand = [ta1, ta2, tutor1, tutor2]
>>> test_player.play(0) is ta1
True
>>> test_player.play(2) is tutor2
True
>>> len(test_player.hand)
2
"""
"*** YOUR CODE HERE ***"
return self.hand.pop(card_index)
Use Ok to test your code:
python3 ok -q Player.__init__
python3 ok -q Player.draw
python3 ok -q Player.play
After you complete this problem, you'll be able to play a working version of the game! Type
python3 cardgame.py
to start a game of Magic: The Lambda-ing!
This version doesn't have the effects for different cards, yet - to get those working, try out the optional questions below.
Optional Questions
For the following sections, do not overwrite any lines already provided in the
code. Additionally, make sure to uncomment any calls to print
once you have implemented
each method. These are used to display information to the user, and changing them
may cause you to fail tests that you would otherwise pass.
Q4: Tutors: Flummox
To really make this card game interesting, our cards should have effects!
We'll do this with the effect
function for cards, which takes
in the opponent card, the current player, and the opponent player.
Implement the effect
method for Tutors, which causes the opponent to discard
the first 3 cards in their hand and then draw 3 new cards. Assume there at least 3 cards
in the opponent's hand and at least 3 cards in the opponent's deck.
Remember to uncomment the call to print
once you're done!
class TutorCard(Card):
cardtype = 'Tutor'
def effect(self, other_card, player, opponent):
"""
Discard the first 3 cards in the opponent's hand and have
them draw the same number of cards from their deck.
>>> from cards import *
>>> player1, player2 = Player(player_deck, 'p1'), Player(opponent_deck, 'p2')
>>> other_card = Card('other', 500, 500)
>>> tutor_test = TutorCard('Tutor', 500, 500)
>>> initial_deck_length = len(player2.deck.cards)
>>> tutor_test.effect(other_card, player1, player2)
p2 discarded and re-drew 3 cards!
>>> len(player2.hand)
5
>>> len(player2.deck.cards) == initial_deck_length - 3
True
"""
"*** YOUR CODE HERE ***"
opponent.hand = opponent.hand[3:]
for _ in range(3):
opponent.draw() #Uncomment the line below when you've finished implementing this method!
#print('{} discarded and re-drew 3 cards!'.format(opponent.name))
Use Ok to test your code:
python3 ok -q TutorCard.effect
Q5: TAs: Shift
Let's add an effect for TAs now! Implement the effect
method for TAs, which
swaps the attack and defense of the opponent's card.
class TACard(Card):
cardtype = 'TA'
def effect(self, other_card, player, opponent):
"""
Swap the attack and defense of an opponent's card.
>>> from cards import *
>>> player1, player2 = Player(player_deck, 'p1'), Player(opponent_deck, 'p2')
>>> other_card = Card('other', 300, 600)
>>> ta_test = TACard('TA', 500, 500)
>>> ta_test.effect(other_card, player1, player2)
>>> other_card.attack
600
>>> other_card.defense
300
"""
"*** YOUR CODE HERE ***"
other_card.attack, other_card.defense = other_card.defense, other_card.attack
Use Ok to test your code:
python3 ok -q TACard.effect
Q6: Instructors: Rally
We now have effects that affect the opponent's card, but what about ones that affect ours? Implement theeffect
method for Instructors, who increase the
attack and defense of all cards in the player's deck (but not their hand) by
300 each, and then add a copy of the opponent's card to both the player's deck
and their hand! Note that the 2 added cards are distinct copies, and they do
not get the +300/300 buff.
Note: to access a list of all the cards in a
deck
, usedeck.cards
. To make a copy of acard
, usecard.copy()
.
class InstructorCard(Card):
cardtype = 'Instructor'
def effect(self, other_card, player, opponent):
"""
Increase attack/defense of every card in the player's
deck by 300 each, then adds a copy of the opponent's card
to both the player's deck and to their hand.
>>> test_card = Card('card', 300, 300)
>>> instructor_test = InstructorCard('Instructor', 500, 500)
>>> opponent_card = test_card.copy()
>>> test_deck = Deck([test_card.copy() for _ in range(8)])
>>> player1, player2 = Player(test_deck.copy(), 'p1'), Player(test_deck.copy(), 'p2')
>>> instructor_test.effect(opponent_card, player1, player2)
p2's card added to p1's hand and deck!
>>> [(card.attack, card.defense) for card in player1.deck.cards]
[(600, 600), (600, 600), (600, 600), (300, 300)]
>>> len(player1.hand)
6
>>> opponent_card.attack
300
>>> opponent_card.defense
300
"""
"*** YOUR CODE HERE ***"
for card in player.deck.cards:
card.attack += 300
card.defense += 300
player.deck.cards.append(other_card.copy())
player.hand.append(other_card.copy()) #Uncomment the line below when you've finished implementing this method!
#print('{}\'s card added to {}\'s hand and deck!'.format(opponent.name, player.name))
Use Ok to test your code:
python3 ok -q InstructorCard.effect
Q7: Nonlocal Environment Diagram
Draw the environment diagram that results from running the following code.
def moon(f):
sun = 0
moon = [sun]
def run(x):
nonlocal sun, moon
def sun(sun):
return [sun]
y = f(x)
moon.append(sun(y))
return moon[0] and moon[1]
return run
moon(lambda x: moon)(1)
After you've done it on your own, generate an environment diagram in python tutor to check your answer.