Inheritance

Why Inheritance Matters

Imagine you are building a school management system. You need to represent both teachers and students. Both have names, ages, and addresses. Both can introduce themselves. Without inheritance, you would write the name, age, and address attributes twice—once in a Teacher class and once in a Student class. You would also duplicate the introduction logic. This duplication makes your code harder to maintain: if you discover a bug in how addresses are stored, you have to fix it in two places. Inheritance solves this problem by letting you define shared behavior once in a base class, then have Teacher and Student inherit that shared behavior while adding only what makes each one unique.

The Type and Subtype Relationship

Inheritance creates a type/subtype relationship. When you say 'Teacher inherits from SchoolMember,' you are declaring that Teacher is a specialized kind of SchoolMember. Every Teacher is a SchoolMember, but not every SchoolMember is a Teacher. This relationship is fundamental to how inheritance works: the subclass (Teacher) becomes a more specific version of the base class (SchoolMember). The subclass automatically receives all the attributes and methods of the base class, then can add its own specialized attributes and methods on top.

Python Inheritance Syntax

To use inheritance in Python, the base class name is listed in a tuple following the new class's own name in its definition. The syntax is: class ChildClass(ParentClass):. The parentheses after the child class name contain the parent class (or classes, if using multiple inheritance). When you define a child class this way, it automatically inherits all attributes and methods from the parent class.

class SchoolMember:
    def __init__(self, name, age, address):
        self.name = name
        self.age = age
        self.address = address
    
    def introduce(self):
        return f"I am {self.name}, age {self.age}, living at {self.address}"

class Teacher(SchoolMember):
    def __init__(self, name, age, address, subject, salary):
        super().__init__(name, age, address)
        self.subject = subject
        self.salary = salary
    
    def grade_assignment(self, student_name, grade):
        return f"Graded {student_name}'s assignment: {grade}"

class Student(SchoolMember):
    def __init__(self, name, age, address, student_id, grade_level):
        super().__init__(name, age, address)
        self.student_id = student_id
        self.grade_level = grade_level
    
    def submit_homework(self, assignment):
        return f"Submitted: {assignment}"

How Inheritance Flows in Action

When you create an instance of Teacher or Student, the inheritance relationship means both the parent class's initialization and the child class's initialization run. The child class receives all the parent's attributes and methods automatically, so a Teacher instance has name, age, address, and introduce() even though those are defined in SchoolMember. The child class can then add specialized attributes and methods that only it has.

teacher = Teacher('Alice', 35, '123 Oak Street', 'Math', 50000)
student = Student('Bob', 14, '456 Elm Street', 1001, 9)

print(teacher.introduce())
print(student.introduce())
print(teacher.grade_assignment('Bob', 'A'))
print(student.submit_homework('Math Project'))

I am Alice, age 35, living at 123 Oak Street
I am Bob, age 14, living at 456 Elm Street
Graded Bob's assignment: A
Submitted: Math Project

Multiple Inheritance

When more than one class is listed in that inheritance tuple, this is specifically called multiple inheritance. For example, you could write class TeachingAssistant(Teacher, Student): to create a class that inherits from both Teacher and Student. Python will look for methods and attributes in the order the parent classes are listed. Multiple inheritance is powerful but can become complex, so it is used less frequently than single inheritance in practice.

class TeachingAssistant(Teacher, Student):
    def __init__(self, name, age, address, subject, salary, student_id, grade_level):
        Teacher.__init__(self, name, age, address, subject, salary)
        self.student_id = student_id
        self.grade_level = grade_level

Common Mistakes with Inheritance

• Forgetting to call super().__init__() in the child class's __init__ method

  The parent class's __init__ is not called, so name, age, and address are never initialized. Any code that tries to access teacher.name will fail.

  Fix: Always call super().__init__() with the appropriate arguments before setting child-specific attributes: super().__init__(name, age, address)

• Assuming a child class instance is an instance of the parent class

  Actually, this is correct—a child class instance IS an instance of the parent class. The mistake is the opposite: assuming a parent class instance is an instance of the child class, which is false.

  Fix: Remember: every Teacher is a SchoolMember, but not every SchoolMember is a Teacher. Use isinstance() correctly to check the actual type.

• Creating a deep inheritance hierarchy when composition would be simpler

  Deep hierarchies are hard to understand and maintain. If you only need Dog to have certain behaviors, you do not need four levels of inheritance.

  Fix: Keep inheritance hierarchies shallow and focused. Use composition (having an object contain another object) when the relationship is not a true type/subtype relationship.

• Overriding a parent method without understanding the parent's behavior

  The child's override replaces the parent's method entirely. If the parent's method has important logic, you lose it.

  Fix: If you need to extend a parent method, call super().method_name() to preserve the parent's behavior, then add your own: return super().introduce() + f', teaching {self.subject}'

When to Use Inheritance

Use inheritance when you have a genuine type/subtype relationship. Ask yourself: Is the child class a specialized version of the parent class? Can you say 'every instance of the child class is also an instance of the parent class'? If yes, inheritance is appropriate. If you are just trying to reuse some code but the relationship is not a true type/subtype, consider composition instead—having one class contain an instance of another class.

Practice: Building Your Own Inheritance Hierarchy

Summary

Inheritance is a core feature of object-oriented programming that lets you create a type/subtype relationship between classes. A subclass inherits all attributes and methods from its parent class, then adds or overrides them to create specialized behavior. The Python syntax is simple: class Child(Parent):. The main benefit is code reuse—shared behavior lives in the parent class once, and multiple child classes can inherit it without duplication. Use inheritance for genuine 'is-a' relationships, keep hierarchies shallow, always call super().__init__() in child constructors, and remember that every instance of a child class is also an instance of the parent class.