Per saperne di piu sulla programmazione oggetti

Definizione di una Classe con Costruttore

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

    def descrizione(self):
        return f"Sono un {self.tipo} di nome {self.nome}"

Creazione di un oggetto (istanza della classe)

mio_animale = Animale(nome="Fido", tipo="cane")

# Chiamata al metodo della classe
print(mio_animale.descrizione())  # Stampa "Sono un cane di nome Fido"

In questo esempio, la classe `Animale` ha un costruttore (`__init__`) che viene chiamato automaticamente quando si crea un nuovo oggetto.
Il parametro `self` è un riferimento all'istanza corrente della classe

Ereditarietà e uso di `super`

class AnimaleDomestico(Animale):
    def __init__(self, nome, tipo, padrone):
        super().__init__(nome, tipo)  # Chiamata al costruttore della classe base (Animale)
        self.padrone = padrone

    def descrizione(self):
        animale_descrizione = super().descrizione()  # Chiamata al metodo della classe base (Animale)
        return f"{animale_descrizione} e il mio padrone è {self.padrone}"

# Creazione di un oggetto della classe derivata
mio_animale_domestico = AnimaleDomestico(nome="Whiskers", tipo="gatto", padrone="Alice")

# Chiamata al metodo della classe derivata
print(mio_animale_domestico.descrizione())
# Stampa "Sono un gatto di nome Whiskers e il mio padrone è Alice"

Qui, `AnimaleDomestico` è una sottoclasse di `Animale`, e `super().__init__(nome, tipo)` chiama il costruttore della classe base.
Anche `super().descrizione()` chiama il metodo della classe base. In breve:
`self` si riferisce all'istanza corrente della classe,
`super()` viene utilizzato per accedere ai metodi e ai costruttori della classe base,
il costruttore (`__init__`) è chiamato automaticamente quando viene creato un nuovo oggetto della classe.

Ecco due esempi di utilizzo della funzione `super()` in Python

Esempio 1: Ereditarietà Singola

class Veicolo:
    def __init__(self, marca, modello):
        self.marca = marca
        self.modello = modello

    def descrizione(self):
        return f"{self.marca} {self.modello}"

class Auto(Veicolo):
    def __init__(self, marca, modello, tipo_carburante):
        super().__init__(marca, modello)  # Chiamata al costruttore della classe base
        self.tipo_carburante = tipo_carburante

    def descrizione(self):
        veicolo_descrizione = super().descrizione()  # Chiamata al metodo della classe base
        return f"{veicolo_descrizione}, Alimentata a {self.tipo_carburante}"

# Utilizzo delle classi
auto1 = Auto("Toyota", "Camry", "Benzina")
print(auto1.descrizione())

In questo esempio, `Auto` eredita da `Veicolo`.
`super().__init__(marca, modello)` chiama il costruttore della classe base (`Veicolo`)
`super().descrizione()` chiama il metodo della classe base per ottenere la descrizione del veicolo.

Esempio 2: Ereditarietà Multipla

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

    def info_mammifero(self):
        return f"Nome: {self.nome}"

class Volatile:
    def __init__(self, tipo_ali):
        self.tipo_ali = tipo_ali

    def info_volatile(self):
        return f"Tipo ali: {self.tipo_ali}"

class Pipistrello(Mammifero, Volatile):
    def __init__(self, nome, tipo_ali, abitudine_notturna=True):
        # Chiamate ai costruttori delle classi base usando super()
        super().__init__(nome)
        super(Volatile, self).__init__(tipo_ali)
        self.abitudine_notturna = abitudine_notturna

    def info_pipistrello(self):
        mammifero_info = super(Mammifero, self).info_mammifero()
        volatile_info = super(Volatile, self).info_volatile()
        abitudine_info = "Si muove di notte" if self.abitudine_notturna else "Si muove di giorno"
        return f"{mammifero_info}, {volatile_info}, {abitudine_info}"

# Utilizzo della classe
pipistrello1 = Pipistrello("Bruce", "Lunghe")
print(pipistrello1.info_pipistrello())