When a class is derived from many base classes it is called?
|
In this article, you’ll explore inheritance and composition in Python. Inheritance and composition are two important concepts in object oriented programming that model the relationship between two classes. They are the building blocks of object oriented design, and they help programmers to write reusable code. Show
By the end of this article, you’ll know how to:
Free Bonus: Click here to get access to a free Python OOP Cheat Sheet that points you to the best tutorials, videos, and books to learn more about Object-Oriented Programming with Python. What Are Inheritance and Composition?Inheritance and composition are two major concepts in object oriented programming that model the relationship between two classes. They drive the design of an application and determine how the application should evolve as new features are added or requirements change. Both of them enable code reuse, but they do it in different ways. Remove adsWhat’s Inheritance?Inheritance models what is called an is a relationship. This means that when you have a Inheritance is represented using the Unified Modeling Language or UML in the following way:  Classes are represented as boxes with the class name on top. The inheritance relationship is represented by an arrow from the derived class pointing to the base class. The word extends is usually added to the arrow. Note: In an inheritance relationship:
Let’s say you have a base class This is known as the Liskov substitution principle. The principle states that “in a computer program, if You’ll see in this article why you should always follow the Liskov substitution principle when creating your class hierarchies, and the problems you’ll run into if you don’t. What’s Composition?Composition is a concept that models a has a relationship. It enables creating complex types by combining objects of other types. This means that a class UML represents composition as follows: Composition is represented through a line with a diamond at the composite class pointing to the component class. The composite side can express the cardinality of the relationship. The cardinality indicates the number or valid range of In the diagram above, the
Note: Classes that contain objects of other classes are usually referred to as composites, where classes that are used to create more complex types are referred to as components. For example, your Composition enables you to reuse code by adding objects to other objects, as opposed to inheriting the interface and implementation of other classes. Both An Overview of Inheritance in PythonEverything in Python is an object. Modules are objects, class definitions and functions are objects, and of course, objects created from classes are objects too. Inheritance is a required feature of every object oriented programming language. This means that Python supports inheritance, and as you’ll see later, it’s one of the few languages that supports multiple inheritance. When you write Python code using classes, you are using inheritance even if you don’t know you’re using it. Let’s take a look at what that means. Remove adsThe Object Super ClassThe easiest way to see inheritance in Python is to jump into the and write a little bit of code. You’ll start by writing the simplest class possible: >>> You declared a class >>> returns a list of all the members in the specified object. You have not declared any members in >>> As you can see, the two lists are nearly identical. There are some additional members in This is because every class you create in Python implicitly derives from Note: In Python 2, you have to explicitly derive from Exceptions Are an ExceptionEvery class that you create in Python will implicitly derive from You can see the problem using the Python interactive interpreter: >>> You created a new class to indicate a type of error. Then you tried to use it to raise an exception. An exception is raised but the output states that the exception is of type The correct way to define your error type is the following: >>> As you can see, when you raise Creating Class HierarchiesInheritance is the mechanism you’ll use to create hierarchies of related classes. These related classes will share a common interface that will be defined in the base classes. Derived classes can specialize the interface by providing a particular implementation where applies. In this section, you’ll start modeling an HR system. The example will demonstrate the use of inheritance and how derived classes can provide a concrete implementation of the base class interface. The HR system needs to process payroll for the company’s employees, but there are different types of employees depending on how their payroll is calculated. You start by implementing a The Now, you implement a base class The HR system requires that every For example, administrative workers have a fixed salary, so every week they get paid the same amount: You create a derived class The class provides the required The company also employs manufacturing workers that are paid by the hour, so you add an The Finally, the company employs sales associates that are paid through a fixed salary plus a commission based on their sales, so you create a You derive Since The problem with accessing the property directly is that if the implementation of You created your first class hierarchy for the system. The UML diagram of the classes looks like this: The diagram shows the inheritance hierarchy of the classes. The derived classes implement the Interfaces are represented similarly to classes with the word interface above the interface name. Interface names are usually prefixed with a capital The application creates its employees and passes them to the payroll system to process payroll: You can run the program in the command line and see the results: The program creates three employee objects, one for each of the derived classes. Then, it creates the payroll system and passes a list of the employees to its Notice how the >>> While you can instantiate an Abstract Base Classes in PythonThe You can use leading underscores in your class name to communicate that objects of that class should not be created. Underscores provide a friendly way to prevent misuse of your code, but they don’t prevent eager users from creating instances of that class. The in the Python standard library provides functionality to prevent creating objects from abstract base classes. You can modify the implementation of the You derive This change has two nice side-effects:
You can see that objects of type >>> The output shows that the class cannot be instantiated because it contains an abstract method Implementation Inheritance vs Interface InheritanceWhen you derive one class from another, the derived class inherits both:
Most of the time, you’ll want to inherit the implementation of a class, but you will want to implement multiple interfaces, so your objects can be used in different situations. Modern programming languages are designed with this basic concept in mind. They allow you to inherit from a single class, but you can implement multiple interfaces. In Python, you don’t have to explicitly declare an interface. Any object that implements the desired interface can be used in place of another object. This is known as . Duck typing is usually explained as “if it behaves like a duck, then it’s a duck.” To illustrate this, you will now add a The
All these requirements are met by the You can modify the program to use the The program creates a As you can see, the Since you don’t have to derive from a specific class for your objects to be reusable by the program, you may be asking why you should use inheritance instead of just implementing the desired interface. The following rules may help you:
You can now clean up the example above to move onto the next topic. You can delete the You removed the import of the Basically, you are inheriting the implementation of the Notice how the The Class Explosion ProblemIf you are not careful, inheritance can lead you to a huge hierarchical structure of classes that is hard to understand and maintain. This is known as the class explosion problem. You started building a class hierarchy of The
With those requirements, you start to see that You create an The implementation remains the same, but you move the classes to the You run the program and verify that it still works: With everything in place, you start adding the new classes: First, you add a Then you add Now, you can add the The class tracks employees in the The program creates a list of employees of different types. The employee list is sent to the productivity system to track their work for 40 hours. Then the same list of employees is sent to the payroll system to calculate their payroll. You can run the program to see the output: The program shows the employees working for 40 hours through the productivity system. Then it calculates and displays the payroll for each of the employees. The program works as expected, but you had to add four new classes to support the changes. As new requirements come, your class hierarchy will inevitably grow, leading to the class explosion problem where your hierarchies will become so big that they’ll be hard to understand and maintain. The following diagram shows the new class hierarchy: The diagram shows how the class hierarchy is growing. Additional requirements might have an exponential effect in the number of classes with this design. Remove adsInheriting Multiple ClassesPython is one of the few modern programming languages that supports multiple inheritance. Multiple inheritance is the ability to derive a class from multiple base classes at the same time. Multiple inheritance has a bad reputation to the extent that most modern programming languages don’t support it. Instead, modern programming languages support the concept of interfaces. In those languages, you inherit from a single base class and then implement multiple interfaces, so your class can be re-used in different situations. This approach puts some constraints in your designs. You can only inherit the implementation of one class by directly deriving from it. You can implement multiple interfaces, but you can’t inherit the implementation of multiple classes. This constraint is good for software design because it forces you to design your classes with fewer dependencies on each other. You will see later in this article that you can leverage multiple implementations through composition, which makes software more flexible. This section, however, is about multiple inheritance, so let’s take a look at how it works. It turns out that sometimes temporary secretaries are hired when there is too much paperwork to do. The You look at your class design. It has grown a little bit, but you can still understand how it works. It seems you have two options:
Then, you remember that Python supports multiple inheritance, so you decide to derive from both Python allows you to inherit from two different classes by specifying them between parenthesis in the class declaration. Now, you modify your program to add the new temporary secretary employee: You run the program to test it: You get a exception saying that This is because you derived Okay, let’s reverse it: Now, run the program again and see what happens: Now it seems you are missing a Maybe implementing Try it: That didn’t work either. Okay, it’s time for you to dive into Python’s method resolution order (MRO) to see what’s going on. When a method or attribute of a class is accessed, Python uses the class MRO to find it. The MRO is also used by You can evaluate the >>> The MRO shows the order in which Python is going to look for a matching attribute or method. In the example, this is what happens when we create the
Because the parameters don’t match, a You can bypass the MRO by reversing the inheritance order and directly calling That solves the problem of creating the object, but you will run into a similar problem when trying to calculate payroll. You can run the program to see the problem: The problem now is that because you reversed the inheritance order, the MRO is finding the The The program now works as expected because you’re forcing the method resolution order by explicitly telling the interpreter which method we want to use. As you can see, multiple inheritance can be confusing, especially when you run into the . The following diagram shows the diamond problem in your class hierarchy: The diagram shows the diamond problem with the current class design. The diamond problem appears when you’re using multiple inheritance and deriving from two classes that have a common base class. This can cause the wrong version of a method to be called. As you’ve seen, Python provides a way to force the right method to be invoked, and analyzing the MRO can help you understand the problem. Still, when you run into the diamond problem, it’s better to re-think the design. You will now make some changes to leverage multiple inheritance, avoiding the diamond problem. The
This means that everything related to productivity should be together in one module and everything related to payroll should be together in another. You can start making changes to the productivity module: The You can do the same with the The You can now add the necessary classes to the The Notice that you still need to explicitly initialize the salary policies in the constructors. You probably saw that the initializations of You will not want to have this kind of code duplication in more complex designs, so you have to be careful when designing class hierarchies. Here’s the UML diagram for the new design: The diagram shows the relationships to define the You can run the program and see how it works: You’ve seen how inheritance and multiple inheritance work in Python. You can now explore the topic of composition. Remove adsComposition in PythonComposition is an object oriented design concept that models a has a relationship. In composition, a class known as composite contains an object of another class known to as component. In other words, a composite class has a component of another class. Composition allows composite classes to reuse the implementation of the components it contains. The composite class doesn’t inherit the component class interface, but it can leverage its implementation. The composition relation between two classes is considered loosely coupled. That means that changes to the component class rarely affect the composite class, and changes to the composite class never affect the component class. This provides better adaptability to change and allows applications to introduce new requirements without affecting existing code. When looking at two competing software designs, one based on inheritance and another based on composition, the composition solution usually is the most flexible. You can now look at how composition works. You’ve already used composition in our examples. If you look at the
These two attributes are objects that the Another attribute for an You implemented a basic address class that contains the usual components for an address. You made the You implemented >>> When you You can now add the You initialize the Composition is a loosely coupled relationship that often doesn’t require the composite class to have knowledge of the component. The UML diagram representing the relationship between The diagram shows the basic composition relationship between You can now modify the You check to see if the You added a couple of addresses to the Notice how the payroll output for the The Flexible Designs With CompositionComposition is more flexible than inheritance because it models a loosely coupled relationship. Changes to a component class have minimal or no effects on the composite class. Designs based on composition are more suitable to change. You change behavior by providing new components that implement those behaviors instead of adding new classes to your hierarchy. Take a look at the multiple inheritance example above. Imagine how new payroll policies will affect the design. Try to picture what the class hierarchy will look like if new roles are needed. As you saw before, relying too heavily on inheritance can lead to class explosion. The biggest problem is not so much the number of classes in your design, but how tightly coupled the relationships between those classes are. Tightly coupled classes affect each other when changes are introduced. In this section, you are going to use composition to implement a better design that still fits the requirements of the You can start by implementing the functionality of the The It also exposes the previous functionality in the You can now implement the different role classes: Each of the roles you implemented expose a The role classes are independent of each other, but they expose the same interface, so they are interchangeable. You’ll see later how they are used in the application. Now, you can implement the The The implementation of You can now implement the payroll policy classes: You first implement a The other policy classes derive from The The You can now add an The The The class manages the address components and provides a pretty representation of an address. So far, the new classes have been extended to support more functionality, but there are no significant changes to the previous design. This is going to change with the design of the You can start by implementing an The It exposes an The The class exposes a In the same way, it delegates to the The following diagram shows the composition design used: The diagram shows the design of composition based policies. There is a single You can now use this design in your program: You can run the program to see its output: This design is what is called , where classes are composed of policies, and they delegate to those policies to do the work. Policy-based design was introduced in the book Modern C++ Design, and it uses template metaprogramming in C++ to achieve the results. Python does not support templates, but you can achieve similar results using composition, as you saw in the example above. This type of design gives you all the flexibility you’ll need as requirements change. Imagine you need to change the way payroll is calculated for an object at run-time. Remove adsCustomizing Behavior With CompositionIf your design relies on inheritance, you need to find a way to change the type of an object to change its behavior. With composition, you just need to change the policy the object uses. Imagine that our The program gets the employee list from the The new policy is now used by the The check for Mary Poppins, our manager, is now for $2200 instead of the fixed salary of $3000 that she had per week. Notice how we added that business rule to the program without changing any of the existing classes. Consider what type of changes would’ve been required with an inheritance design. You would’ve had to create a new class and change the type of the manager employee. There is no chance you could’ve changed the policy at run-time. Choosing Between Inheritance and Composition in PythonSo far, you’ve seen how inheritance and composition work in Python. You’ve seen that derived classes inherit the interface and implementation of their base classes. You’ve also seen that composition allows you to reuse the implementation of another class. You’ve implemented two solutions to the same problem. The first solution used multiple inheritance, and the second one used composition. You’ve also seen that Python’s duck typing allows you to reuse objects with existing parts of a program by implementing the desired interface. In Python, it isn’t necessary to derive from a base class for your classes to be reused. At this point, you might be asking when to use inheritance vs composition in Python. They both enable code reuse. Inheritance and composition can tackle similar problems in your Python programs. The general advice is to use the relationship that creates fewer dependencies between two classes. This relation is composition. Still, there will be times where inheritance will make more sense. The following sections provide some guidelines to help you make the right choice between inheritance and composition in Python. Inheritance to Model “Is A” RelationshipInheritance should only be used to model an is a relationship. Liskov’s substitution principle says that an object of type Liskov’s substitution principle is the most important guideline to determine if inheritance is the appropriate design solution. Still, the answer might not be straightforward in all situations. Fortunately, there is a simple test you can use to determine if your design follows Liskov’s substitution principle. Let’s say you have a class
If you can justify both relationships, then you should never inherit those classes from one another. Let’s look at a more concrete example. You have a class Before you jump into the implementation, you use Liskov’s substitution principle to evaluate the relationship. A It makes sense. You can justify the relationship and explain why a A It also makes sense. You can justify the relationship and describe the special constraints for each class. This is a good sign that these two classes should never derive from each other. You might have seen other examples that derive First, you implement The Now, you derive The The program creates a The program executes correctly, so it seems that Later on, you need to support resizing You resize the rectangle object and assert that the new area is correct. You can run the program to verify the behavior: The assertion passes, and you see that the program runs correctly. So, what happens if you resize a square? Modify the program, and try to modify the You pass the same parameters to The program shows that the new area is How can you fix that problem? You can try several approaches, but all of them will be awkward. You can override In a small program like this one, it might be easy to spot the causes of the weird behavior, but in a more complex program, the problem will be harder to find. The reality is that if you’re able to justify an inheritance relationship between two classes both ways, you should not derive one class from another. In the example, it doesn’t make sense that This difference in interface justifies not deriving Mixing Features With Mixin ClassesOne of the uses of multiple inheritance in Python is to extend a class features through mixins. A mixin is a class that provides methods to other classes but are not considered a base class. A mixin allows other classes to reuse its interface and implementation without becoming a super class. They implement a unique behavior that can be aggregated to other unrelated classes. They are similar to composition but they create a stronger relationship. Let’s say you want to convert objects of certain types in your application to a dictionary representation of the object. You could provide a This could be a good candidate for a mixin. You start by slightly modifying the The change is very small. You just changed the Now, you add the The Note: This is why we made the role and payroll attributes internal in the As you saw at the beginning, creating a class inherits some members from You iterate through all the items in You can modify the All you have to do is inherit the You apply the mixin to the The program implements a Then, it iterates through all the employees, printing the dictionary representation provided by You leveraged the implementation of Composition to Model “Has A” RelationshipComposition models a has a relationship. With composition, a class In the composition example above, the Other classes like A problem you may run into when using composition is that some of your classes may start growing by using multiple components. Your classes may require multiple parameters in the constructor just to pass in the components they are made of. This can make your classes hard to use. A way to avoid the problem is by using the Factory Method to construct your objects. You did that with the composition example. If you look at the implementation of the This design will work, but ideally, you should be able to construct an The following changes might improve your design. You can start with the First, you make the What you are saying is that the Now, you can do the same with the Again, you make the You will now do the same with the You are basically saying that there should only be one Now, you can work on the You first import the relevant functions and classes from other modules. The You changed the The The You can now change the program to test the changes: You import the relevant functions from the Notice that you can now create an The program works the same as before, but now you can see that a single Take a closer look at the The You are using composition in two different ways. The Still, the relationship between Composition to Change Run-Time BehaviorInheritance, as opposed to composition, is a tightly couple relationship. With inheritance, there is only one way to change and customize behavior. Method overriding is the only way to customize the behavior of a base class. This creates rigid designs that are difficult to change. Composition, on the other hand, provides a loosely coupled relationship that enables flexible designs and can be used to change behavior at run-time. Imagine you need to support a long-term disability (LTD) policy when calculating payroll. The policy states that an employee on LTD should be paid 60% of their weekly salary assuming 40 hours of work. With an inheritance design, this can be a very difficult requirement to support. Adding it to the composition example is a lot easier. Let’s start by adding the policy class: Notice that The The public interface first checks that the You can now make a small change to the You added an The program accesses The check amount for employee Kevin Bacon, who is the sales employee, is now for $1080 instead of $1800. That’s because the As you can see, you were able to support the changes just by adding a new policy and modifying a couple interfaces. This is the kind of flexibility that policy design based on composition gives you. Choosing Between Inheritance and Composition in PythonPython, as an object oriented programming language, supports both inheritance and composition. You saw that inheritance is best used to model an is a relationship, whereas composition models a has a relationship. Sometimes, it’s hard to see what the relationship between two classes should be, but you can follow these guidelines:
ConclusionYou explored inheritance and composition in Python. You learned about the type of relationships that inheritance and composition create. You also went through a series of exercises to understand how inheritance and composition are implemented in Python. In this article, you learned how to:
Recommended ReadingHere are some books and articles that further explore object oriented design and can be useful to help you understand the correct use of inheritance and composition in Python or other languages:
Mark as Completed Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Inheritance and Composition: A Python OOP Guide 🐍 Python Tricks 💌 Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team. Send Me Python Tricks » About Isaac Rodriguez Hi, I'm Isaac. I build, lead, and mentor software development teams, and for the past few years I've been focusing on cloud services and back-end applications using Python among other languages. Love to hear from you here at Real Python. » More about IsaacEach tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are: Alex Aldren Joanna Master Real-World Python Skills With Unlimited Access to Real Python Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas: Level Up Your Python Skills » Master Real-World Python Skills Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas: Level Up Your Python Skills » What Do You Think? Rate this article: Tweet Share Share EmailWhat’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know. Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. and get answers to common questions in our support portal. When a class is derived from several base classes it is called as?A derived class with several base classes is called as multiple inheritance.
When a class serves as base class for many derived classes?When a class serves as base class for many derived classes, the situation is called: polymorphism.
When a class is derived from a base class it gets access to?A derived class can access all the non-private members of its base class. Thus base-class members that should not be accessible to the member functions of derived classes should be declared private in the base class. Constructors, destructors and copy constructors of the base class.
What are base classes also called?The base class is also called superclass or parent class. The derived class is also called a subclass or child class.
|
