Python Academy · Leçon

Redéfinition de méthodes et super()

Redéfinissez les méthodes parentes et appelez-les avec super().

Redéfinition de méthodes et super() est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 2 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

La redéfinition de méthodes permet aux classes enfants de personnaliser un comportement hérité. super() permet d’appeler l’implémentation d’origine.

Principes de la redéfinition

Définissez le même nom de méthode dans la classe enfant pour remplacer la version du parent pour toutes les instances de l’enfant.

class Greeter:
    def greet(self): return 'Hello'
class FormalGreeter(Greeter):
    def greet(self): return 'Good day'
print(FormalGreeter().greet())

super() dans les redéfinitions

super().greet() dans l’enfant appelle la version du parent. C’est utile pour étendre le comportement plutôt que le remplacer complètement.

class Logger:
    def log(self, msg): print(f'[LOG] {msg}')
class TimedLogger(Logger):
    def log(self, msg):
        import time
        super().log(f'{time.time():.0f}: {msg}')
TimedLogger().log('test')

super() dans init

Appelez toujours super().__init__() dans le __init__ de l’enfant afin de garantir l’exécution de l’initialisation du parent.

class Animal:
    def __init__(self, name): self.name = name
class Cat(Animal):
    def __init__(self, name, indoor):
        super().__init__(name)
        self.indoor = indoor
cat = Cat('Whiskers', True)
print(cat.name, cat.indoor)

super() avec des arguments

super(ChildClass, self) est la forme explicite, héritée du style de Python 2. Python 3 permet généralement d’utiliser super() sans arguments.

class A:
    def greet(self): return 'A'
class B(A):
    def greet(self): return super().greet() + 'B'
class C(B):
    def greet(self): return super().greet() + 'C'
print(C().greet())

Héritage coopératif

Dans l’héritage multiple, super() suit le MRO. Chaque classe qui appelle super() garantit l’initialisation de toutes les classes de la chaîne.

class A:
    def __init__(self): print('A init')
class B(A):
    def __init__(self): super().__init__(); print('B init')
class C(A):
    def __init__(self): super().__init__(); print('C init')
class D(B, C):
    def __init__(self): super().__init__(); print('D init')
D()

Redéfinir str

Redéfinissez __str__ dans l’enfant pour personnaliser l’affichage des instances.

class Animal:
    def __init__(self, name): self.name = name
    def __str__(self): return f'Animal: {self.name}'
class Dog(Animal):
    def __str__(self): return f'Dog: {self.name}'
print(Dog('Rex'))

Patron de méthode modèle

Le parent définit la structure de l’algorithme ; l’enfant fournit les étapes en redéfinissant certaines méthodes.

class DataProcessor:
    def process(self):
        data = self.load()
        return self.transform(data)
    def load(self): return [1,2,3]
    def transform(self, d): return d
class Doubler(DataProcessor):
    def transform(self, d): return [x*2 for x in d]
print(Doubler().process())

Appeler la méthode d’une classe sœur

Avec super() et un MRO correct, vous pouvez appeler la méthode d’une classe sœur dans un héritage multiple : c’est le super() coopératif.

class A:
    def hello(self): print('A')
class B(A):
    def hello(self): super().hello(); print('B')
class C(A):
    def hello(self): super().hello(); print('C')
class D(B,C):
    def hello(self): super().hello(); print('D')
D().hello()

__init_subclass__

__init_subclass__ est appelée chaque fois que la classe est sous-classée. Elle est utile pour les modèles d’enregistrement de modules d’extension.

class Plugin:
    registry = []
    def __init_subclass__(cls, **kw):
        super().__init_subclass__(**kw)
        Plugin.registry.append(cls)
class A(Plugin): pass
class B(Plugin): pass
print([c.__name__ for c in Plugin.registry])

Quand ne pas redéfinir

Ne redéfinissez pas une méthode si vous n’avez pas besoin de modifier son comportement. Les redéfinitions inutiles alourdissent la maintenance. Préférez la composition pour les comportements sans lien.

# Good: only override what's needed
class Dog(Animal):
    def speak(self): return 'Woof'
    # No need to override __init__ if parent's is fine
print('override guidance')

Vérification rapide

Dans Python 3, à quoi super() (sans arguments) fait-il référence à l’intérieur d’une méthode ?

Récapitulatif

Redéfinissez une méthode en la redéclarant dans l’enfant. super().method() appelle la version du parent. super().__init__() initialise le parent. Le super() coopératif suit l’ordre du MRO.

Continuez

Vos progrès sont excellents ! Continuez pour maîtriser le prochain concept.

Questions Fréquemment Posées

La leçon « Redéfinition de méthodes et super() » est-elle gratuite ?

Oui — le texte complet de « Redéfinition de méthodes et super() » 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 « Redéfinition de méthodes et super() » ?

Redéfinissez les méthodes parentes et appelez-les avec super(). 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 2 sur 4.

Combien de temps prend la leçon « Redéfinition de méthodes et super() » ?

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