After this lesson, you will be able to:

• Declare a subclass that inherits behavior from a parent class.
• Use super().__init__(...) to initialize inherited instance state before adding new attributes.
• Extend a parent's instance method with super().method(...) instead of copying its logic.
• Recognize when inherited state or methods must be preserved while customizing a subclass.

Inheritance lets one class reuse the behavior of another. Put the parent class in parentheses:

class Job:
    pass

class SpecialJob(Job):
    pass

A subclass inherits accessible methods and attributes from its parent. It can also define its own attributes and methods. When the subclass defines an __init__, the parent's initializer is not automatically called. Call super().__init__(...) to establish the parent's attributes before adding new ones.

The super() helper also lets an overriding instance method call the parent's implementation. That avoids duplicating a working base behavior. The next lesson will focus on method overriding and polymorphism in depth; for now, use an override only when it needs to extend what the parent already does.

1. Reuse an inherited method

A subclass can call a parent method even when it does not define that method itself.

class Device:
    def __init__(self, identifier):
        self.identifier = identifier

    def label(self):
        return f"Device {self.identifier}"

class Laptop(Device):
    pass

print(Laptop("A14").label())

Output:

Device A14

Laptop inherited the label() method from Device.

2. Initialize inherited and new attributes

Use super().__init__ to keep the parent's setup intact.

class Account:
    def __init__(self, owner):
        self.owner = owner

class PremiumAccount(Account):
    def __init__(self, owner, credits):
        super().__init__(owner)
        self.credits = credits

print(f"{PremiumAccount('Noor', 50).owner}: premium")

Output:

Noor: premium

The parent creates owner; the child adds credits.

3. Extend a method with super()

The child can reuse a parent's result and append its own information.

class Message:
    def __init__(self, text):
        self.text = text

    def summary(self):
        return self.text

class UrgentMessage(Message):
    def summary(self):
        return f"URGENT: {super().summary()}"

print(UrgentMessage("Restart required").summary())

Output:

URGENT: Restart required

The overridden method calls the parent's method, rather than rewriting its behavior.

4. Preserve one base behavior across objects

Inherited methods can be called on different subclasses or parent instances.

class Counter:
    def __init__(self, value):
        self.value = value

    def double(self):
        return self.value * 2

class LabeledCounter(Counter):
    def __init__(self, value, label):
        super().__init__(value)
        self.label = label

print(LabeledCounter(7, "items").double())

Output:

14

The subclass adds label without losing the parent's double() method.

• Defining a child __init__ but forgetting to initialize parent attributes.
• Passing self manually to super().__init__.
• Calling a parent method without its required arguments.
• Copying the parent's implementation instead of extending it with super().