7. Defining Classes

When an object is created there are two things that must happen: the space or memory of the object must be reserved, and the space must be initialized by storing some values within the object that make sense for a newly created object. Python takes care of reserving the appropriate amount of space for us when we create an object. We must write some code to initialize the space within the object with reasonable values. What are reasonable values? This depends on the program we are writing.

Creating a circle called shape creates an object that contains the data that we give the constructor when the circle is created. The constructor is called when we write the class name, followed by the arguments to pass to the constructor. In this case, the call to the constructor is Circle (x, y, radius, width=3, color=“red”, outline=“gray”). The constructor takes care of putting the given information in the object. Figure 7.2 shows what the data looks like in the object after calling the constructor.

The data in an object doesn’t get filled in by magic. We must write some code to do this. When programming in an object-oriented language like Python we can write a class definition once and it can be used to create as many objects of that class as we want. To help us do this, Python creates a special reference called self that always points to the object we are currently working with. In this way, inside the class, instead of writing the reference shape we can write the reference self. By using the reference self when writing the code for the class, the code will work with any object we create, not just the one that shape refers to. We are not stuck just creating one circle object because Python creates the special self reference for us. We can create a shape and any other circle we care to create by writing just one Circle class.

In Example 7.3 notice that the formal parameters nearly match the arguments provided when the circle object is created in Example 7.2. The one additional parameter is the extra self parameter provided by Python. When the constructor is called, Python makes a new self local variable for the __init__ function call. This self variable points at the newly created space for the object. Figure 7.3 shows the run-time stack with the self variable pointing at the newly created object. The picture shows what memory looks like just before returning from the __init__ constructor method. There are two activation records on the run-time stack. The first is the activation record for the function that creates the shape by executing the code in Example 7.2. The second activation record is for the __init__ function call (i.e. the call to the constructor). When the program returns from the constructor the top activation record will be popped and the self reference will go away.

If we have a circle object, it would be nice to draw it on a turtle graphics screen. In addition, we may want to change its color, width, or outline color at some point. These are all actions that we want to perform on a circle object and because they change the object in some way they will become mutator methods when implemented. In addition, we may want to access the x, y, and radius values. These are implemented with accessor methods. The mutator and accessor methods must be defined in the class definition.

When a method is called on an object the variable is written first, followed by a dot (i.e. period), followed by the method name. So, for instance, to call the getX method on the shape you would write shape.getX(). When you look at the definition of getX there is one parameter, the self parameter. When you call getX it looks like there are no parameters. Python sets self to point to the same object that appears on the left side of the dot. So, in this example, the self parameter points at the shape object because shape was written on the left hand side of the dot. The picture in Fig. 7.3 applies to calling the getX method as well. When getX is called, an activation record is added to the stack with the self variable pointing at the object. This is true of all classes in Python. When implementing a class the first parameter to all the methods is always self and the object that is on the left hand side of the dot when the method is called is the object that becomes self while executing the method.

A class is an abstraction that helps programmers reuse code. Code reuse is important because it frees us to solve interesting problems while allowing us to forget the details of the classes we use to solve a problem. Code reuse can be achieved between classes as well. When objects are similar in most respects but one is a special case of another the relationship between the classes can be modeled using inheritance. A subclass inherits from a superclass . When using inheritance, the subclass gets everything that’s in the superclass. All data and methods that were a part of the superclass are available in the subclass. The subclass can then add additional data or methods and it can redefine existing methods in the superclass.

Inheritance in Computer Science is like inheritance in genetics. We inherit certain physical characteristics of our birth parents. We may look different from them but typically there are some similarities in hair color, eye color, height and so on. We probably also inherit behaviors from our parents, although this may come from social contact with our parents and isn’t necessarily genetic. Inheritance when applied to Computer Science means that we don’t have to rewrite all the code of the superclass. We can just use it in the subclass.

Inheritance comes up all over the place in OOP. For instance, the Turtle class inherits from the RawTurtle class. The Turtle class is essentially a RawTurtle except that a Turtle creates a TurtleScreen object if one has not already been created.

While the code in Example 7.5 is difficult to completely understand out of context, the Turtle class only consists of a constructor, the minimum amount that can be provided in a derived class. The constructor creates the screen if needed and then calls the RawTurtle’s constructor. Every class, whether a derived class or a base class, must provide its own constructor. When Python creates an object of a certain class, it needs the constructor to determine how the object is initialized. So, the class Turtle in Example 7.5 truly contains the minimal amount of methods possible for a derived class.

Essentially a Turtle and a RawTurtle are identical. It also turns out that Turtles (and RawTurtles) are based on Tkinter. A TurtleScreen contains a ScolledCanvas widget from Tkinter. To create a RawTurtle object we must provide a ScrolledCanvas for the Turtle to draw on.

Because turtle graphics is based on Tkinter, we can write a program that contains widgets including a canvas on which we can draw with turtle graphics! The constructor in Example 7.6 shows us that if we provide a canvas the RawTurtle object will use it. So, we could write a little drawing program that draws circles and rectangles on the screen and integrates other Tk widgets, like buttons for instance.

To begin building a draw application we’ll put a ScrolledCanvas on the left side of a window and some buttons to control drawing on the right side. Since we’ve been looking at a Circle class, we’ll start by drawing circles on the screen. It would be nice to provide the radius for the circle. We can do that with an entry field and a StringVar object as was seen in the last chapter.

The program in Example 7.7 is missing the Circle class which was defined in Example 7.4. The program waits for the Circle button to be pressed once. Then, after each mouse click, a circle is drawn on the ScrolledCanvas on the left side of the window.

Both a Circle and a Rectangle share a lot of common code. It makes sense for that common code to be in one base class that both classes inherit from. If a Shape class were defined that contained the shared code, then it would only have to be written once, which is a requirement of elegant code.

With the Shape base class defined in Example 7.8 the definition of Circle can be simplified.

The Circle class still is the only class that will know how to draw a circle. And, of course, shapes don’t have a radius in general. All the other code that isn’t circle specific is now moved out of the Circle class.

A RawTurtle can move around the screen either with its pen up or its pen down. With its pen up, if we can imagine the turtle as something other than a little sprite, it can be essentially any object that we want it to be in a two dimensional world. The creators of the turtle graphics for Python realized this and added code so that we could change the turtle’s picture to anything we would like. For instance, we might want to animate a bouncing ball. We can replace the turtle’s sprite with an image of a ball.

Turtle graphics can do animation because it can be told to perform an action after an interval of time. A timer can be set in turtle graphics. When the timer goes off, the program can move the ball a little bit. If the interval between timer going off and moving the ball can be small enough that it happens several times a second, then to the human eye it will appear as if the ball is flying through the air.

A ball is a turtle. However, a turtle doesn’t remember in which direction it is moving. It would be nice to have the ball remember the direction it is moving. At least somewhere in the program the ball’s direction must be remembered and it makes sense for the ball to remember its own direction in an object-oriented design of the problem. Figure 7.5 depicts what a ball object should look like. A ball is a turtle, but it is a little more than just a turtle. Again, this is an example of inheritance.

With the ball inheriting from the RawTurtle class we’ll automatically get all the functionality of a turtle. We can tell a ball to goto a location on the screen. We can access the x and y coordinate of the ball by calling the xcor and ycor methods. We can even change its shape so it looks like a ball. As we’ve seen, for the Ball class to inherit from the RawTurtle class, the derived Ball class must implement its own constructor and call the constructor of the base class.

When we are using the ball object in Fig. 7.5 we refer to it using the ball reference. When we are in the Ball class we refer to the object using the self reference as described earlier in this chapter. In Fig. 7.5 the Turtle part of the object is greyed out. This is because the insides of the RawTurtle are available to us, but generally it is a bad idea to access the RawTurtle part of the object directly. Instead, we can use methods to access the RawTurtle part of the object when needed.

The constructor needs to initialize the RawTurtle part of the object as well as the Ball part of the object. To create a RawTurtle we could write turtle = RawTurtle(cv). However, writing this won’t work to initialize the RawTurtle part of the object. A line of code like this would create a new RawTurtle object. Remember, a Ball is a RawTurtle so we don’t want to create a new RawTurtle object. Instead, we want to initialize the RawTurtle part of the Ball object. To do this, we explicitly call the RawTurtle constructor by writing RawTurtle.__init__(self,cv). This calls the RawTurtle’s constructor. In this case we call the constructor by writing the class name followed by a dot followed by the constructor’s name __init__. Since self is a Ball and a RawTurtle, we pass self as the parameter to RawTurtle’s constructor. This line of code initializes the RawTurtle part of the object. Then the Ball specific initialization occurs next.

The Ball class contains one more method, the move method. This is a new method not defined in the RawTurtle class. A Ball can move on the screen while a RawTurtle can not. A Ball moves by (dx,dy) each time the move method is called. The bouncing balls are animated by repeatedly calling the move method on each of the balls in the ballList defined in the main function of the program. Chapter 16 contains the complete code for the bouncing ball example.

Polymorphism is a term used in object-oriented programming that means “many versions” or more than one version. When a subclass defines its own version of a method then the right version, either the subclass version or the base class version of the method, will be called depending on the type of object you have created. To best understand this it helps to look at an example.

Let’s assume we wanted to modify the bouncing ball example so some balls bounce according to a simulated gravity instead of simply bouncing in space forever. It turns out this is very easy to do. We can have Ball objects bounce in space forever and GravityBall objects bounce according to a simulated gravity. Since GravityBalls are nearly the same as Balls we’ll use inheritance to define the GravityBall class. The only real difference will be in the way the GravityBall moves when it is told to move.

A hook is a means by which one program allows another program to modify its behavior. The Python interpreter is a program that allows its behavior to be altered by means of certain hooks it makes available to programmers. Consider the Rational class described earlier in this chapter. With the definition you came up with (or the provided solution in practice Problem 7.1) we can create Rational numbers. However, we can’t do much more than create them at the moment. Without some more code, our rational implementation doesn’t really do us much good.

The addition of the __str__ to the Rational class makes using rational numbers a bit easier because we can quickly convert it to a string when we want a nice representation of it. You can force the __str__ method to be called by calling the str built-in function in Python. So, writing str(x) will force a string version of x to be constructed using the __str__ method. The presence of the __str__ method doesn’t mean that rational numbers will always be converted to a string when printed. Sometimes, the Python interpreter isn’t interested in producing a strictly human-readable presentation of an object. Sometimes a Python readable representation is more appropriate.

In Example 7.13 the __str__ was added and rational numbers printed nicely, but Example 7.14 shows that the Python interpreter does not use __str__ when printing a list of rationals. When printing a list, Python is producing a string representation of the list that would be suitable for Python to evaluate later to rebuild the list. If Python tried to read a number like in the list, it would not know what to do with it. However, there is another hook that allows the programmer to determine the best representation of an object for Python’s purposes.

So, what is the difference between converting to a string and converting to a Python representation? A string version of an object can be in whatever format the programmer determines is best. But, a Python representation should be in a format so that if the built-in Python function eval is called on it, it will evaluate to its original value. The eval function is given an expression contained in a string and evaluates the expression to produce the Python value contained in the string. The appropriate representation for most programmer-defined classes is to use the same form that is required to construct the object in the first place. To construct the rational number we had to write Rational(4,5). For the eval function to correctly evaluate a string containing a Rational, the eval function should be given a rational in the Rational(numerator,denominator) form, not the form.

There is another Python hook that controls how sorting is performed in Python. For any type of object in Python, if there is a natural ordering to those objects, Python can sort a list of them.

If we attempt to sort the list lst from Example 7.14, Python will complain with the following error message: builtins.TypeError: unorderable types: Rational (). While we have an understanding of rational numbers, Python has no way of understanding that the class of Rational numbers represents an ordered collection of values. To tell Python that it is an ordered collection, we have to implement the __lt__ method. To compare any two rational numbers, we must first make sure they have a common denominator. Once we have a common denominator, the numerator of the two rational numbers must be converted to units for the common denominator. It turns out we don’t really need the common denominator at all. We just need the converted numerators. The __lt__ method must return True if the object self references is less than the object that other references and it must return False otherwise.

Once the __lt__ method of Example 7.17 is added to the Rational class, Python understands how to sort them. The sort function sorts a list in place as shown in Example 7.16. If sort is called on the list lst from Example 7.14, Python reorders the list so it contains [Rational(9,12), Rational(4,5)].

These are solutions to the practice problems in this chapter. You should only consult these answers after you have tried each of them for yourself first. Practice problems are meant to help reinforce the material you have just read so make use of them.