An Introduction to Object-Oriented Concepts in Python, Part 3
Like this article? We recommend
Like this article? We recommend
Like this article? We recommend
In this article, I'll continue showing you how to use Python from an object-oriented (OO) point of view. If you're unfamiliar with object-oriented concepts such as inheritance, encapsulation, and polymorphism, read my article "A Primer on Object-Oriented Concepts" before continuing with this article.
This article builds on my earlier article "An Introduction to Object-Oriented Concepts in Python, Part 2." If you haven't read that article already, please read it before reading this article. The concepts in this article will take a closer look at Python inheritance.
If you've been following my Python series, you know how classes in Python work. But so far I haven't addressed how Python classes are used with inheritance. Like other programming languages, in Python it's necessary to derive classes from a parent (base) class that has similiar functionality, but allowing that base functionality to be overridden or extended.
Miss the Earlier Articles in this Python Series?
In case you joined late, here are the earlier installments in this article series:
Python Inheritance
All classes in Python are derived from a special top-level parent class called Object. If we don't explicitly derive a custom parent class from this class, it's implied anyway. For example, let's say we want to create a parent class Animal and then derive this class from Object:
class Animal(Object):
As with Java, Python lingo often refers to the parent class as a superclass. The class that's derived from the superclass is called the subclass. So, as you can see, inheritance in Python begins right away, from the very first definition of a class in your program.
How about an example of a subclass that extends the functionality of a parent class? In this example, Animal will be the parent class and Dog the subclass:
class Animal(object): speakStr = 'Hello from Animal' pass class Dog(Animal): pass bark = Dog.speakStr print(bark)
When running the program, you should see Hello from Animal. As you can see, the Dog class inherited the attribute from the Animal class and printed out the string that the Animal class had originally assigned to it. If we want to override an attribute value in the subclass, do the following:
class Animal(object): speakStr = 'Hello from Animal' pass class Dog(Animal): speakStr = 'Hello from Dog' pass bark = Dog.speakStr; print(bark)
If you run the program, you should get the Hello from Dog result string.
Can we execute a method from the parent class inside the subclass? Sure! Just do the following:
class Animal(object):
def habitat(self):
speakStr = 'Hello from Animal'
print(speakStr)
class Dog(Animal):
pass
bark = Dog()
print(bark.habitat())
What if you want to override a parent class method in the subclass? Simply do this:
class Animal(object):
speakStr = 'Hello from Animal'
def habitat(self):
print('Everywhere')
pass
class Dog(Animal):
speakStr = 'Hello from Dog'
habitatLocation = "Domestic"
def habitat(self,testStr):
print('Everywhere but here')
pass
bark = Dog()
print(bark.habitat("hello"))
In the example above, notice that I also passed in an extra parameter for the habitat method defined in the subclass Dog. When subclassing, you might have the same method defined in multiple classes that require a different number or type of parameters.
If you have programmed in Java or .NET, you'll notice the similarities between these languages and Python class inheritance. However, in Java, when a subclass is derived from a parent class that has non-abstract method definitions, you're forced to override these methods in your subclass. In Python, you don't have to override these methods, as there's only one way to declare the class methods. Also in Java, you often use interfaces instead of using the actual class directly.
What if we wanted to do multiple inheritance in Python? Well, all you have to do is pass the parent class names into the subclass definition, separated by commas, as in the following example:
class Circle(Shape, Canvas):
The Circle subclass can now use, override, or extend the functionality of the Shape and Canvas parent classes. By supporting multiple inheritance, Python supports polymorphism, which is just a fancy term for multiple inheritance. In Java, a Factory class is a good example of using polymorphism.
It's also important to know that you can just as easily inherit functionality from Python's built-in classes. For example, if you want your subclass to have the functionality of a list object, simply pass this object into your subclass.
When inheriting from a single parent class, you can use the super keyword to call its methods from a subclass:
class Animal(object):
def __init__(self):
print("Hello from the Animal class constructor")
pass
class Dog(Animal):
def __init__(self):
super().__init__()
pass
dog = Dog()
print(dog)
If you're inheriting more than one superclass into a subclass, you can use the dot notation to call the methods:
class Dog():
def __init__(self):
print("Woof!")
pass
class Cat():
def __init__(self):
print("Meow!")
pass
class Mammal(Cat, Dog):
def __init__(self):
Cat.__init__(self)
pass
mammal = Mammal()
print(mammal)
If you run this program, you'll get the "Meow!" result string.
Conclusion
In this article, you learned how to use class inheritance in Python programs by passing parent class types into their calling subclass definitions. It's important to note that subclasses can override their parent class attributes and methods, along with handling multiple custom and built-in types using multiple inheritance. Something else to take away from this article is that all classes are implicitly inherited from the object base class.
At this stage, you should be comfortable creating your own small programs using inheritance. Typically, it's a best practice to inherit from only one parent class when subclassing, unless you know you need to inherit from more than one parent class. By not using multiple inheritance, your programs are less complicated and easier to manage. However, for large applications, multiple inheritance can rarely be avoided altogether.
In Part 4 of this series, I'll continue discussing OO concepts by covering exception handling and data structures. These OO concepts are important for well-designed, user-friendly Python programs.