Python Inheritance

Put the parent class in brackets after the child's name:

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

    def describe(self):
        return f"{self.name} is an animal"

class Dog(Animal):
    def speak(self):
        return "Woof"

Dog has no __init__ or describe() of its own, yet Dog("Rex").describe() works, because it inherits them from Animal. It also adds a new method, speak(), that plain animals don't have. Read class Dog(Animal) as "a Dog is an Animal".

If a child defines a method with the same name as one in the parent, the child's version is used instead. That's overriding.

Often you want to extend the parent's behaviour rather than replace it completely. super() gives you access to the parent's version:

class SavingsAccount(Account):
    def __init__(self, owner, balance=0, rate=0.03):
        super().__init__(owner, balance)   # let Account set owner and balance
        self.rate = rate                   # then add what's new

Calling super().__init__(...) first is the usual pattern. It runs the parent's set-up code, so you don't repeat it, and then the child adds its own attributes.

A Python class can inherit from more than one parent: class FlyingCar(Car, Aircraft):. When the same method exists in several ancestors, Python decides which one to use by following the method resolution order (MRO), a single fixed list of classes it checks in turn. You can print it:

class A:
    def hello(self):
        return "A"

class B(A):
    pass

class C(A):
    def hello(self):
        return "C"

class D(B, C):
    pass

print([cls.__name__ for cls in D.__mro__])  # ['D', 'B', 'C', 'A', 'object']
print(D().hello())                          # C

D doesn't define hello, neither does B, so Python finds it in C before reaching A. super() follows the same order, which is why it is safer than naming the parent class directly. In everyday code, multiple inheritance is mostly used for small mixin classes that add one capability, such as logging or JSON export.

Polymorphism means "many forms": different classes provide the same method, each in its own way, and your code can call it without caring which class it's dealing with.

for animal in [Dog("Rex"), Cat("Tom"), Cow("Daisy")]:
    print(animal.speak())

The loop doesn't check types or use a long if. Each object knows how to speak(). Adding a new animal later only means writing a new class; the loop doesn't change. This is one of the main benefits of object-oriented design.

isinstance(obj, Class) checks whether an object is an instance of a class or any of its subclasses: isinstance(Dog("Rex"), Animal) is True. issubclass(Dog, Animal) checks the classes themselves.

Inheritance isn't always the answer. If the relationship is "has a" rather than "is a", use composition: give one object another object as an attribute. A car has an engine, so a Car should store an Engine object, not inherit from Engine. Composition keeps classes small and flexible, and many experienced developers prefer it unless there's a clear "is a" relationship.