Duck typing

Il duck typing si concentra su ciò che un oggetto può fare, non su ciò che è. Se un oggetto dispone dei metodi di cui hai bisogno, puoi usarlo, indipendentemente dalla sua classe.

Ecco due classi non correlate con gli stessi metodi:

class Duck:
    def swim(self):
        return "Duck swimming"
    
    def quack(self):
        return "Quack!"

class Person:
    def swim(self):
        return "Person swimming"
    
    def quack(self):
        return "Person imitating a duck: Quack!"

Nota che Duck e Person non ereditano dalla stessa classe genitore, ma hanno entrambi i metodi swim() e quack().

Crea una funzione che funzioni con qualsiasi oggetto «simile a un'anatra»:

def make_it_swim_and_quack(duck_like_object):
    print(duck_like_object.swim())
    print(duck_like_object.quack())

A questa funzione non interessa il tipo dell'oggetto: le interessa solo che l'oggetto abbia i metodi richiesti.

Usa la funzione con entrambe le classi:

make_it_swim_and_quack(Duck())
make_it_swim_and_quack(Person())

Output:

Duck swimming
Quack!
Person swimming
Person imitating a duck: Quack!

Aggiungi un'altra classe "simile a un'anatra":

class Robot:
    def swim(self):
        return "Robot swimming with propellers"
    
    def quack(self):
        return "Robot sound: BEEP BEEP!"

make_it_swim_and_quack(Robot())

Output:

Robot swimming with propellers
Robot sound: BEEP BEEP!

Punto chiave: il duck typing consente il polimorfismo senza ereditarietà. Se un oggetto dispone dei metodi di cui hai bisogno, puoi usarlo. Questo rende il codice Python flessibile e segue il principio «è più facile chiedere perdono che permesso».