A.5 Manipuler les méthodes

1Situer

Une épicerie de quartier à Agadir veut un panier d'achat pour sa future application. Le panier doit pouvoir ajouter un article, retirer un article, calculer le total avec une remise éventuelle, et se créer directement à partir d'une liste de courses. Chacune de ces actions est une méthode.

2Comprendre

Ce qui se passe lors d'un appel de méthode

On appelle la méthode ajouter sur l'objet panier, avec trois arguments.

1 / 5

Une méthode est une fonction définie à l’intérieur d’une classe. Elle décrit ce que l’objet sait faire.

def ajouter(self, nom, prix, quantite=1):
    self.articles.append((nom, prix, quantite))

On l’appelle avec un point : panier.ajouter("Thé", 18, 2). Python transforme cet appel en Panier.ajouter(panier, "Thé", 18, 2) : c’est pour cela que self reçoit l’objet.

Les paramètres d’une méthode

obligatoires : nom, prix ;
par défaut : quantite=1, qu’on peut omettre ;
nommés à l’appel : ajouter(prix=18, nom="Thé") ;
variables : *args (plusieurs valeurs), **kwargs (plusieurs paramètres nommés).

Exemple simple

self, puis les vrais paramètres

self est rempli automatiquement par Python. On ne passe que les paramètres qui suivent.

class Panier:
    def __init__(self):
        self.total = 0
    def ajouter(self, prix, quantite=1):
        self.total += prix * quantite

p = Panier()
p.ajouter(12)            # quantite = 1 par défaut
p.ajouter(5, 3)          # quantite = 3
print(p.total)           # 27

Ce qui se passe

p.ajouter(12) devient en réalité Panier.ajouter(p, 12).
quantite a une valeur par défaut : on peut l’omettre.
12 × 1 + 5 × 3 = 27.

La visibilité d’une méthode

Comme pour les attributs : total() est publique, _sous_total() est protégée (usage interne), __calcul() est privée.

Exemple simple

Une méthode privée d’aide au calcul

Une méthode privée sert à l’intérieur de la classe. L’extérieur n’utilise que la méthode publique.

class Facture:
    def __init__(self, ht):
        self.ht = ht
    def __taxe(self):                 # privée
        return self.ht * 0.2
    def total(self):                  # publique
        return self.ht + self.__taxe()

print(Facture(100).total())           # 120.0

Ce qui se passe

total() appelle __taxe() à l’intérieur de la classe : c’est permis.
Facture(100).__taxe() depuis l’extérieur provoque une AttributeError.

Trois sortes de méthodes

Sorte	Décorateur	Premier paramètre	Exemple
d’instance	aucun	`self` (l’objet)	`panier.total()`
de classe	`@classmethod`	`cls` (la classe)	`Panier.depuis_liste(...)`
statique	`@staticmethod`	aucun	`Panier.en_euros(108)`

Exemple simple

Méthode d’instance, de classe et statique

Trois décorateurs, trois usages.

class Date:
    def __init__(self, j, m, a):
        self.j, self.m, self.a = j, m, a
    def afficher(self):                  # instance : utilise self
        return f"{self.j}/{self.m}/{self.a}"
    @classmethod
    def depuis_texte(cls, texte):        # classe : fabrique un objet
        j, m, a = texte.split("/")
        return cls(int(j), int(m), int(a))
    @staticmethod
    def est_bissextile(a):               # statique : simple outil
        return a % 4 == 0 and (a % 100 != 0 or a % 400 == 0)

d = Date.depuis_texte("30/07/2026")
print(d.afficher(), Date.est_bissextile(2028))

Résultat

30/7/2026 True

Ce qui se passe

afficher a besoin des données de l’objet : méthode d’instance.
depuis_texte crée un objet à partir d’un texte : méthode de classe (reçoit cls).
est_bissextile n’utilise ni self ni cls : méthode statique.

Les fonctions imbriquées

Une fonction peut être définie dans une méthode. Elle n’existe que pendant l’appel et sert à découper un calcul sans encombrer la classe : c’est le cas de appliquer() dans total().

Exemple simple

Une petite fonction d’aide cachée dans une méthode

Une fonction définie dans une autre n’existe qu’à l’intérieur : elle évite de répéter du code.

class Bulletin:
    def __init__(self, notes):
        self.notes = notes
    def resume(self):
        def arrondi(x):
            return round(x, 1)
        m = sum(self.notes) / len(self.notes)
        return f"moyenne {arrondi(m)}, max {arrondi(max(self.notes))}"

print(Bulletin([12.25, 15.5, 9.75]).resume())

Ce qui se passe

arrondi n’existe que pendant l’appel de resume().
On l’utilise deux fois sans la rendre visible au reste du programme.

Exemple simple

La télécommande

Chaque bouton de la télécommande déclenche une action sur la télévision : allumer, changer de chaîne, monter le son. Appeler une méthode, c'est appuyer sur un bouton de l'objet.

tele.allumer()
tele.changer_chaine(2)
tele.monter_son(5)

Exemple simple

Une méthode qui n'a pas besoin de l'objet

Convertir des dirhams en euros ne dépend d'aucun panier en particulier : c'est une méthode statique, rangée dans la classe parce qu'elle lui est liée.

class Panier:
    @staticmethod
    def en_euros(montant_dh):
        return round(montant_dh / 10.8, 2)

print(Panier.en_euros(108))   # 10.0

3Manipuler

Exécutez, puis ajoutez un article avec panier.ajouter("Huile", 32, 2) et appliquez une remise de 10 % avec panier.total(remise=10).

Pas à pas dans le lab ↗Python se charge au premier clic (environ 12 Mo, une seule fois).

class Panier:
    TVA = 0.20                        # attribut de classe

def __init__(self, client):
        self.client = client
        self.articles = []            # liste de (nom, prix, quantité)

# Méthode d'instance avec un paramètre par défaut
    def ajouter(self, nom, prix, quantite=1):
        self.articles.append((nom, prix, quantite))

def retirer(self, nom):
        self.articles = [a for a in self.articles if a[0] != nom]

# Méthode « protégée » : usage interne
    def _sous_total(self):
        return sum(prix * q for _, prix, q in self.articles)

def total(self, remise=0):
        # Fonction imbriquée : n'existe qu'à l'intérieur de total()
        def appliquer(montant, pourcentage):
            return montant * (1 - pourcentage / 100)
        ht = appliquer(self._sous_total(), remise)
        return round(ht * (1 + Panier.TVA), 2)

# Méthode de classe : un autre moyen de construire un Panier
    @classmethod
    def depuis_liste(cls, client, liste):
        p = cls(client)
        for nom, prix in liste:
            p.ajouter(nom, prix)
        return p

panier = Panier.depuis_liste("Hassan", [("Pain", 1.2), ("Lait", 7.5)])
panier.ajouter("Thé", 18, 2)
panier.retirer("Pain")
print(panier.articles)
print("Total TTC :", panier.total(), "DH")

Entrées pour input(), séparées par des virgules

Console

Mémoire : objets créés

Exécutez le code : les objets et leurs attributs s'afficheront ici.

4Pratiquer

Exercice 1 · Compter les articles

Ajoutez une méthode nb_articles() qui renvoie le nombre total d'unités dans le panier (en tenant compte des quantités).

Voir le corrigé

def nb_articles(self):
    return sum(q for _, _, q in self.articles)

Exercice 2 · Paramètres nommés

Appelez ajouter en nommant les paramètres, dans un ordre différent de la définition. Pourquoi est-ce utile ?

Voir le corrigé

panier.ajouter(quantite=3, nom="Eau", prix=5)
# Les paramètres nommés rendent l'appel lisible et évitent
# d'inverser le prix et la quantité par erreur.

Exercice 3 · Méthode de classe ou statique ?

Pour chaque méthode, dites si elle doit être d'instance, de classe ou statique : (1) vider() vide le panier ; (2) depuis_ticket(texte) crée un panier à partir d'un ticket ; (3) arrondir(montant) arrondit au centime.

Voir le corrigé

1. d'instance : elle modifie un panier précis (self)
2. de classe  : elle fabrique un nouvel objet (cls)
3. statique   : elle n'a besoin ni du panier ni de la classe

Manipuler les méthodes

1Situer

2Comprendre

Les paramètres d’une méthode

La visibilité d’une méthode

Trois sortes de méthodes

Les fonctions imbriquées

La télécommande

Une méthode qui n'a pas besoin de l'objet

3Manipuler

4Pratiquer

Exercice 1 · Compter les articles

Exercice 2 · Paramètres nommés

Exercice 3 · Méthode de classe ou statique ?

5Vérifier