Maintenant que nous savons ce qu’est une classe, voyons comment en écrire une en Python.

On utilise le mot-clé class, des déclarations de fonctions def, et des déclarations d’affectation de variables (x = 3).

Voici un exemple :

class Rectangle:
    width = 3
    height = 2
 
    def calculate_area(self):
        return self.width * self.height

Chaque déclaration de classe commence avec le mot-clé class suivi du nom de cette classe. Dans l’exemple ci-dessus, notre classe s’appelle Rectangle.

Toutes les variables et méthodes qui composent cette classe (ses « attributs ») sont définies en dessous dans sa portée (« scope », en anglais), avec une indentation supplémentaire de 4 espaces.

Quand on déclare une méthode, on utilise le mot-clé def – exactement comme pour les fonctions. Vous pouvez en voir un exemple dans la méthode calculate_area ci-dessus. Les méthodes d’instance incluent toujours « self » en premier paramètre. Ce paramètre référence l’objet lui-même, et il permet d’accéder à ses autres attributs. Par exemple, nous nous en servons dans calculate_area pour multiplier la largeur (self.width) de l’objet par sa hauteur (self.height).

Enfin, vous avez les variables – elles permettent de définir des valeurs par défaut à nos objets. Ici, nous avons fixé la valeur par défaut de la largeur et de la hauteur, ce qui signifie que chaque rectangle aura une largeur de 3 et une hauteur de 2 lors de sa création. Ici, nous avons défini des attributs dits « de classe », et ces variables seront partagées par toutes les autres instances de la classe Rectangle.

Et voilà ! Toutes les classes que vous écrirez seront basées sur ces briques fondamentales (et une ou deux autres que nous présenterons par la suite). Nous pourrions ajouter des méthodes à notre classe Rectangle (comme le constructeur, dont nous allons parler dans la prochaine section), si nécessaire.

Il existe une catégorie spéciale de méthode nommée constructeur. Chaque classe en a un, et il est utilisé pour créer des objets à partir de cette classe (instanciation). En Python, notre constructeur est une méthode magique nommée init, que l’on peut utiliser un peu comme ceci :

class Rectangle:
 
    def __init__(self, length, width, color="red"):
        self.length = length
        self.width = width
        self.color = color

Une méthode « magique » ? Eh oui, elle est dite « magique » parce qu’elle modifie le comportement interne de la classe. En Python, il existe plusieurs méthodes magiques, qui commencent et se terminent par deux underscores (ou « dunders »).

Les constructeurs vous permettent de passer des valeurs initiales à un objet en cours de création. Vous vous souvenez de l’exemple du chapitre précédent, dans lequel nous avions défini des valeurs par défaut pour chaque rectangle ? En définissant ces valeurs plutôt dans le constructeur, nous pouvons initialiser des objets avec différentes longueurs et largeurs. De plus, les attributs définis dans la méthode magique __init__ ne seront pas partagés par les autres instances. Ce sont des attributs d’instance, qui seront propres à chaque objet créé.

Dans le cas de la classe Rectangle ci-dessus, pour créer un nouvel objet rectangle, nous devons lui donner une longueur, une largeur et une couleur. Nous reviendrons sur la création concrète d’objets dans le prochain chapitre.

Qu’est-ce que c’est que ce color=“red” (couleur=rouge) dans la définition de la méthode ?

C’est un raccourci très pratique – vous pouvez appeler ce constructeur en définissant ou non une couleur. Si vous ne spécifiez pas de couleur, la valeur (« red », soit rouge) sera utilisée par défaut. Vous pouvez créer des « paramètres optionnels » dans toute méthode ou fonction. Assurez-vous simplement que vos paramètres optionnels se trouvent après les autres paramètres dans la liste (donc après 'self, lengthet et width, dans notre exemple).

La plupart des classes auront besoin d’un constructeur. Si vous n’en fournissez pas, Python utilisera – ce qui est commode – un constructeur par défaut qui ne fait rien.

Et maintenant, il est temps de traduire les plans du chapitre précédent en code. Dans votre propre environnement de développement, écrivez 3 classes, soit une pour chacune des classes que vous avez identifiées et planifiées dans l’exercice du chapitre précédent (boîte à outils, tournevis et marteau).

Vous ne savez pas encore comment implémenter certaines méthodes. Ce n’est pas grave, laissez simplement le corps de la méthode vide. En Python, nous pouvons utiliser pour cela le mot-clé pass, comme ceci :

def empty_method(self, length):
    pass

Je vous recommande de placer toutes les classes que vous écrivez dans le même fichier Python. Nous discuterons plus en détail de la structure et du découpage de votre code au fil du cours.

Vous noterez que j’utilise des commentaires spéciaux appelés docstrings pour cet exemple. Vous pouvez en apprendre plus sur cette forme de documentation dans le cours Écrivez du code maintenable avec Python.

Proposition

class Toolbox:
    """
    Boite à outils pour ranger ses outils
    """
    def __init__(self):
        """
        Constructeur de la classe Toolbox : initialise les objets à l'instanciation.
        """
        self.tools = []
 
    def add_tool(self, a_tool):
        """
        Ajouter un outil dans la boite à outils.
 
        :param a_tool: outil à ajouter dans la boite
        """
        pass
 
    def remove_tool(self, a_tool):
        """
        Récupérer / retirer un outil de la boite à outils.
 
        :param a_tool: L'outil a retirer.
        :return: un outil
        """
        pass
 
 
class Hammer:
    """
    Marteau : un outil
    """
    def __init__(self):
        """
        Constructeur de la classe Hammer : initialise les objets lors de l'instanciation.
        """
        self.color = "red"
 
    def tack(self, a_nail):
        """
        Planter un clou
 
        :param a_nail:
        :return: self
        """
        pass
 
    def remove(self, a_nail):
        """
        Retirer un clou
 
        :param a_nail:
        :return:
        """
        pass
 
    def set_color(self, a_color):
        """
        Change la couleur du marteau.
 
        :param a_color: La nouvelle couleur du marteau
        :return:
        """
        self.color = a_color
 
 
class ScrewDriver:
    """
    Tournevis : un outil
    """
 
    def __init__(self, a_size):
        """
        Constructeur de la classe Screwdriver : initialise les objets lors de l'instanciation.
 
        :param a_size: La taille du tournevis exprimée en mm.
        :type a_size: int
        """
        self.size = a_size
 
    def clamp(self, a_screw):
        """
        Serrer une vis.
 
        :param a_screw: La vis à visser / serrer.  
        :return: self
        """
        pass
 
    def loosen(self, a_screw):
        """
        Deserrer la vis
        :param a_screw: la vis à deserrer. 
        :return: self
        """
        pass

• Créez une classe en utilisant le mot-clé class ;
• La méthode magique __init__ est connue sous le nom de constructeur ;
• Les constructeurs sont appelés lorsqu’un objet est créé (instancié).

Maintenant que nous savons comment écrire une classe, il est temps de passer concrètement à la création et l’utilisation d’objets !

◁ Précédent | ⌂ Retour au sommaire | Suivant ▷