Python tutorials > Object-Oriented Programming (OOP) > Classes and Objects > What is inheritance?

What is inheritance?

Inheritance is a fundamental concept in object-oriented programming (OOP) that allows you to create new classes based on existing classes. The new classes, called subclasses or derived classes, inherit the properties and methods of the existing classes, called superclasses or base classes. This promotes code reusability and establishes a hierarchical relationship between classes.

Basic Inheritance Example

This example demonstrates a simple inheritance scenario. The Animal class is the base class. The Dog and Cat classes are subclasses that inherit from Animal. They inherit the __init__ method (and thus the name attribute) and override the speak method to provide their specific sounds. The Dog and Cat classes inherit the attribute and method.

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print("Generic animal sound")

class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

dog = Dog("Buddy")
cat = Cat("Whiskers")

print(dog.name)
dog.speak()
print(cat.name)
cat.speak()

Concepts Behind the Snippet

  • Base Class (Superclass): The class being inherited from (Animal in the example).
  • Derived Class (Subclass): The class inheriting from the base class (Dog and Cat).
  • Inheritance: The process of inheriting properties and methods from the base class.
  • Method Overriding: When a subclass provides a specific implementation for a method that is already defined in its base class (the speak method).
  • Code Reusability: Inheritance promotes code reusability by allowing subclasses to reuse the code of their base classes.

Real-Life Use Case

Consider a graphical user interface (GUI) framework. You might have a base class called Widget that defines common properties like position, size, and color. Then, you could create subclasses like Button, TextField, and Label that inherit from Widget and add their own specific properties and behaviors. This avoids duplicating code related to the basic widget properties in each subclass. Another example is in game development, where you could have a base class Character and then subclasses like Player, Enemy, NPC inheriting common attributes like health, position, and animation methods but providing unique behaviors.

Best Practices

  • Single Responsibility Principle: Ensure each class has a clear and specific responsibility. Overly complex base classes can lead to problems.
  • Keep Inheritance Hierarchies Shallow: Deep inheritance hierarchies can be difficult to understand and maintain. Aim for a maximum depth of 2-3 levels.
  • Favor Composition over Inheritance: Consider composition (creating classes that contain instances of other classes) as an alternative to inheritance when appropriate. This can often lead to more flexible and maintainable code. For example, instead of inheriting from a `Flying` class, a `Bird` class could have a `wings` attribute that is an instance of a `Wings` class.
  • Use Abstract Base Classes: Use abstract base classes (using the abc module) to define interfaces and ensure that subclasses implement required methods.

Interview Tip

Be prepared to explain the benefits of inheritance (code reusability, reducing redundancy, improved organization) and its potential drawbacks (increased complexity, tight coupling). Be ready to discuss when to use inheritance and when to favor composition. Also, explain the difference between single and multiple inheritance (though Python mostly uses single inheritance with mixin classes).

When to Use Inheritance

Use inheritance when there is a clear "is-a" relationship between classes. For example, a Dog is an Animal. Inheritance is appropriate when the subclass needs to inherit and potentially extend or modify the behavior of the base class. If you find yourself copying and pasting code between classes, inheritance might be a good solution to reduce redundancy.

Memory Footprint

Inheritance can increase the memory footprint slightly because each subclass stores a reference to its base class. However, the primary benefit is reduced code duplication, which often outweighs the small memory overhead. The actual memory usage depends on the size and complexity of the base class and the subclass, but is generally not a significant concern. Modern Python interpreters optimize memory usage, especially when using slots.

Alternatives

  • Composition: Instead of inheriting, a class can contain an instance of another class. This allows for greater flexibility and avoids the tight coupling associated with inheritance.
  • Interfaces (Abstract Base Classes): Define a set of methods that a class must implement, without providing an implementation. This allows for polymorphism and loose coupling.
  • Mixins: Small classes that provide specific functionalities. They can be combined with other classes through multiple inheritance to add features without creating a deep inheritance hierarchy.

Pros

  • Code Reusability: Avoids code duplication by reusing the code of the base class.
  • Reduced Redundancy: Reduces the amount of code that needs to be written and maintained.
  • Improved Organization: Creates a hierarchical relationship between classes, making the code easier to understand and maintain.
  • Polymorphism: Allows objects of different classes to be treated as objects of a common type (base class).

Cons

  • Increased Complexity: Can make the code more complex and difficult to understand, especially with deep inheritance hierarchies.
  • Tight Coupling: Creates a strong dependency between the base class and its subclasses, making it difficult to modify the base class without affecting the subclasses.
  • Fragile Base Class Problem: Changes to the base class can unintentionally break subclasses.
  • Overuse: Can be misused when composition would be a better approach.

← What is encapsulation? What is interface polymorphism? →

FAQ

  • What is the difference between inheritance and composition?

    Inheritance is an "is-a" relationship, where a subclass inherits properties and methods from a base class. Composition is a "has-a" relationship, where a class contains an instance of another class. Composition is generally more flexible and avoids the tight coupling associated with inheritance.
  • What is method overriding?

    Method overriding is when a subclass provides a specific implementation for a method that is already defined in its base class. This allows the subclass to customize the behavior of the inherited method.
  • What is the purpose of using super() in Python?

    The super() function is used to call a method from the parent class. It is commonly used in the __init__ method of a subclass to initialize the attributes of the parent class. It helps avoid code duplication and ensures that the parent class's initialization logic is executed.