Cos'è il polimorfismo?

In Python, len("hello") restituisce 5, len([4, 8, 15]) restituisce 3 e len({"a": 1}) restituisce 1. È un unico nome di funzione usato su tre tipi, e ogni tipo conta a modo suo: una stringa conta i caratteri, una lista conta gli elementi, un dizionario conta le chiavi. La parola viene dal greco: poly, molti, e morph, forma. Una sola chiamata, molte forme di comportamento.

Come funziona il polimorfismo

Il codice chiama un metodo per nome, come shape.area(). Quando quella riga viene eseguita, il linguaggio guarda l'oggetto reale e trova area nella classe dell'oggetto stesso. Questa ricerca si chiama dispatch dinamico, ed è ciò che permette a una sola riga di fare un lavoro diverso per oggetti diversi:

import math

class Shape:
    def area(self):
        raise NotImplementedError

class Circle(Shape):
    def __init__(self, r):
        self.r = r
    def area(self):
        return math.pi * self.r ** 2

class Square(Shape):
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

shapes = [Circle(1), Square(3), Circle(2)]
for shape in shapes:
    # One line of code, a different area() for each type
    print(type(shape).__name__, round(shape.area(), 2))

Circle 3.14
Square 9
Circle 12.57

Python trova il metodo cercando prima nella classe dell'oggetto, poi nelle sue classi genitore in un ordine fisso chiamato method resolution order (ordine di risoluzione dei metodi). Se Square non avesse una propria area(), la ricerca arriverebbe a Shape.area() e solleverebbe NotImplementedError, un segnale che ogni sottoclasse deve fornirne una.

Il ciclo non controlla mai che tipo di forma contiene. Per aggiungere un triangolo, scrivi una classe Triangle con la sua area(), e il ciclo funziona senza modifiche. Senza polimorfismo, il ciclo avrebbe bisogno di un ramo if isinstance(...) per ogni forma, da modificare ogni volta che ne compare una nuova.

Tipi di polimorfismo

Quando nella programmazione a oggetti si dice "polimorfismo" senza altri dettagli, si intende quasi sempre la prima riga: il polimorfismo per sottotipo tramite override.

Python li ha tutti e tre a modo suo. L'override funziona come nell'esempio delle forme. Operatori come + sono polimorfismo ad hoc. Funzioni come max() e sorted() sono parametriche nello spirito: accettano una lista di numeri, stringhe o date, purché gli elementi si possano confrontare, e i type hint come list[int] o un TypeVar possono dichiararlo esplicitamente.

Polimorfismo in fase di compilazione e a runtime in Java

Java li ha entrambi, e nei colloqui di lavoro capita spesso che chiedano la differenza:

class Animal { String sound() { return "..."; } }
class Dog extends Animal {
    @Override String sound() { return "Woof"; }
}

Animal pet = new Dog();
pet.sound();          // "Woof": chosen at run time from the object

int add(int a, int b)          { return a + b; }
double add(double a, double b) { return a + b; }
add(2, 3);            // int version, chosen by the compiler
add(2.5, 1.0);        // double version

La variabile pet è di tipo Animal, eppure viene eseguita la versione di Dog, perché la scelta dipende dall'oggetto, non dalla variabile. I due metodi add sono overloading: il compilatore ne sceglie uno in base ai tipi degli argomenti prima che il programma venga eseguito. Le interfacce danno lo stesso comportamento a runtime senza condividere codice: qualsiasi classe che implementa Comparable può essere ordinata da Collections.sort. C++ funziona allo stesso modo con una differenza: un metodo ha il dispatch a runtime solo se è dichiarato virtual. Vedi il polimorfismo in Java, l'overloading dei metodi e le funzioni virtuali in C++.

Polimorfismo in Python: duck typing e operatori

Python non richiede una classe genitore comune. Se un oggetto ha il metodo che il codice chiama, funziona: "se cammina come un'anatra e fa qua qua come un'anatra, è un'anatra". Anche gli operatori sono polimorfici. Scrivere a + b chiama a.__add__(b), quindi le tue classi possono supportare +, len() e print():

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __add__(self, other):          # called for v1 + v2
        return Vector(self.x + other.x, self.y + other.y)
    def __len__(self):                 # called for len(v)
        return 2
    def __repr__(self):                # called by print()
        return f"Vector({self.x}, {self.y})"

print(1 + 2, "ab" + "cd", [1] + [2])   # built-in types
print(Vector(1, 2) + Vector(10, 20))    # your own type
print(len("hello"), len([1, 2, 3]), len(Vector(0, 0)))

3 abcd [1, 2]
Vector(11, 22)
5 3 2

L'ereditarietà è un modo per ottenere il polimorfismo, non un requisito. Vector non eredita da niente di speciale, eppure len() e + lo trattano come un tipo integrato. La documentazione sull'ereditarietà in Python mostra la strada delle sottoclassi.

Errori comuni

Aspettarsi che Python faccia overloading in base alla firma. Un secondo def con lo stesso nome sostituisce il primo senza avvisare:

def greet(name):
    return "Hi " + name

def greet(first, last):          # replaces the first greet
    return "Hi " + first + " " + last

print(greet("Ana", "Silva"))
print(greet("Ana"))

Hi Ana Silva
Traceback (most recent call last):
  ...
TypeError: greet() missing 1 required positional argument: 'last'

Usa invece un argomento predefinito: def greet(first, last="").

Dimenticare virtual in C++. Senza di esso, chiamare un metodo tramite un puntatore alla classe base esegue la versione base, anche quando l'oggetto è una sottoclasse.

Override che cambiano il significato. Se area() in una sottoclasse restituisce il perimetro, ogni chiamante che si fida di area() si rompe. Un override deve mantenere la promessa fatta dal genitore; questa regola è nota come principio di sostituzione di Liskov.

Controlli di tipo ovunque. Una catena di rami if type(x) == ... di solito è il segnale che ogni tipo dovrebbe avere il proprio metodo.

Cosa leggere dopo

Il polimorfismo lavora insieme all'incapsulamento, che protegge i dati di ogni oggetto, e all'astrazione, che definisce l'interfaccia comune implementata dai tipi. Esercitati con l'override nella documentazione sulle classi Python, oppure prova il corso Java, dove overloading e override compaiono fianco a fianco.