Définir des classes et créer des objets

Syntaxe de définition d'une classe : le mot-clé `class`

En Python, vous définissez une classe en utilisant le mot-clé `class`, suivi du nom de la classe et de deux-points (`:`). Le corps de la classe (les attributs et les méthodes) est indenté.

Le nom de la classe doit respecter les conventions de nommage de Python (généralement en CamelCase, c'est-à-dire avec une majuscule au début de chaque mot, sans espaces ni tirets bas). Par exemple : `class MaClasse:`.

A l'intérieur du corps de la classe, vous pouvez définir des attributs (variables) et des méthodes (fonctions). Les méthodes sont définies comme des fonctions normales, mais leur premier paramètre est toujours `self`, qui représente l'objet sur lequel la méthode est appelée.

Nous verrons des exemples de définitions de classes simples, et comment définir des attributs et des méthodes.

Le constructeur `__init__` : initialisez vos objets

Le constructeur est une méthode spéciale qui est appelée automatiquement lorsque vous créez un objet (une instance) d'une classe. En Python, le constructeur est nommé `__init__` (avec deux tirets bas avant et après).

Le constructeur est utilisé pour initialiser les attributs de l'objet. Il prend généralement des arguments qui permettent de spécifier les valeurs initiales des attributs.

Le premier paramètre du constructeur est toujours `self`, qui représente l'objet en cours de création. Les autres paramètres sont les arguments que vous passez lors de la création de l'objet.

Par exemple : `class Voiture: def __init__(self, marque, modele, couleur): self.marque = marque; self.modele = modele; self.couleur = couleur`. Dans cet exemple, le constructeur prend la marque, le modèle et la couleur en argument, et les affecte aux attributs correspondants de l'objet.

Nous verrons comment définir un constructeur, comment l'utiliser pour initialiser les attributs, et comment créer des objets en passant des arguments au constructeur.

Méthodes spéciales (dunder methods) : personnalisez le comportement de vos objets

Les méthodes spéciales (également appelées "dunder methods", pour "double underscore methods") sont des méthodes dont le nom commence et se termine par deux tirets bas. Elles permettent de personnaliser le comportement de vos objets dans certaines situations.

Nous avons déjà vu le constructeur `__init__`, qui est une méthode spéciale. D'autres méthodes spéciales courantes incluent :

• `__str__` : appelée par la fonction `str()` et par l'instruction `print()`, pour obtenir une représentation textuelle "informelle" de l'objet (destinée à l'utilisateur final).
• `__repr__` : appelée par la fonction `repr()`, pour obtenir une représentation textuelle "officielle" de l'objet (destinée au développeur, pour le débogage).
• `__len__` : appelée par la fonction `len()`, pour obtenir la "longueur" de l'objet (par exemple, le nombre d'éléments dans une liste).
• `__getitem__` et `__setitem__` : appelées par les opérateurs d'accès aux éléments (`[]`), pour accéder à un élément de l'objet par son index ou sa clé, et pour modifier un élément.
• `__add__`, `__sub__`, `__mul__`, etc. : appelées par les opérateurs arithmétiques (`+`, `-`, `*`, etc.), pour définir le comportement de ces opérateurs avec vos objets.

Nous verrons comment définir et utiliser ces méthodes spéciales, et comment elles vous permettent de créer des objets qui s'intègrent parfaitement avec le reste de Python.

Il existe de nombreuses autres méthodes spéciales, mais nous nous concentrerons sur les plus courantes et les plus utiles.

Variables de classe vs. variables d'instance : deux types d'attributs

En Python, il existe deux types d'attributs : les variables de classe et les variables d'instance.

Les variables de classe sont définies au niveau de la classe (en dehors de toute méthode). Elles sont partagées par tous les objets de la classe. Si vous modifiez une variable de classe, la modification sera visible par tous les objets.

Les variables d'instance sont définies à l'intérieur du constructeur `__init__` (ou d'une autre méthode), en utilisant `self.nom_de_la_variable`. Elles sont propres à chaque objet. Chaque objet a sa propre copie de la variable d'instance.

Il est important de comprendre la différence entre les variables de classe et les variables d'instance, car elles n'ont pas le même comportement. Les variables de classe sont généralement utilisées pour stocker des informations qui sont communes à tous les objets de la classe, tandis que les variables d'instance sont utilisées pour stocker des informations qui sont spécifiques à chaque objet.

Nous verrons des exemples de variables de classe et de variables d'instance, et comment les utiliser.