Debugging

• If you try to access an attribute that doesn’t exist, you get an

AttributeError:
Example
>>> p = Point()
>>> p.x = 3
>>> p.y = 4
>>> p.z
AttributeError: Point instance has no attribute 'z’
• If you are not sure what type an object is, you can ask:
• Example
>>> type(p)
<class ‘__main__.Point’>
 Debugging
• You can also use isinstance to check whether an object is an instance of a class:
Example
>>> isinstance(p, Point)
True
• If you are not sure whether an object has a particular attribute, you can use the built-in function hasattr:
Example
>>> hasattr(p, 'x’)
True
>>> hasattr(p, 'z’)
False
• The first argument can be any object; the second argument is a string that contains the name of the attribute.
• You can also use a try statement to see if the object has the attributes you need:
Example
try:
x = p.x
except AttributeError:
x=0
Debugging
• A Time object is well-formed
• If the values of minute and second are between 0 and 60
• If hour is positive.
• Hour and minute should be integer values
• But we might allow Second to have a fraction part.
• Requirements like these are called invariants because they should
always be true.
Debugging
Example:
def valid_time(time):
if time.hour < 0 or time.minute < 0 or time.second < 0:
return False
if time.minute >= 60 or time.second >= 60:
return False
return True

def add_time(t1, t2):

if not valid_time(t1) or not valid_time(t2) :
raise ValueError('invalid Time object in add_time’)
seconds = time_to_int(t1) + time_to_int(t2)
return int_to_time(seconds)
Debugging
• It is legal to add attributes to objects at any point in the execution of a
program,
• But if you have objects with the same type that don’t have the same
attributes, it is easy to make mistakes.
• It is considered a good idea to initialize all of an object’s attributes in the
init method.
• If you are not sure whether an object has a particular attribute, you can
use the built-in function hasattr
• Alternative to access attributes is the built-in function vars, which takes an
object and returns a dictionary that maps from attribute names to their
values:
>>> p = Point(3, 4)
>>> vars(p)
{'y': 4, 'x': 3}
Debugging
• For purposes of debugging, you might find it useful to keep this
function handy:
def print_attributes(obj):
for attr in vars(obj):
print(attr, getattr(obj, attr))
• print_attributes traverses the dictionary and prints each attribute
name and its corresponding value.
• The built-in function getattr takes an object and an attribute name (as
a string) and returns the attribute’s value.
 CHAPTER 04
INHERITANCE
Card Objects
• There are 52 cards in a deck, each of which belongs to 1 of 4 suits and 1 of
13 ranks.
• The suits are Spades, Hearts, Diamonds and Clubs.
• The ranks are Ace,2,3,4,5,6,7,8,9,10,Jack,Queen and King.
• If we want to define a new object to represent a playing card, it is obvious
what the attributes should be: rank and suit.
• One possibility is to use strings containing words like 'Spade' for suits and
'Queen' for ranks.
• An alternative is to use integers to encode the ranks and suits. In this
context, “encode” means that we are going to define a mapping between
numbers and suits, or between numbers and ranks.
Card Objects
• Ex:

• This code makes it easy to compare cards; because higher suits map to
higher numbers, we can compare suits by comparing their codes.
• The mapping for ranks is fairly obvious; each of the numerical ranks maps
to the corresponding integer, and for face cards.

• The → symbol to make it clear that these mappings are not part of the
Python program. They are part of the program design, but they don’t
appear explicitly in the code.
Card Objects
• The class definition
• n for Card looks like this:

• As usual, the init method takes an optional parameter for each attribute.
The default card is the 2 of Clubs.
• To create a Card, we call Card with the suit and rank of the card you want
2. Class Attributes
• In order to print Card, we need a mapping from the integer codes to the
corresponding ranks and suits. A natural way to do that is with lists of strings. We
assign these lists to class attributes:

• Variables like suit_names and rank_names, which are defined inside a class but
outside of any method, are called class attributes because they are associated
with the class object Card.
• The variables like suit and rank, which are called instance attributes because they
are associated with a particular instance.
• Both kinds of attribute are accessed using dot notation. Class
o Ex, in __str__, self is a Card object, and self.rank is its rank. Attributes
o Similarly, Card is a class object, and Card.rank_names is a list of strings
associated with the class.
• The first element of rank_names is None because there is no card
with rank zero.
• By including None as a place-keeper, we get a mapping with the
nice property that the index 2 maps to the string '2', and so on. To
avoid this tweak, we could have used a dictionary instead of a list.
With the methods we have so far, we can create and print cards:
3. Comparing Cards
• For built-in types, there are relational operators (, ==, etc.) that compare values
and determine when one is greater than, less than, or equal to another.
• For user-defined types, we can override the behavior of the built-in operators by
providing a method named __cmp__
• __cmp__ takes two parameters, self and other, and returns a positive number if
the first object is greater, a negative number if the second object is greater, and 0
if they are equal to each other.
• The built-in function cmp has the same interface as the method __cmp__: it takes
two values and returns a positive number if the first is larger, a negative number if
the second is larger, and 0 if they are equal.
• In Python 3, cmp no longer exists, and the __cmp__ method is not supported.
Instead you should provide __lt__, which returns True if self is less than other. You
can implement __lt__ using tuples and the < operator.
Comparing Cards
 4. Decks
• Now that we have Cards, the next step is to define Decks. Since a deck is made up
of cards, it is natural for each Deck to contain a list of cards as an attribute.
• The init method creates the attribute cards and generates the standard set of fifty-
two cards:

• The outer loop enumerates the suits from 0 to 3.

• The inner loop enumerates the ranks from 1 to 13.
• Each iteration creates a new Card with the current suit and rank, and appends it to
self.cards.
5. Printing the Deck
Printing the Deck
• This method demonstrates an efficient way to accumulate a large
string: building a list of strings and then using join.
• The built-in function str invokes the __str__ method on each card and
returns the string representation.
• Since we invoke join on a newline character, the cards are separated
by newlines.
• Even though the result appears on 52 lines, it is one long string that
contains newlines.
6. Add, Remove, Shuffle and Sort
Remove
• We would like a method that removes a card from the deck and
returns it. The list method pop provides a convenient way to do that:
• Since pop removes the last card in the list, we are dealing from the
bottom of the deck.
Add, Remove, Shuffle and Sort
Add
• To add a card, we can use the list method append:

• A method like this that uses another function without doing much
real work is sometimes calleda veneer-(where it is common to glue a
thin layer of good quality wood to the surface of a cheaper piece of
wood).
• In this case we are defining a “thin” method that expresses a list
operation in terms that are appropriate for decks.
Add, Remove, Shuffle and Sort
Shuffle
• We can write a Deck method named shuffle using the function shuffle
from the random module:
• Don’t forget to import random.
 7.Inheritance
• The language feature most often associated with object-oriented programming
is inheritance.
• Inheritance is the ability to define a new class that is a modified version of an
existing class.
• It is called “inheritance” because the new class inherits the methods of the
existing class.
• Extending this metaphor, the existing class is called the parent and the new
class is called the child.
• The definition of a child class is like other class definitions, but the name of the
parent class appears in parentheses:
Inheritance
• This definition indicates that Hand inherits from Deck; that means we
can use methods like pop_card and add_card for Hands as well as
Decks.
• Inheritance is a useful feature
• Inheritance can facilitate code reuse, since you can customize the
behavior of parent classes without having to modify them.
• In some cases, the inheritance structure reflects the natural structure
of the problem, which makes the program easier to understand.
8. Class Diagrams
• A class diagram is a more abstract representation of the structure of a
program. Instead of showing individual objects, it shows classes and
the relationships between them.
• There are several kinds of relationship between classes:
• Objects in one class might contain references to objects in another class. For
example, each Rectangle contains a reference to a Point, and each Deck
contains references to many Cards. This kind of relationship is called HAS-A,
as in, “a Rectangle has a Point.”
• One class might inherit from another. This relationship
is called IS-A, as in, “a Hand is a kind of a Deck.”
• One class might depend on another in the sense that
changes in one class would require changes in the other.
Class Diagrams
• A class diagram is a graphical representation of these relationships.
For example, the above class diagram shows the relationships
between Card, Deck and Hand.
• The arrow with a hollow triangle head represents an IS-A relationship;
in this case it indicates that Hand inherits from Deck.
• The standard arrow head represents a HAS-A relationship; in this
case a Deck has references to Card objects.
• The star (*) near the arrow head is a multiplicity; it indicates how
many Cards a Deck has. A multiplicity can be a simple number, like 52,
a range, like 5..7 or a star, which indicates that a Deck can have any
number of Cards.