Home > Articles > Open Source > Python

  • Print
  • + Share This
This chapter is from the book

This chapter is from the book

4.5 Single Inheritance

Classes without inheritance are enough for what is called object-based programming. You can create new data types (called abstract data types) that have their own operations. But for object-oriented programming, you need inheritance. Python allows a class to inherit from one or more classes—multiple inheritance. We discuss single inheritance first, and then expand the discussion to multiple inheritance.

A class declaration with single inheritance has the form:

class name(superclass):
    suite

where superclass is an expression that yields a class object. In other languages, like Java, the class declarations are handled by the compiler, so the superclass would be a name of a class. In Python, class declarations are executable, so the superclass is an expression that yields a class at run-time. You could have an array of classes and a loop creating a subclass of each, something like:

for i in range(len(X)):
    class C(Y[i]): ...
    X[i]=C

although it is hard, offhand, to think of any use for doing so. Executing the same class declaration more than once is more likely to be a bug.

When we say the subclass inherits from its superclass, we mean that the subclass starts with all the superclass's methods. The subclass can add new methods and attributes beyond those possessed by the superclass. The subclass can override methods that it would inherit from its superclass; that is, it can provide its own declarations of some of the methods declared in the superclass. Then, when someone calls the method, they get the version provided by the subclass.

Because objects in the subclass get all the attributes and methods of the superclass, they can be used in any place an object of the superclass can be. They will respond to the same operations. This gives an "is-a" relationship between instances of the subclass and its superclass. If class y inherits from class X, an instance of Y is an X. The is-a relationship provides what is called "polymorphism." At a particular place in the program, you may not be sure precisely what class of object is being operated on, only that it has a certain interface, that is, that it will respond to certain method calls. (Actually, polymorphism is the wrong name. It means "multiple forms," but the interface is more analogous to a form and the implementation to a substance. The interface is the same. It is the implementations that can be different.)

So what do you use inheritance for? It has a great many different uses. We discuss some of them here and some in later chapters. Many of the uses have been given names and have been classified as object-oriented design patterns, which we discuss in Chapter 5.

One use for inheritance is to add functionality. Consider the class settableCounter in Figure 4–3. It is a subclass of class counter shown in Figure 4–2. As we've already seen, counter provides three things to its user: an attribute count that contains the current count; an __init__() method that allows the counter to be initialized to a particular value or to default to zero; and a bump() method that allows you to increase the count either by one by default or by an explicit amount, positive or negative.

Figure 4-3Figure 4–3 Class settableCounter.

The class settableCounter adds a method set() that allows you to assign an explicit value to the current count. You may be wondering why we would need a set() method. Why not just assign a value to count? Well, with the current implementation, that would work; but does counter actually promise that you will be able to assign to count? It is possible to implement counter so that you can only read count, but not assign to it. The actual count can be hidden. We'll see how to do this in Chapter 14.

Here is an example of a settableCounter in action:

>>> from settableCounter import settableCounter
>>> x=settableCounter(1)
>>> x.count
1
>>> x.bump()
2
>>> x.set(10)
>>> x.count
10

Clearly, when we create a settableCounter, we get an object that has the methods declared in its class and in its superclass, counter. When we created it, the __init__() method in the superclass was executed, setting count initially to 1. We got at the attribute count as easily as in a counter object. When we called bump(), we called the bump() method declared in the superclass, counter. When we called set(), we got the method declared in settableCounter.

Here's how it works: As discussed earlier, when we access an object using the dot operator—for example, x.y—Python first looks for a y attribute of object x. If it finds one, that's what it returns. Otherwise, it looks through a series of classes for a definition. It first looks in x's class. Then, if it doesn't find it there, it looks in x's superclass. It will keep on looking in superclasses until it finds the class attribute y or it comes to a class that has no superclasses.

In the settableCounter example, when we referred to x.count, Python found it in x's dictionary of attributes. When we referred to set(), Python found it in x's class object. When we referred to bump(), Python found it in x's class's superclass. Similarly, when we created a settableCounter, Python found the __init__() method in the superclass, counter, and executed that. These namespaces are shown in the contour diagram in Figure 4–4. The boxes represent nested namespaces. You start searching for a name in the innermost name space and move to each enclosing namespace in turn.

Figure 4-4Figure 4–4 Contour model of scopes (namespaces) in a settableCounter instance.

  • + Share This
  • 🔖 Save To Your Account