Programming in python and introduction.ppt

Guide to Programming with
Python
Chapter Nine
Object-Oriented Programming: The Blackjack
Game

Guide to Programming with Python 2
Objectives
• Create objects of different classes in the same
program
• Allow objects to communicate with each other
• Create more complex objects by combining simpler
ones
• Derive new classes from existing ones
• Extend the definition of existing classes
• Override method definitions of existing classes

The Blackjack Game
Figure 9.1: Sample run of the Blackjack game
One player wins, the other is not so lucky.

Sending and Receiving Messages
• Object-oriented program like an ecosystem
• Objects like organisms
• Organisms interact and so do objects
• Message: Communication between objects; one
object sends another a message when it invokes a
method of the other

The Alien Blaster Program
Figure 9.2: Sample run of the Alien Blaster program
Battle description is result of objects exchanging message.

The Alien Blaster Program (continued)
Figure 9.3: Visual representation of objects exchanging a message
hero, a Player object, sends invader, an Alien object, a message.

The Alien Blaster Program (continued)
class Player(object):
def blast(self, enemy):
print "The player blasts an enemy."
enemy.die()
class Alien(object):
def die(self):
print "Good-bye, cruel universe."
hero = Player()
invader = Alien()
hero.blast(invader)

Sending a Message
def blast(self, enemy):
print "The player blasts an enemy."
enemy.die()
...
hero.blast(invader)
• hero.blast() method is passed invader; i.e.,
the Player blast() method is passed an Alien object
• In blast(), enemy refers to the Alien object (invader)
• blast() invokes the Alien object’s die() method; i.e.,
the Player object sends the Alien object a message
telling it to die
alien_blaster.py

Combining Objects
• Real-world objects are often made up of other
objects
• Can mimic composition and collection in OOP
• Drag racer composed of body, tires, and engine
– Drag_Racer class with attribute engine that is a
Race_Engine object
• Zoo is collection of animals
– Zoo class that has an attribute animals which is a list
of different Animal objects

The Playing Cards Program
Figure 9.4: Sample run of the Playing Cards program
Each Hand object has a collection of Card objects.

Creating the Card Class
class Card(object):
""" A playing card. """
RANKS = ["A", "2", "3", "4", "5", "6", "7",
"8", "9", "10", "J", "Q", "K"]
SUITS = ["c", "d", "h", "s"]
def __init__(self, rank, suit):
self.rank = rank
self.suit = suit
def __str__(self):
reply = self.rank + self.suit
return reply

Creating the Card Class (continued)
• Card object rank attribute represents rank of card
– RANKS class attribute has all possible values
– "A" ace, "J" jack, "Q" queen, "K" king, "2" - "10"
numeric values
• Card object suit attribute represents suit of card
– SUITS class attribute has all possible values
– "c" clubs, "d" diamonds, "h" hearts, "s" spades
• A Card object with rank "A" and suit "d" is the ace
of diamonds

Creating the Hand Class
class Hand(object):
""" A hand of playing cards. """
def __init__(self):
self.cards = []
def __str__(self):
if self.cards:
reply = ""
for card in self.cards:
reply += str(card) + " "
else:
reply = "<empty>"
return reply

Creating the Hand Class (continued)
def clear(self):
self.cards = []
def add(self, card):
self.cards.append(card)
def give(self, card, other_hand):
self.cards.remove(card)
other_hand.add(card)

Creating the Hand Class (continued)
• Attribute
– cards is list of Card objects
• Methods
– __str__() returns string for entire hand
– clear() clears list of cards
– add() adds card to list of cards
– give() removes card from current hand and adds to
another hand

Using Card Objects
card1 = Card(rank = "A", suit = "c")
card2 = Card(rank = "2", suit = "c")
print card1 # Ac
print card2 # 2c
print card3 # 3c
print card4 # 4c
print card5 # 5c

Combining Card Objects Using a Hand
Object
my_hand = Hand()
print my_hand # <empty>
my_hand.add(card1)
my_hand.add(card2)
my_hand.add(card3)
my_hand.add(card4)
my_hand.add(card5)
print my_hand # Ac 2c 3c 4c 5c

Combining Card Objects Using a Hand
Object (continued)
your_hand = Hand()
my_hand.give(card1, your_hand)
my_hand.give(card2, your_hand)
print your_hand # Ac 2c
print my_hand # 3c 4c 5c
my_hand.clear()
print my_hand # <empty>
playing_cards.py

Using Inheritance to Create New
Classes
• Inheritance: An element of OOP that allows a new
class to be based on an existing one where the
new automatically gets (or inherits) all of the
methods and attributes of the existing class
• Like getting all the work that went into the existing
class for free

Extending a Class Through
Inheritance
• Inheritance is used to create a more specialized
version of an existing class
• The new class gets all the methods and attributes of
the existing class
• The new class can also define additional methods and
attributes
• Drag_Racer class with methods stop() and go()
• Clean_Drag_Racer based on Drag_Racer()
– Automatically inherits stop() and go()
– Can define new method, clean(), for cleaning
windshield

The Playing Cards 2.0 Program
Figure 9.5: Sample run of the Playing Cards 2.0 program
The Deck object inherits all of the methods of the Hand class.

Creating a Base Class
(Same as before)
class Hand(object):
""" A hand of playing cards. """
def __init__(self):
self.cards = []
def __str__(self):
if self.cards:
reply = ""
for card in self.cards:
reply += str(card) + " "
else:
reply = "<empty>"
return rep

Creating a Base Class (continued)
(Same as before)
def clear(self):
self.cards = []
def add(self, card):
self.cards.append(card)
def give(self, card, other_hand):
self.cards.remove(card)
other_hand.add(card)

Inheriting from a Base Class
class Deck(Hand):
• Base class: A class upon which another is based;
it is inherited from by a derived class
• Derived class: A class that is based upon another
class; it inherits from a base class
• Hand is base class
• Deck is derived class

Inheriting from a Base Class
(continued)
• Deck inherits Hand attribute:
cards
• Deck inherits all Hand methods:
__init__()
__str__()
clear()
add()
give()

Extending a Derived Class
class Deck(Hand):
""" A deck of playing cards. """
def populate(self):
for suit in Card.SUITS:
for rank in Card.RANKS:
self.add(Card(rank, suit))
def shuffle(self):
import random
random.shuffle(self.cards)

Extending a Derived Class (continued)
def deal(self, hands, per_hand = 1):
for rounds in range(per_hand):
for hand in hands:
if self.cards: # if len(self.cards) > 0
top_card = self.cards[0]
self.give(top_card, hand)
else:
print "Out of cards!"

Extending a Derived Class (continued)
• In addition to methods Deck inherits, it defines new
methods:
populate()
shuffle()
deal()

Using the Derived Class
deck1 = Deck()
print deck1 # <empty>
deck1.populate()
print deck1 # ordered deck
deck1.shuffle()
print deck1 # shuffled deck

Using the Derived Class (continued)
my_hand = Hand()
your_hand = Hand()
hands = [my_hand, your_hand]
deck1.deal(hands, per_hand = 5)
print my_hand # 5 alternating cards from deck
print your_hand # 5 alternating cards from deck
print deck1 # deck minus first 10 cards
deck1.clear()
print deck1 # <empty>
playing_cards2.py

Altering the Behavior of Inherited
Methods
• Override: To redefine how inherited method of
base class works in derived class
• Two choices when overriding
– Completely new functionality vs. overridden method
– Incorporate functionality of overridden method, add
more

Altering the Behavior of Inherited
Methods (continued)
• Drag_Racer with stop() method that applies brakes
• Parachute_Racer based on Drag_Racer overrides
stop() method, two choices
– Overridden stop() method shifts into reverse
– Overridden stop() method applies brakes (using
the overridden method) and releases parachute

The Playing Cards 3.0 Program
Figure 9.6: Sample run of the Playing Cards program
By overriding __str__(), objects of derived classes print differently.

Creating a Base Class
(Same as before)
class Card(object):
""" A playing card. """
RANKS = ["A", "2", "3", "4", "5", "6", "7",
"8", "9", "10", "J", "Q", "K"]
SUITS = ["c", "d", "h", "s"]
def __init__(self, rank, suit):
self.rank = rank
self.suit = suit
def __str__(self):
reply = self.rank + self.suit
return reply

Overriding Base Class Methods
class Unprintable_Card(Card):
....
def __str__(self):
return "<unprintable>"
• Unprintable_Card
– Inherits all methods of Card
– Overrides inherited method __str__()
– Printed object displayed as <unprintable>
• A derived class has no effect on a base class

Invoking Base Class Methods
• In overridden method, can incorporate inherited method’s
functionality
• Suppose we want to have a card that can be face up or face
down…
class Positionable_Card(Card):
def __init__(self, rank, suit, face_up = True):
super(Positionable_Card, self).__init__(rank, suit)
self.is_face_up = face_up
• Superclass: Another name for a base class
• Card is the superclass of Positionable_Card

(continued)
• Incorporate inherited method’s functionality by
calling super()
• Positionable_Card constructor invokes Card
constructor and creates new attribute
• super() lets you invoke the method of a superclass
– First argument is the base class, Positionable_Card
– Second is a reference to the object itself, self
– Last is the superclass method you want to call with
its parameters, __init__(rank, suit)

(continued)
class Positionable_Card(Card):
def __str__(self):
if self.is_face_up:
reply = super(Positionable_Card, self).__str__()
else:
reply = "XX"
return rep
def flip(self):
self.is_face_up = not self.is_face_up
• __str__() invokes superclass __str__() method if
card is face up; otherwise, returns "XX"

Using the Derived Classes
card1 = Card("A", "c")
card2 = Unprintable_Card("A", "d")
card3 = Positionable_Card("A", "h")
print card1 # Ac
print card2 # <unprintable>
print card3 # Ah
card3.flip()
print card3 # XX
playing_cards3.py

Understanding Polymorphism
• Polymorphism: Aspect of object-oriented
programming that allows you to send same
message to objects of different classes, related by
inheritance, and achieve different but appropriate
results for each object
• When you invoke __str__() method of
Unprintable_Card object, you get different result
than when you invoke the __str__() method of a
Card object

Creating Modules
• Create, use, and even share your own modules
• Reuse code
– Could reuse the Card, Hand, and Deck classes for
different card games
• Manage large projects
– Professional projects can be hundreds of thousands
of lines long
– Would be nearly impossible to maintain in one file

The Simple Game Program
Figure 9.7: Sample run of the Simple Game program
Program uses functions and class from programmer-created module.

Writing Modules
• Write module as a collection of related
programming components, like functions and
classes, in single file
• File is just Python file with extension .py
• Module imported using filename, just like built-in
modules

Writing Modules (continued)
games module is file games.py
""" A player for a game. """
def __init__(self, name, score = 0):
self.name = name
self.score = score
def __str__(self):
reply = self.name + ":t" + str(self.score)
return reply

def ask_yes_no(question):
"""Ask a yes or no question."""
response = None
while response not in ("y", "n"):
response = raw_input(question).lower()
return response
def ask_number(question, low, high):
"""Ask for a number within a range."""
response = None
while response not in range(low, high):
response = int(raw_input(question))
return response

if __name__ == "__main__":
print "You ran module but must 'import' it."
raw_input("nnPress the enter key to exit.")
• __name__ == "__main__" is true if file is run directly;
is false if the file is imported as module
• If games.py run directly, message displayed that the
file is meant to be imported
games.py

Importing Modules
import games, random
• Import programmer-created module the same way
you import a built-in module

Using Imported Functions and Classes
num = games.ask_number(question = "How many?",
low = 2, high = 5)
...
player = games.Player(name, score)
...
again = games.ask_yes_no("Play again? (y/n): ")
• Use imported programmer-created modules the
same way as you use imported built-in modules
simple_game.py

The Blackjack Game - Classes
Table 9.1: Blackjack classes

The Blackjack Game – Class
Hierarchy
Figure 9.8: Blackjack classes
Inheritance hierarchy of classes for the Blackjack game

The Blackjack Game - Pseudocode
Deal each player and dealer initial two cards
For each player
While the player asks for a hit and the player is not busted
Deal the player an additional card
If there are no players still playing
Show the dealer’s two cards
Otherwise
While the dealer must hit and the dealer is not busted
Deal the dealer an additional card
If the dealer is busted
For each player who is still playing
The player wins

The Blackjack Game – Pseudocode
(continued)
Otherwise
For each player who is still playing
If the player’s total is greater than the dealer’s total
The player wins
Otherwise, if the player’s total is less than the dealer’s total
The player loses
Otherwise
The player pushes
blackjack.py

Summary
• In object-oriented programming, objects can send
messages to each other by invoking each other’s
methods
• Objects can be composed of other objects or have
collections of objects
• Inheritance is an aspect of object-oriented
programming that allows a new class to be based
on an existing one where the new class
automatically gets (or inherits) all of the methods
and attributes of the existing one

Summary (continued)
• Inheritance can be used to create a more
specialized version of an existing class
• A base class is a class upon which another is
based; it is inherited from by this other class (the
derived class)
• A derived class is a class that is based upon
another class; it inherits from this other class (a
base class)
• Superclass is another name for base class

Summary (continued)
• A derived class can define new methods and
attributes in addition to the ones that it inherits
• To override an inherited method is to redefine how
the method of a base class works in a derived
class
• When overriding a method, the new definition can
have completely different functionality than the
original definition or the new definition can
incorporate the functionality of the original

Summary (continued)
• The super() function allows you to invoke the
method of a superclass
• Polymorphism is an aspect of object-oriented
programming that allows you to send the same
message to objects of different classes, related by
inheritance, and achieve different but appropriate
results for each object
• You can write, import, and even share your own
modules

Summary (continued)
• You write a module as a collection of related
programming components, like functions and
classes, in a single Python file
• Programmer-created modules can be imported the
same way that built-in modules are, with an import
statement
• You test to see if __name__ is equal to
"__main__" to make a module identify itself as
such

Programming in python and introduction.ppt

More Related Content

Similar to Programming in python and introduction.ppt (20)

More from ajajkhan16 (20)

Recently uploaded (20)

Programming in python and introduction.ppt