Ereditarietà multipla in Python

L’ereditarietà ci consente di utilizzare le funzionalità della classe padre in una classe figlia ed è una caratteristica essenziale della programmazione orientata agli oggetti. Aiuta con la riusabilità e la transitività dei dati dalla classe genitore alla classe figlio e compensa la perdita di dati.

L’ereditarietà multipla si verifica quando la classe figlio eredita i metodi e le funzionalità da due o più classi padre. È utile ricavare tutti i dati in una volta. Tuttavia, d’altra parte, presenta complessità e ambiguità di utilizzo. È ambiguo dire quale caratteristica proviene da quale genitore se più genitori possiedono la stessa caratteristica. Si verifica quando l’ereditarietà multipla non viene utilizzata o implementata correttamente. L’ereditarietà virtuale, l’uso di Method Resolution Order (MRO) e la funzione super() possono in qualche modo ridurne i rischi.

Vediamo un esempio di base di eredità multiple nel codice seguente.

class Father:
    def drive(self):
        print("Father drives his son to school")


class Mother:
    def cook(self):
        print("Mother loves to cook for her son")


class Son(Father, Mother):
    def love(self):
        print("I love my Parents")


c = Son()
c.drive()
c.cook()
c.love()

Produzione:

Father drives his son to school
Mother loves to cook for her son
I love my parents

La classe figlia Son è derivata dalle classi padre Father e Mother, che le consentono di utilizzare le funzioni drive() e cook() per fornire l’output desiderato.

La funzione super() si riferisce alla classe genitore o sorella nella classe figlia ereditata e restituisce un oggetto temporaneo che consente alla classe figlia di utilizzare tutti i metodi della superclasse.

Questo di solito viene fatto in caso di ambiguità quando l’ereditarietà inizia a incrociare percorsi, cioè quando le due classi genitori sono anche derivate dalla classe super base.

Per esempio,

class Animals:
    def __init__(self, animalsName):
        print(animalsName, "is an animal.")


class Mammal(Animals):
    def __init__(self, Name):
        print(Name, "is a mammal.")
        super().__init__(Name)


class donotFly(Mammal):
    def __init__(self, name):
        print(name, "cannot fly.")
        super().__init__(name)


class donotSwim(Mammal):
    def __init__(self, name):
        print(name, "cannot swim.")
        super().__init__(name)


class Cat(donotSwim, donotFly):
    def __init__(self):
        print("A cat.")
        super().__init__("Cat")


cat = Cat()
print("")
bat = donotSwim("Bat")

Produzione:

A cat.
Cat cannot swim.
Cat cannot fly.
Cat is a mammal.
Cat is an animal.

Bat cannot swim.
Bat is a mammal.
Bat is an animal.

Viene creata una classe figlio Cat, ereditata dalle classi con due genitori donotswim e donotfly. Quindi, la classe dei Mammiferi li eredita loro stessi. La classe Mammals eredita inoltre le proprietà della superclasse Animals. Pertanto, in questo caso, abbiamo utilizzato la funzione super() per accedere facilmente ai metodi della superclasse.