Méthodes [Spécialité NSI - Année 2026

Méthodes

Définition : Méthode

Une méthode est une fonction définie à l’intérieur d’une classe. Elle définit les comportements des objets créés à partir de cette classe. Une méthode peut accéder et modifier les attributs de l’objet, ainsi que prendre des arguments et renvoyer des valeurs comme toute fonction en Python.

Pour définir une méthode dans une classe, nous utilisons la syntaxe suivante :

class MaClasse:
    def ma_methode(self, arg1, arg2):
        # Corps de la méthode

class MaClasse:
    def ma_methode(self, arg1, arg2):
        # Corps de la méthode

Dans cet exemple, nous avons défini une méthode ma_methode dans la classe MaClasse. Cette méthode prend trois arguments : self, arg1 et arg2. L’argument self est une référence à l’objet sur lequel la méthode est appelée. Il est automatiquement passé par Python lors de l’appel de la méthode et doit toujours être le premier argument d’une méthode.

Exemple : Vélo

Voici un exemple concret qui montre comment définir et utiliser des méthodes dans notre classe Velo :

class Velo:
    """Représente un vélo avec une marque, un modèle et une couleur."""
    def __init__(self, marque, modele, couleur):
        """Initialise les attributs du vélo avec les valeurs données."""
        self.marque = marque
        self.modele = modele
        self.couleur = couleur
    def rouler(self, distance):
        """Fait rouler le vélo sur la distance donnée."""
        print(f"Le vélo {self.marque} {self.modele} roule sur {distance} km.")
# Création d'un objet Velo
mon_velo = Velo('Peugeot', 'E01 D9', 'bleu')
# Appel de la méthode rouler sur l'objet
mon_velo.rouler(10)  # Le vélo Peugeot E01 D9 roule sur 10 km.

class Velo:
    """Représente un vélo avec une marque, un modèle et une couleur."""

    def __init__(self, marque, modele, couleur):
        """Initialise les attributs du vélo avec les valeurs données."""
        self.marque = marque
        self.modele = modele
        self.couleur = couleur

    def rouler(self, distance):
        """Fait rouler le vélo sur la distance donnée."""
        print(f"Le vélo {self.marque} {self.modele} roule sur {distance} km.")

# Création d'un objet Velo
mon_velo = Velo('Peugeot', 'E01 D9', 'bleu')

# Appel de la méthode rouler sur l'objet
mon_velo.rouler(10)  # Le vélo Peugeot E01 D9 roule sur 10 km.

Dans cet exemple, nous avons défini une méthode rouler dans la classe Velo. Cette méthode prend deux arguments : self et distance. Elle utilise l’argument self pour accéder aux attributs marque et modele de l’objet et affiche un message indiquant que le vélo roule sur la distance donnée.

Ensuite, nous avons créé un objet mon_velo à partir de la classe Velo et avons appelé la méthode rouler sur cet objet en utilisant la syntaxe mon_velo.rouler(10). Comme on peut le voir, la méthode a bien été exécutée et a affiché le message attendu.

Les méthodes spéciales

Les méthodes spéciales sont des méthodes qui ont des noms spécifiques commençant et se terminant par deux underscores, comme __init__, __str__ et __repr__. Ces méthodes sont appelées automatiquement par Python dans certaines situations, comme lors de la création d’un objet ou lors de l’affichage d’un objet en tant que chaîne de caractères.

Exemple : str et repr

class Velo:
    """Représente un vélo avec une marque, un modèle et une couleur."""
    def __init__(self, marque, modele, couleur):
        """Initialise les attributs du vélo avec les valeurs données."""
        self.marque = marque
        self.modele = modele
        self.couleur = couleur
    def __str__(self):
        """Retourne une représentation en chaîne de caractères du vélo."""
        return f"Velo {self.marque} {self.modele} de couleur {self.couleur}"
    def __repr__(self):
        """Retourne une représentation formelle du vélo."""
        return f"Velo('{self.marque}', '{self.modele}', '{self.couleur}')"
# Création d'un objet Velo
mon_velo = Velo('Peugeot', 'E01 D9', 'bleu')
# Affichage de l'objet en utilisant la méthode __str__
print(mon_velo)  # Velo Peugeot E01 D9 de couleur bleu
# Affichage de l'objet en utilisant la méthode __repr__
print(repr(mon_velo))  # Velo('Peugeot', 'E01 D9', 'bleu')

class Velo:
    """Représente un vélo avec une marque, un modèle et une couleur."""

    def __init__(self, marque, modele, couleur):
        """Initialise les attributs du vélo avec les valeurs données."""
        self.marque = marque
        self.modele = modele
        self.couleur = couleur

    def __str__(self):
        """Retourne une représentation en chaîne de caractères du vélo."""
        return f"Velo {self.marque} {self.modele} de couleur {self.couleur}"

    def __repr__(self):
        """Retourne une représentation formelle du vélo."""
        return f"Velo('{self.marque}', '{self.modele}', '{self.couleur}')"

# Création d'un objet Velo
mon_velo = Velo('Peugeot', 'E01 D9', 'bleu')

# Affichage de l'objet en utilisant la méthode __str__
print(mon_velo)  # Velo Peugeot E01 D9 de couleur bleu

# Affichage de l'objet en utilisant la méthode __repr__
print(repr(mon_velo))  # Velo('Peugeot', 'E01 D9', 'bleu')

Dans cet exemple, nous avons défini les méthodes spéciales __str__ et __repr__ dans la classe Velo. La méthode __str__ retourne une représentation en chaîne de caractères du vélo, tandis que la méthode __repr__ retourne une représentation formelle du vélo. Ces méthodes sont appelées automatiquement par Python lorsque nous affichons l’objet en utilisant la fonction print ou la fonction repr.

Les méthodes de classe et les méthodes statiques

Les méthodes de classe et les méthodes statiques sont des méthodes qui sont liées à la classe elle-même plutôt qu’à ses instances. Les méthodes de classe prennent en premier argument une référence à la classe, tandis que les méthodes statiques ne prennent aucun argument spécial. Ces méthodes sont généralement utilisées pour créer des fonctions utilitaires liées à la classe.

Exemple : @classmethod et @staticmethod

class Velo:
    """Représente un vélo avec une marque, un modèle et une couleur."""
    nb_velos = 0  # Attribut de classe pour compter le nombre de vélos
    def __init__(self, marque, modele, couleur):
        """Initialise les attributs du vélo avec les valeurs données."""
        self.marque = marque
        self.modele = modele
        self.couleur = couleur
        Velo.nb_velos += 1  # Incrémente le compteur de vélos
    @classmethod
    def get_nb_velos(cls):
        """Retourne le nombre total de vélos créés."""
        return cls.nb_velos
    @staticmethod
    def get_types():
        """Retourne une liste des types de vélos disponibles."""
        return ['VTT', 'VTC', 'Vélo de route', 'Vélo électrique']
# Affichage du nombre total de vélos (avant création d'objets)
print(Velo.get_nb_velos())  # 0
# Création d'objets Velo
velo1 = Velo('Peugeot', 'E01 D9', 'bleu')
velo2 = Velo('Bianchi', 'Oltre XR4', 'noir')
# Affichage du nombre total de vélos (après création d'objets)
print(Velo.get_nb_velos())  # 2
# Affichage des types de vélos disponibles
print(Velo.get_types())  # ['VTT', 'VTC', 'Vélo de route', 'Vélo électrique']

class Velo:
    """Représente un vélo avec une marque, un modèle et une couleur."""

    nb_velos = 0  # Attribut de classe pour compter le nombre de vélos

    def __init__(self, marque, modele, couleur):
        """Initialise les attributs du vélo avec les valeurs données."""
        self.marque = marque
        self.modele = modele
        self.couleur = couleur
        Velo.nb_velos += 1  # Incrémente le compteur de vélos

    @classmethod
    def get_nb_velos(cls):
        """Retourne le nombre total de vélos créés."""
        return cls.nb_velos

    @staticmethod
    def get_types():
        """Retourne une liste des types de vélos disponibles."""
        return ['VTT', 'VTC', 'Vélo de route', 'Vélo électrique']

# Affichage du nombre total de vélos (avant création d'objets)
print(Velo.get_nb_velos())  # 0

# Création d'objets Velo
velo1 = Velo('Peugeot', 'E01 D9', 'bleu')
velo2 = Velo('Bianchi', 'Oltre XR4', 'noir')

# Affichage du nombre total de vélos (après création d'objets)
print(Velo.get_nb_velos())  # 2

# Affichage des types de vélos disponibles
print(Velo.get_types())  # ['VTT', 'VTC', 'Vélo de route', 'Vélo électrique']

Dans cet exemple, nous avons défini une méthode de classe get_nb_velos et une méthode statique get_types dans la classe Velo. La méthode de classe get_nb_velos utilise l’argument cls pour accéder à l’attribut de classe nb_velos et retourner sa valeur. La méthode statique get_types ne prend aucun argument spécial et retourne simplement une liste des types de vélos disponibles.

Il est important d'utiliser @classmethod et @staticmethod pour indiquer à Python de ne pas passer self en paramètre.

La surcharge d’opérateurs

La surcharge d’opérateurs permet de définir des comportements personnalisés pour les opérateurs tels que +, -, *, /, etc. en utilisant des méthodes spéciales. Par exemple, nous pouvons définir une méthode spéciale __add__ dans notre classe pour spécifier comment les objets de cette classe doivent se comporter lorsqu’ils sont ajoutés avec l’opérateur +.

Exemple : add

class Velo:
    """Représente un vélo avec une marque, un modèle et une couleur."""
    def __init__(self, marque, modele, couleur):
        """Initialise les attributs du vélo avec les valeurs données."""
        self.marque = marque
        self.modele = modele
        self.couleur = couleur
    def __add__(self, autre_velo):
        """Combine deux vélos en un seul vélo tandem."""
        nouvelle_marque = f"{self.marque}-{autre_velo.marque}"
        nouveau_modele = f"{self.modele}-{autre_velo.modele}"
        nouvelle_couleur = f"{self.couleur}/{autre_velo.couleur}"
        return Velo(nouvelle_marque, nouveau_modele, nouvelle_couleur)
# Création de deux objets Velo
velo1 = Velo('Peugeot', 'E01 D9', 'bleu')
velo2 = Velo('Bianchi', 'Oltre XR4', 'noir')
# Combinaison des deux vélos en un seul vélo tandem
tandem = velo1 + velo2
# Affichage des attributs du vélo tandem
print(tandem.marque)  # Peugeot-Bianchi
print(tandem.modele)  # E01 D9-Oltre XR4
print(tandem.couleur) # bleu/noir

class Velo:
    """Représente un vélo avec une marque, un modèle et une couleur."""

    def __init__(self, marque, modele, couleur):
        """Initialise les attributs du vélo avec les valeurs données."""
        self.marque = marque
        self.modele = modele
        self.couleur = couleur

    def __add__(self, autre_velo):
        """Combine deux vélos en un seul vélo tandem."""
        nouvelle_marque = f"{self.marque}-{autre_velo.marque}"
        nouveau_modele = f"{self.modele}-{autre_velo.modele}"
        nouvelle_couleur = f"{self.couleur}/{autre_velo.couleur}"
        return Velo(nouvelle_marque, nouveau_modele, nouvelle_couleur)

# Création de deux objets Velo
velo1 = Velo('Peugeot', 'E01 D9', 'bleu')
velo2 = Velo('Bianchi', 'Oltre XR4', 'noir')

# Combinaison des deux vélos en un seul vélo tandem
tandem = velo1 + velo2

# Affichage des attributs du vélo tandem
print(tandem.marque)  # Peugeot-Bianchi
print(tandem.modele)  # E01 D9-Oltre XR4
print(tandem.couleur) # bleu/noir

Dans cet exemple, nous avons défini une méthode spéciale __add__ dans la classe Velo pour surcharger l’opérateur +. Cette méthode prend en argument un autre objet Velo et crée un nouvel objet Velo qui représente un vélo tandem combinant les marques, les modèles et les couleurs des deux vélos originaux.

Nous avons ensuite créé deux objets Velo et avons utilisé l’opérateur + pour les combiner en un seul objet tandem. Comme on peut le voir, les attributs du nouvel objet tandem combinent les valeurs des attributs des deux objets Velo originaux.