Object-oriented programming helps us by encapsulating data and processing into a tidy class definition. This encapsulation assures us that our data is processed correctly. It also helps us understand what a program does by allowing us to ignore the details of an object's implementation.

When we combine multiple objects into a collaboration, we exploit the power of ecapsulation. We'll look at a simple example of creating a composite object, which has a number of detailed objects inside it.

Defining Collaboration. Defining a collaboration means that we are creating a class which depends on one or more other classes. Here's a new class, Dice, which uses instances of our Die class. We can now work with a Dice collection, and not worry about the details of the individual Die objects.

Example 21.4. dice.py - part 1

#!/usr/bin/env python
"""Define a Die, and Dice and simulate a dozen rolls."""

class Die( object ):

See the definition in Example 21.1, “die.py”.


class Dice( object ):
    """Simulate a pair of dice."""
    def __init__( self ):
        "Create the two Die objects."
        self.myDice = ( Die(), Die() )
    def roll( self ):
        "Return a random roll of the dice."
        for d in self.myDice:
            d.roll()
    def getTotal( self ):
        "Return the total of two dice."
        t= 0
        for d in self.myDice:
            t += d.getValue()
        return t
    def getTuple( self ):
        "Return a tuple of the dice values."
        return tuple( [d.getValue() for d in self.myDice] )
    def hardways( self ):
        "Return True if this is a hardways roll."
        return self.myDice[0].getValue() == self.myDice[1].getValue()

	This is the definition of a single Die, from the die.py example. We didn't repeat it here to save some space in the example.
	This class, Dice, defines a pair of Die instances.
	The __init__ method creates an instance variable, myDice, which has a tuple of two instances of the Die class.
	The roll method changes the overall state of a given Dice object by changing the two individual Die objects it contains. This manipulator uses a for loop to assign each of the internal Die objects to d. In the loop it calls the roll method of the Die object, d. This technique is called delegation: a Dice object delegates the work to two individual Die objects. We don't know, or care, how each Die computes it's next value.
	The getTotal method computes a sum of all of the Die objects. It uses a for loop to assign each of the internal Die objects to d. It then uses the getValue method of d. This is the official interface method; by using it, we can remain blissfully unaware of how Die saves it's state.
	The getTuple method returns the values of each Die object. It uses a list comprehension to create a list of the value instance variables of each Die object. The built-in function tuple converts the list into an immutable tuple.
	The harways method examines the value of each Die objec to see if they are the same. If they are, the total was made "the hard way."

The getTotal and getTuple methods return basic attribute information about the state of the object. These kinds of methods are often called getters because their names start with “get”.

Collaborating Objects. The following function exercises an instance this class to roll a Dice object a dozen times and print the results.

def test2():
    x= Dice()
    for i in range(12):
        x.roll()
        print x.getTotal(), x.getTuple()

This function creates an instance of Dice, called x. It then enters a loop to perform a suite of statements 12 times. The suite of statements first manipulates the Dice object using its roll method. Then it accesses the Dice object using getTotal and getTuple method.

Here's another function which uses a Dice object. This function rolls the dice 1000 times, and counts the number of hardways rolls as compared with the number of other rolls. The fraction of rolls which are hardways is ideally 1/6, 16.6%.

def test3():
    x= Dice()
    hard= 0
    soft= 0
    for i in range(1000):
        x.roll()
        if x.hardways(): hard += 1
        else: soft += 1
    print hard/1000., soft/1000.

Independence. One point of object collaboration is to allow us to modify one class definition without breaking the entire program. As long as we make changes to Die that don't change the interface that Die uses, we can alter the implementation of Die all we want. Similarly, we can change the implementation of Dice, as long as the basic set of methods are still present, we are free to provide any alternative implementation we choose.

We can, for example, rework the definition of Die confident that we won't disturb Dice or the functions that use Dice (test2 and test3). Let's change the way it represents the value rolled on the die. Here's an alternate implemetation of Die. In this case, the private instance variable, value, will have a value in the range 0<=value<=5. When getValue adds 1, the value is in the usual range for a single die, 1≤ n ≤6.

class Die(object):
    """Simulate a 6-sided die."""
    def __init__( self ):
        self.roll()
    def roll( self ):
        self.value= random.randint(0,5)
        retuen self.value
    def getValue( self ):
        return 1+self.value

Since this version of Die has the same interface as other versions of Die in this chapter, it is isomorphic to them. There could be performance differences, depending on the performance of randint and randrange functions. Since randint has a slightly simpler definition, it may process more quickly.

Similarly, we can replace Die with the following alternative. Depending on the performance of choice, this may be faster or slower than other versions of Die.

class Die(object):
    """Simulate a 6-sided die."""
    def __init__( self ):
        self.domain= range(1,7)
    def roll( self ):
        self.value= random.choice(self.domain)
        return self.value
    def getValue( self ):
        return self.value