Ereditarietà in Python

1. Introduzione

• Documentazione Ufficiale

L’ereditarietà (inheritance) è un principio fondamentale della programmazione orientata agli oggetti (OOP). Consente di riutilizzare e estendere il codice di una classe già esistente.

L’idea è semplice: una classe figlia (o sottoclasse) eredita attributi e metodi da una classe madre (o superclasse), potendo eventualmente modificarli o aggiungerne di nuovi.

2. Creare una classe base e una classe derivata

class Animale:
    def __init__(self, nome):
        self.nome = nome

    def parla(self):
        print("L'animale emette un suono.")

Ora creiamo una classe derivata che eredita da Animale:

class Cane(Animale):
    def parla(self):
        print("Bau!")

Uso:

a = Animale("Creatura")
c = Cane("Fido")

a.parla()   # L'animale emette un suono.
c.parla()   # Bau!

3. Il costruttore e la funzione super()

Quando una sottoclasse ha un proprio costruttore __init__, può comunque richiamare quello della classe base tramite super().

class Animale:
    def __init__(self, nome):
        self.nome = nome

class Cane(Animale):
    def __init__(self, nome, razza):
        super().__init__(nome)     # chiama il costruttore della superclasse
        self.razza = razza

Uso:

c = Cane("Fido", "Labrador")
print(c.nome, c.razza) # Output: Fido Labrador

4. Aggiungere nuovi metodi o estendere quelli esistenti

Le sottoclassi possono aggiungere nuovi metodi oppure estendere quelli ereditati.

class Animale:
    def parla(self):
        print("Suono generico.")

class Cane(Animale):
    def parla(self):
        super().parla()      # chiama il metodo originale
        print("Bau!")

c = Cane()
c.parla()

Output:

Suono generico.
Bau!

5. Verificare relazioni di ereditarietà

In Python una classe può ereditare da più superclassi. È una caratteristica potente, ma da usare con attenzione.

class Volante:
    def vola(self):
        print("Sto volando!")

class Nuotante:
    def nuota(self):
        print("Sto nuotando!")

class Anatra(Volante, Nuotante):
    pass

a = Anatra()
a.vola()
a.nuota()

Output:

Sto volando!
Sto nuotando!

7. La MRO (Method Resolution Order)

La MRO definisce l’ordine in cui Python cerca un attributo o metodo nelle classi coinvolte nell’ereditarietà multipla.

Possibile visualizzarla con:

print(Anatra.mro())

Output (esempio):

[<class '__main__.Anatra'>, <class '__main__.Volante'>, <class '__main__.Nuotante'>, <class 'object'>]

8. Classi astratte

A volte vogliamo definire una classe base che non sia istanziabile, ma che serva solo da modello per altre classi. In Python si possono creare usando il modulo abc.

from abc import ABC, abstractmethod

class Animale(ABC):
    @abstractmethod
    def parla(self):
        pass

class Cane(Animale):
    def parla(self):
        print("Bau!")

Uso:

c = Cane()
c.parla()

9. Quiz a risposta multipla

Mettiti alla prova

0/10 risposte

1. 1) In Python, cosa rappresenta l'ereditarietà?

   AUn modo per creare copie identiche di una classeBUn meccanismo che permette a una classe di ereditare attributi e metodi da un'altra classeCUn metodo per nascondere gli attributi di una classeDUna funzione per collegare più file Python

2. 2) Qual è la parola chiave usata per creare una sottoclasse in Python?

   AinheritsBextendsCclass Figlia(ClasseMadre)Dsubclass

3. 3) Cosa fa la funzione super() in una sottoclasse?

   ARichiama i metodi privati della sottoclasseBElimina gli attributi ereditatiCRichiama metodi e costruttori della superclasseDDuplica la superclasse

4. 4) Se una sottoclasse ridefinisce un metodo della superclasse, cosa succede?

   APython genera un errore di ereditarietàBIl metodo della sottoclasse sostituisce quello della superclasseCEntrambi i metodi vengono eseguiti in ordine casualeDIl metodo originale viene cancellato dal codice

5. 5) Come si definisce una classe astratta in Python?

   AUsando la parola chiave abstract classBEreditando da ABC e usando @abstractmethodCUsando la funzione abs() nella classeDNon è possibile creare classi astratte in Python

6. 6) Quale tra questi metodi serve per verificare se un oggetto appartiene a una classe o sottoclasse?

   Ahasattr()Bissubclass()Cisinstance()Dsuper()

7. 7) In un'ereditarietà multipla, come decide Python l'ordine di ricerca dei metodi?

   AIn base all'ordine alfabetico delle classiBUsando il Method Resolution Order (MRO)CSeguendo la gerarchia inversa delle classiDIn modo casuale a ogni esecuzione

8. 8) Quale delle seguenti affermazioni sul polimorfismo è corretta?

   APermette di usare lo stesso nome di metodo in classi diverse con comportamenti differentiBSignifica che una classe può avere più di un costruttoreCRende i metodi privati accessibili da sottoclassiDServe solo nelle interfacce grafiche

9. 9) Cosa restituisce la chiamata print(ClasseFiglia.mro())?

   AUn elenco dei metodi ereditatiBL'ordine di risoluzione dei metodi tra le classi della gerarchiaCI parametri del costruttore della superclasseDI nomi di tutti gli attributi pubblici della classe

10. 10) Quando è opportuno usare una classe astratta?

    AQuando vogliamo creare una classe che non deve essere istanziata ma solo estesaBQuando serve una classe con metodi statici soltantoCQuando la classe deve ereditare da più classi contemporaneamenteDQuando vogliamo creare un costruttore privato

Controlla le risposte

10. Esercizi

10.1 Esercizio

Creare una gerarchia di classi che rappresenti veicoli:

• Classe base Veicolo con attributo marca e metodo info().
• Classe Auto che eredita da Veicolo e aggiunge porte.
• Classe Moto che eredita da Veicolo e aggiunge cilindrata.
• Sovrascrivere info() in entrambe le sottoclassi per mostrare informazioni specifiche.
• Creare alcune istanze e verifica l’uso di isinstance() e issubclass().

10.2 Esercizio — Gestione di un Parco Veicoli Aziendale

Creare un programma orientato agli oggetti che gestisca diversi tipi di veicoli, sfruttando ereditarietà, polimorfismo e classi astratte.

Specifiche:

• Creare una classe base astratta Veicolo con:

  • attributi: marca, modello, anno, targa
  • metodo descrizione() che restituisce una stringa con le informazioni del veicolo
  • metodo eta() che calcola l’età come differenza tra la data attuale e l’anno di immatricolazione
  • metodo astratto calcola_costo_manutenzione()

• Creare le sottoclassi:

  • Auto → aggiunge numero_porte e tipo_carburante
  • Moto → aggiunge cilindrata
  • Camion → aggiunge portata_massima

• In ciascuna sottoclasse:

  • Sovrascrivere calcola_costo_manutenzione() con formule diverse
    • Auto: 100 + 10 * età
    • Moto: 80 + 5 * età
    • Camion: 200 + 20 * età
  • Ridefinire descrizione() per includere gli attributi specifici

• Creare una classe ParcoVeicoli che:

  • Contenga una lista di veicoli
  • Permetta di aggiungere nuovi veicoli (aggiungi_veicolo())
  • Stampi tutti i veicoli con stampa_veicoli()
  • Calcoli il costo totale di manutenzione annuale
  • Ordini i veicoli in base al costo di manutenzione

• Aggiungere un metodo di classe numero_veicoli() nella classe base per contare quanti veicoli sono stati creati.

Suggerimento:

Usare il modulo datetime per calcolare l’età dei veicoli