Python est également un langage de programmation dynamique. Python est un langage de typage de canard. Cela signifie que les types de données des variables peuvent changer tant que la syntaxe est compatible.

L’héritage est considéré comme un élément de base de la programmation orientée objet, et il est important de le comprendre. Cela dit, ce n’est pas aussi utile en Python que c’est dans d’autres langues. La raison en est que Python a intégré (paramétrique) polymorphisme. Cela signifie que nous pouvons passer n’importe quel type d’objet que nous voulons une fonction. Par exemple, supposons que nous ayons une classe pour stocker des collections de polygones comme suit:

class PolygonCollection:
def __init__(self):
self._triangles = []
self._squares = []
def add(self, polygon):
if polygon.sides() == 3:
self._triangles.append(polygon)
if polygon.sides() == 4:
self._squares.append(polygon)

Notez que la méthode d’ajout fonctionnerait aussi bien avec l’une ou l’autre version des classes Triangle et Carré définies précédemment. En fait, on pourrait passer tout objet qui a une méthode appelée côtés. Nous n’avions pas besoin d’héritage afin de traiter les triangles et les carrés comme des cas particuliers du même objet.

Python: COMPOSITION AND “HAS A” RELATIONSHIPS

Parfois, l’héritage est le bon moyen de combiner des classes afin qu’elles puissent être traité comme une seule classe, mais en Python, ce n’est pas aussi nécessaire que dans d’autres langues.

Le polymorphisme de Python est basé sur l’idée du typage canard. Le nom vient d’une vieille expression qui dit que si quelque chose marche comme un canard et cancane comme un canard, alors c’est un canard. Dans l’exemple Polygon Collection, si nous appelons la méthode add avec un argument qui a une méthode côtés qui renvoie quelque chose qui peut être comparé à un entier, alors le code sera exécuté sans erreur. Avoir les bonnes méthodes équivaut à “marcher et parler comme un canard”. Cela signifie que même si l’héritage doit toujours signifier est un, toutes les relations \est un” dans votre code” n’ont pas besoin d’être exprimées avec héritage.

Cette idée que non seulement l’héritage signifie “est un” est très importante dans Python sera très important tout au long de ce cours. Nous discuterons cela plus lorsque nous examinons plus en profondeur les types de données abstraits.

Un exemple que nous avons déjà vu est la fonction str. Différent les types d’objets peuvent être convertis en chaînes, y compris les objets de classes qui nous nous sommes définis. Tant que nous avons implémenté la méthode str sur notre classe, alors nous pouvons appeler str sur une instance de cette classe. Cette fonction appelle la méthode correspondante, c’est-à-dire que str(t) pour un Triangle t appelle t. str() qui équivaut à Triangle. str (t).

Il existe de nombreux cas où nous voulons que des objets de différents types partagent certaines fonctionnalités. Parfois, l’héritage est utilisé pour permettre ce partage, mais

plus souvent, nous utilisons quelque chose appelé composition. C’est là qu’une classe stocke une instance d’une autre classe. Cela nous permet de produire plus complexe

objets. La règle la plus importante concernant la composition est la suivante.

Composition signifie “a un”

Considérons le cas où nous voulons qu’une classe se comporte comme une liste. Pour exemple, nous aimerions pouvoir ajouter à la liste et accéder aux éléments par leur index, mais nous ne voulons aucun des autres éléments de la liste. Dans ce cas, il serait erroné d’utiliser l’héritage. Au lieu de cela, nous ferions notre magasin de classe une liste en interne (composition). Ensuite, l’interface publique de notre classe serait contenir les méthodes que nous voulons lors des appels à l’instance de liste stockée

pour éviter de dupliquer l’implémentation de la liste. Voici un exemple:

class MyLimitedList:
def __init__(self):
self._L = []
def append(self, item):
self._L.append(item)
def __getitem__(self, index):
return self._L[index]

Ici, la méthode magique getitem va nous permettre d’utiliser le carré notation parenthèse avec notre classe. Comme avec d’autres méthodes magiques, nous n’appelons pas directement.

L = MyLimitedList()
L.append(1)
L.append(10)
L.append(100)
print(L[2])

Output: 100