Python Academy · Leçon

Méthodes d’instance et self

Écrivez des méthodes qui agissent sur les propres données de l’objet.

Méthodes d’instance et self est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Introduction

Les méthodes d’instance agissent sur les données d’un objet précis, en utilisant self pour accéder à ses attributs et les modifier.

Définir des méthodes d’instance

def method(self): à l’intérieur d’une classe est une méthode d’instance. Elle reçoit l’objet comme premier argument (self).

class Circle:
    def __init__(self, r): self.r = r
    def area(self):
        import math
        return math.pi * self.r**2
print(Circle(5).area())

Appeler des méthodes

obj.method() est une notation simplifiée de ClassName.method(obj). Python transmet automatiquement obj comme self.

class Dog:
    def __init__(self, name): self.name = name
    def bark(self): print(f'{self.name} says Woof!')
Dog('Rex').bark()

Méthodes renvoyant self

Renvoyer self permet l’enchaînement des méthodes : builder.set_name('x').set_age(3).build().

class Builder:
    def __init__(self): self.data = {}
    def set(self, k, v):
        self.data[k] = v
        return self
    def build(self): return self.data
result = Builder().set('x',1).set('y',2).build()
print(result)

Méthodes privées (convention)

Préfixez le nom par _ pour signaler un « usage interne ». Le préfixe __ déclenche la transformation du nom : _ClassName__method.

class Account:
    def __init__(self, bal): self._bal = bal
    def _validate(self, amount): return amount > 0
    def deposit(self, amount):
        if self._validate(amount):
            self._bal += amount
a = Account(100)
a.deposit(50)
print(a._bal)

Propriétés comme méthodes

@property transforme une méthode en attribut lisible. Aucune parenthèse n’est nécessaire lors de l’accès.

class Circle:
    def __init__(self, r): self.r = r
    @property
    def diameter(self): return self.r * 2
c = Circle(5)
print(c.diameter)  # no ()

Modifier l’état

Les méthodes qui modifient les attributs de self changent l’état de l’objet. Concevez des méthodes dont l’intention est claire : consultation ou commande.

class Stack:
    def __init__(self): self.items = []
    def push(self, x): self.items.append(x)
    def pop(self): return self.items.pop()
    def peek(self): return self.items[-1]
s = Stack()
s.push(1); s.push(2)
print(s.pop(), s.peek())

Comparer des objets

Par défaut, == compare l’identité. Implémentez __eq__ pour comparer les valeurs.

class Point:
    def __init__(self, x, y): self.x,self.y=x,y
    def __eq__(self, other): return self.x==other.x and self.y==other.y
print(Point(1,2)==Point(1,2))

Protocole d’itération

Implémentez __iter__ et __next__ pour rendre une classe itérable, c’est-à-dire utilisable dans des boucles for.

class Countdown:
    def __init__(self, n): self.n = n
    def __iter__(self): return self
    def __next__(self):
        if self.n <= 0: raise StopIteration
        self.n -= 1; return self.n + 1
print(list(Countdown(3)))

Protocole de gestionnaire de contexte

Implémentez __enter__ et __exit__ pour rendre une classe utilisable dans des instructions with.

class Timer:
    def __enter__(self):
        import time
        self.start = time.time()
        return self
    def __exit__(self, *args):
        import time
        print(f'elapsed: {time.time()-self.start:.3f}s')
with Timer(): pass

Méthode ou fonction

Lorsqu’elle est appelée depuis la classe, Dog.bark est une simple fonction. Depuis une instance, d.bark est une méthode liée : self est prérempli.

class Dog:
    def bark(self): print('woof')
print(type(Dog.bark))
print(type(Dog().bark))

Vérification rapide

Qu’est-ce que l’enchaînement des méthodes et que doit renvoyer une méthode pour le permettre ?

Récapitulatif

Méthodes d’instance : def m(self). Appelez-les avec obj.m(). Renvoyez self pour permettre l’enchaînement. __eq__/__iter__/__enter__/__exit__ implémentent des protocoles. Le préfixe _ signale un usage interne.

Continuez

Excellent ! Continuez avec la leçon suivante pour approfondir vos compétences.

Questions Fréquemment Posées

La leçon « Méthodes d’instance et self » est-elle gratuite ?

Oui — le texte complet de « Méthodes d’instance et self » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Méthodes d’instance et self » ?

Écrivez des méthodes qui agissent sur les propres données de l’objet. Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Méthodes d’instance et self » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Python Academy