super()

Appelle une méthode de la classe de base depuis la classe dérivée, le plus souvent le constructeur __init__.

Renvoie
Un objet intermédiaire par lequel vous appelez les méthodes de la classe suivante dans l’ordre MRO, généralement la classe de base.
Sur cette page

Exemple

#
Python
class User:
    def __init__(self, name):
        self.name = name
        self.active = True

class Student(User):
    def __init__(self, name, world):
        super().__init__(name)
        self.world = world
        self.points = 0

emma = Student("Emma", 7)
print(emma.name, emma.active)
print(emma.world, emma.points)
Résultatrésultat enregistré, vous pouvez le vérifier
Emma True
7 0

Définition et utilisation

#

La fonction super() renvoie un objet intermédiaire par lequel vous appelez une méthode de la classe de base. On l’utilise le plus souvent dans le __init__ de la classe dérivée : super().__init__(name) laisse la classe de base configurer ses propres attributs, et la classe dérivée n’ajoute que les nouveaux.

On étend de la même façon n’importe quelle méthode redéfinie. Au lieu de copier le code de la classe de base, vous appelez super().méthode() et ajoutez quelque chose avant ou après. Si vous ne le faites pas, la version de base ne s’exécute pas du tout. Pour __init__, cela signifie que les attributs définis par la classe de base manquent.

À l’intérieur d’une méthode, il suffit d’écrire super() sans arguments, car Python détermine lui-même la classe et l’objet. En cas d’héritage multiple, super() ne désigne pas simplement « le parent », mais la classe suivante dans l’ordre MRO de l’objet. Ainsi, chaque classe de la hiérarchie s’exécute exactement une fois, à condition que toutes appellent super() de façon cohérente.

Syntaxe

#
Syntaxe
class Dérivée(Base):
    def __init__(self, a, b):
        super().__init__(a)
        self.b = b

    def méthode(self):
        résultat = super().méthode()
        ...

Paramètres

#
  • type

    classe, optionnelle

    La classe à partir de laquelle commence la recherche de la méthode dans l’ordre MRO. Omise à l’intérieur des méthodes.
  • object_or_type

    objet ou classe, optionnel

    L’objet pour lequel vous appelez la méthode. Omis à l’intérieur des méthodes.

Plus d’exemples

#
Étendre une méthode redéfinie
Python
class Reward:
    def __init__(self, exp):
        self.exp = exp

    def describe(self):
        return f"+{self.exp} EXP"

class StreakReward(Reward):
    def __init__(self, exp, days):
        super().__init__(exp)
        self.days = days

    def describe(self):
        return super().describe() + f" et une série de {self.days} jours"

print(Reward(10).describe())
print(StreakReward(15, 7).describe())
Résultatrésultat enregistré, vous pouvez le vérifier
+10 EXP
+15 EXP et une série de 7 jours
Sans super().__init__(), des attributs manquent
Python
class User:
    def __init__(self, name):
        self.name = name

class Mentor(User):
    def __init__(self, name, course):
        self.course = course

darwin = Mentor("Darwin", "Python")
print(darwin.course)
print(hasattr(darwin, "name"))
Résultatrésultat enregistré, vous pouvez le vérifier
Python
False
super() avec l’héritage multiple
Python
class Lesson:
    def start(self):
        print("Lesson: chargement du contenu")

class WithTimer(Lesson):
    def start(self):
        print("WithTimer: démarrage du chrono")
        super().start()

class WithHints(Lesson):
    def start(self):
        print("WithHints: préparation des indices")
        super().start()

class Quiz(WithTimer, WithHints):
    def start(self):
        print("Quiz: start")
        super().start()

Quiz().start()
Résultatrésultat enregistré, vous pouvez le vérifier
Quiz: start
WithTimer: démarrage du chrono
WithHints: préparation des indices
Lesson: chargement du contenu

super() dans la classe WithTimer appelle la méthode de WithHints, et non de Lesson, car c’est l’ordre MRO de l’objet Quiz. Grâce à cela, Lesson.start() ne s’exécute qu’une seule fois.

Bonnes pratiques

#
  • Dans le __init__ d’une classe dérivée, appelez super().__init__(...) au début, avant d’utiliser les attributs définis par la classe de base.
  • N’écrivez pas le nom de la classe de base en dur, par ex. User.__init__(self, name). super() continue de fonctionner correctement même après un changement de hiérarchie, et aussi avec l’héritage multiple.
  • Avec l’héritage multiple, chaque classe de la chaîne devrait appeler super(). Une seule classe sans cet appel interrompt toute la chaîne.

Entrées associées

#

Pratiquer dans les leçons

#

Vous voyez une erreur ou il manque un exemple ? Écrivez-nous.