Ereditarietà

L'ereditarietà ci permette di creare una nuova classe a partire da una classe esistente e di estenderla o modificarla.

Ad esempio, possiamo creare una classe Person nel modo seguente:

>>> # definiamo una classe Person
>>> class Person:
...     # definiamo un __init__ che assegna nome e cognome all'istanza
...     def __init__(self, name, surname):
...         self.name = name
...         self.surname = surname
...     # definiamo un metodo "eat" che stampa un messaggio
...     def eat(self, food):
...         print(self.name, 'is eating', food)
...     # definiamo un metodo "sleep" che stampa un messaggio
...     def sleep(self):
...         print(self.name, 'is sleeping')
...
>>> # creiamo un'istanza di Person specificando nome e cognome
>>> p = Person('Ezio', 'Melotti')
>>> # verifichiamo il valore degli attributi name e surname
>>> e.name
'Ezio'
>>> e.surname
'Melotti'
>>> # verifichiamo che i metodi funzionino
>>> p.eat('pizza')
Ezio is eating pizza
>>> p.sleep()
Ezio is sleeping

Se ora volessimo creare una versione più specializzata di Person Employee Person Employee Person ereditarietà multipla

>>> # definiamo una classe Employee che eredita da Person
>>> class Employee(Person):
...     # definiamo un nuovo __init__ che accetta nome/cognome/lavoro
...     def __init__(self, name, surname, job):
...         # chiamiamo l'__init__ della classe base (o superclasse)
...         # che assegna nome e cognome all'istanza
...         super().__init__(name, surname)
...         # assegniamo il lavoro all'istanza
...         self.job = job
...     # definiamo un metodo aggiuntivo che stampa un messaggio
...     def work(self):
...         print(self.name, 'is working as a', self.job)
...
# creiamo un'istanza di Employee specificando nome/cognome/lavoro
>>> e = Employee('Ezio', 'Melotti', 'developer')
>>> # verifichiamo il valore degli attributi name e surname
>>> e.name
'Ezio'
>>> e.surname
'Melotti'
>>> # verifichiamo il valore del nuovo attributo "job"
>>> e.job
'developer'
>>> # verifichiamo che i metodi ereditati da Person funzionino
>>> e.eat('pizza')
Ezio is eating pizza
>>> e.sleep()
Ezio is sleeping
>>> # verifichiamo che il nuovo metodo funzioni
>>> e.work()
Ezio is working as a developer

Dall'esempio possiamo vedere che per definire una sottoclasse basta usare la sintassi class SottoClasse(SuperClasse): ... class SottoClasse(SuperClasse1, SuperClasse2, ...): ...

La sottoclasse erediterà automaticamente tutti i metodi e gli attributi definiti dalla classe base (o superclasse), come ad esempio i metodi Person.eat e Person.sleep.

È anche possibile, nella sottoclasse, sovrascrivere (override in inglese) e quindi ridefinire metodi definiti dalla superclasse. Per esempio, la sottoclasse Employee sovrascrive l'__init__ definito dalla classe Person, modificandolo in modo che accetti un argomento aggiuntivo (job). Se stiamo sovrascrivendo un metodo, è possibile usare la funzione built-in super() (che restituisce un riferimento alla classe base) per accedere al metodo corrispondente definito nella classe base. Infine, è possibile definire metodi aggiuntivi (come Employee.work).

Il risultato finale è una classe Employee che ha tre attributi (name, surname, e job), un __init__ modificato per accettare un argomento aggiuntivo (job), due metodi ereditati da Person (Person.eat e Person.sleep) e un nuovo metodo (Employee.work).