Introduction to Inheritance

Inheritance is a core concept in Object-Oriented Programming (OOP) that allows a class (subclass) to inherit attributes and methods from another class (superclass). It promotes code reuse and makes code more organized.

In this lesson, you’ll learn how to implement inheritance in Python and understand its benefits.

Defining a Superclass

A superclass is the base class from which other classes inherit. It is defined like any other class:

# Defining a superclass
class Animal:
    def speak(self):
        print("Animal speaks")

Creating a Subclass

A subclass inherits attributes and methods from a superclass. To define a subclass, pass the superclass name as a parameter:

# Defining a subclass
class Dog(Animal):
    def speak(self):
        print("Dog barks")

Overriding Methods

A subclass can override methods from the superclass to provide specific behavior:

# Overriding methods in a subclass
class Dog(Animal):
    def speak(self):
        print("Dog barks")

animal = Animal()
animal.speak()  # Outputs: Animal speaks

dog = Dog()
dog.speak()  # Outputs: Dog barks

Using the super() Function

The super() function allows you to call methods from the superclass in the subclass:

# Using super() to call superclass methods
class Dog(Animal):
    def speak(self):
        super().speak()
        print("Dog barks")

Multiple Inheritance

Python supports multiple inheritance, where a subclass can inherit from more than one superclass:

# Example of multiple inheritance
class Flyer:
    def fly(self):
        print("Flying")

class Swimmer:
    def swim(self):
        print("Swimming")

class Duck(Flyer, Swimmer):
    pass

Checking Class Relationships

You can check class relationships using the isinstance() and issubclass() functions.

# Checking class relationships
# Checking if an object is an instance of a class
print(isinstance(Dog(), Dog))  # Outputs: True

# Checking if a class is a subclass of another
print(issubclass(Dog, Animal))  # Outputs: True

Common Mistakes with Inheritance

Here are some mistakes to avoid:

• Overriding methods without calling super() when needed.
• Confusing method resolution order (MRO) in multiple inheritance.
• Using inheritance when composition might be a better choice.

What Did We Learn?

In this lesson, you learned:

• How to define superclasses and subclasses.
• How to override methods and use super().
• How multiple inheritance works in Python.

Great job! Let’s move to the next topic.