Duck Typing

Fait partie de la section Object Oriented Programming du Journey Python de Coddy — leçon 24 sur 64.

Le duck typing se concentre sur ce qu'un objet peut faire, et non sur ce qu'il est. Si un objet possède les méthodes dont vous avez besoin, vous pouvez l'utiliser, quel que soit son type de classe.

Voici deux classes sans lien entre elles avec les mêmes méthodes :

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!"

Remarquez que Duck et Person n'héritent pas de la même classe parente, mais ils possèdent tous deux les méthodes swim() et quack().

Créez une fonction qui fonctionne avec n'importe quel objet de type « canard » :

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

Cette fonction ne se soucie pas du type de l'objet - elle se soucie seulement du fait que l'objet possède les méthodes requises.

Utilisez la fonction avec les deux classes :

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

Résultat :

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

Ajoutez une autre classe de type « canard » :

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

make_it_swim_and_quack(Robot())

Sortie :

Robot swimming with propellers
Robot sound: BEEP BEEP!

Point clé : Le duck typing permet le polymorphisme sans héritage. Si un objet possède les méthodes dont vous avez besoin, vous pouvez l'utiliser. Cela rend le code Python flexible et suit le principe « il est plus facile de demander pardon que la permission ».

Défi

Moyen

Dans ce défi, vous allez implémenter un système illustrant le duck typing avec différents objets de type fichier :

textfile.py : Implémentez la classe TextFile avec les méthodes read() et write(data)
database.py : Implémentez la classe Database avec des signatures de méthode correspondantes
networkresource.py : Implémentez la classe NetworkResource avec des signatures de méthode correspondantes
driver.py - Implémentez des cas de test qui vérifieront que votre implémentation fonctionne correctement

Chaque fichier contient des commentaires TODO détaillés guidant votre implémentation.

Aide-mémoire

Le duck typing (typage structurel) se concentre sur ce qu'un objet peut faire, et non sur ce qu'il est. Si un objet possède les méthodes dont vous avez besoin, vous pouvez l'utiliser quel que soit son type de classe.

Exemple de duck typing avec des classes non liées qui partagent les mêmes méthodes :

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!"

Créez une fonction qui fonctionne avec n'importe quel objet de type « canard » :

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

# Works with any object that has swim() and quack() methods
make_it_swim_and_quack(Duck())
make_it_swim_and_quack(Person())

Le duck typing permet le polymorphisme sans héritage : si un objet possède les méthodes dont vous avez besoin, vous pouvez l'utiliser. Cela rend le code Python flexible et suit le principe selon lequel « il est plus facile de demander pardon que la permission ».

Essayez vous-même

# TODO: Importer la classe TextFile depuis textfile.py
# TODO: Importer la classe Database depuis database.py
# TODO: Importer la classe NetworkResource depuis networkresource.py

def process_data(data_source, data):
    # TODO: Appeler la méthode read() sur data_source et afficher le résultat
    # TODO: Appeler la méthode write(data) sur data_source et afficher le résultat
    pass


# Test with different data sources - DO NOT MODIFY THIS TEST CODE
text_file = TextFile()
database = Database()
network = NetworkResource()

print("Processing text file:")
process_data(text_file, "Hello, world!")

print("\
Processing database:")
process_data(database, "User record")

print("\
Processing network resource:")
process_data(network, "GET request")