Risposta.

Polimorfismo — un principio fondamentale della programmazione orientata agli oggetti, che consente agli oggetti con strutture diverse di implementare lo stesso interfaccia, permettendo così di lavorare in modo intercambiabile. In Python, grazie alla tipizzazione dinamica, il polimorfismo è molto flessibile.

Storia della questione

Nei linguaggi con tipizzazione statica rigorosa (Java, C++) il supporto per il polimorfismo richiede la dichiarazione di interfacce o classi astratte. In Python, grazie al duck typing, il polimorfismo non è legato alla gerarchia di ereditarietà e nemmeno all'interfaccia. È sufficiente che l'oggetto supporti i metodi/attributi richiesti.

Problema

Da un lato, questo rende il linguaggio flessibile e conveniente. Dall'altro, aumenta la probabilità di errori a runtime a causa di errori di battitura o della mancanza del metodo necessario, che si manifesteranno solo durante l'esecuzione del codice.

Soluzione

In Python, si distinguono:

Polimorfismo normale (classico) attraverso ereditarietà e overriding dei metodi:

class Animal:
    def speak(self):
        raise NotImplementedError

class Dog(Animal):
    def speak(self):
        return 'Woof!'

class Cat(Animal):
    def speak(self):
        return 'Meow!'

def animal_voice(animal):
    print(animal.speak())

animal_voice(Dog())  # Woof!
animal_voice(Cat())  # Meow!

Duck Typing — se una classe ha il metodo necessario, è adatta per qualsiasi funzione che si aspetta quel metodo, indipendentemente dal suo progenitore:

class Duck:
    def quack(self):
        return 'Quack!'

def make_quack(animal):
    print(animal.quack())

make_quack(Duck())  # Quack!

Simulazione di interfaccia — tramite abc.ABC e @abstractmethod è possibile formalizzare quali metodi devono essere implementati dalle classi.

Caratteristiche chiave:

Assenza di obbligo di mantenere una rigida gerarchia di ereditarietà.
Possibilità di sostituire oggetti a runtime se supportano l'interfaccia necessaria.
Errori di non corrispondenza delle interfacce emergono solo durante l'esecuzione.

Domande ingannevoli.

L'ereditarietà è l'unico modo per garantire il polimorfismo in Python?

No. Grazie al duck typing, qualsiasi funzione può accettare un oggetto con i metodi necessari indipendentemente dalla sua classe o gerarchia.

Si può considerare il polimorfismo la corrispondenza della firma solo per nome del metodo, e non per la sua sostanza?

No. Se un oggetto supporta il metodo necessario, ma la sua semantica differisce da quella attesa, possono verificarsi bug. Il polimorfismo è efficace solo quando coincidono non solo l'interfaccia, ma anche il significato.

Il classe astratta fornisce protezione contro errori di implementazione errata dell'interfaccia nelle classi figlie?

Solo parzialmente. Se l'erede non implementa il metodo astratto, si verificherà un TypeError quando si tenta di creare un'istanza. Ma se implementa violando la logica, possono verificarsi errori.

Errori comuni e anti-pattern

Implementazione errata dell'interfaccia senza rispettare la semantica del metodo.
Affidarsi al duck typing senza adeguati test, portando a errori a runtime.
Aspettarsi una tipizzazione rigorosa (come nei linguaggi a tipizzazione statica), sebbene Python non lo garantisca.

Esempio dalla vita

Caso negativo

In una libreria di logging viene introdotta una classe esterna, che ha un metodo log(), ma restituisce un oggetto dati anziché registrare nel log. Gli errori si manifestano solo durante l'esecuzione.

Vantaggi:

Integrazione rapida di diverse classi senza burocrazia inutile.

Svantaggi:

Bug silenziosi, rilevati esclusivamente a runtime, spesso già in produzione.

Caso positivo

Le classi sono dotate di test, l'interfaccia è formalizzata attraverso una classe base astratta e @abstractmethod, e nella documentazione è descritta la semantica dei metodi.