Python super() – Python 3 super()

Le langage Python dispose de la fonction super() qui nous permet de faire référence de manière explicite à la classe parente. Cela est utile dans le cas de l’héritage lorsque nous voulons appeler des fonctions de la classe parente.

Python super

Pour comprendre la fonction super de Python, il est nécessaire de connaître l’héritage en Python. Dans l’héritage Python, les sous-classes héritent de la superclasse. La fonction super() de Python nous permet de faire référence à la superclasse de manière implicite. Ainsi, super() rend notre tâche plus facile et confortable. Lorsque nous faisons référence à la superclasse à partir de la sous-classe, nous n’avons pas besoin d’écrire le nom de la superclasse explicitement. Dans les sections suivantes, nous discuterons de la fonction super de Python.

Exemple de la fonction super de Python

Tout d’abord, examinez le code suivant que nous avons utilisé dans notre tutoriel sur l’héritage Python. Dans cet exemple, la superclasse était Personne et la sous-classe était Étudiant. Le code est présenté ci-dessous.

class Person:
    # initialisation des variables
    name = ""
    age = 0

    # définition du constructeur
    def __init__(self, person_name, person_age):
        self.name = person_name
        self.age = person_age

        # définition des méthodes de classe

    def show_name(self):
        print(self.name)

    def show_age(self):
        print(self.age)


# la définition de la sous-classe commence ici
class Student(Person):
    studentId = ""

    def __init__(self, student_name, student_age, student_id):
        Person.__init__(self, student_name, student_age)
        self.studentId = student_id

    def get_id(self):
        return self.studentId  # returns the value of student id


# fin de la définition de la sous-classe


# Créer un objet de la superclasse
person1 = Person("Richard", 23)
# appeler les méthodes membres des objets
person1.show_age()
# Créer un objet de la sous-classe
student1 = Student("Max", 22, "102")
print(student1.get_id())
student1.show_name()

Dans l’exemple ci-dessus, nous avons appelé la fonction de la classe parent comme suit :

Person.__init__(self, student_name, student_age) 

Nous pouvons remplacer cela par un appel de fonction super python comme ci-dessous.

super().__init__(student_name, student_age)

La sortie restera la même dans les deux cas, comme indiqué dans l’image ci-dessous.

Python 3 super

Notez que la syntaxe ci-dessus est pour la fonction super python 3. Si vous utilisez des versions python 2.x, alors c’est légèrement différent et vous devrez apporter les modifications suivantes :

class Person(object):
...
        super(Student, self).__init__(student_name, student_age)

La première modification consiste à avoir object comme classe de base pour Personne. Il est nécessaire d’utiliser la fonction super en Python 2.x versions. Sinon, vous obtiendrez l’erreur suivante.

Traceback (most recent call last):
  File "super_example.py", line 40, in <module>
    student1 = Student("Max", 22, "102")
  File "super_example.py", line 25, in __init__
    super(Student, self).__init__(student_name, student_age)
TypeError: must be type, not classobj

La deuxième modification concerne la syntaxe de la fonction super elle-même. Comme vous pouvez le voir, la fonction super python 3 est beaucoup plus facile à utiliser et la syntaxe est également propre.

Fonction super Python avec héritage à plusieurs niveaux

Comme nous l’avons mentionné précédemment, la fonction super() en Python nous permet de faire référence à la superclasse implicitement. Mais dans le cas des héritages à plusieurs niveaux, à quelle classe fera-t-elle référence? Eh bien, super() en Python fera toujours référence à la superclasse immédiate. De plus, la fonction super() en Python peut non seulement faire référence à la fonction __init__() mais aussi appeler toutes les autres fonctions de la superclasse. Donc, dans l’exemple suivant, nous verrons cela.

class A:
    def __init__(self):
        print('Initializing: class A')

    def sub_method(self, b):
        print('Printing from class A:', b)


class B(A):
    def __init__(self):
        print('Initializing: class B')
        super().__init__()

    def sub_method(self, b):
        print('Printing from class B:', b)
        super().sub_method(b + 1)


class C(B):
    def __init__(self):
        print('Initializing: class C')
        super().__init__()

    def sub_method(self, b):
        print('Printing from class C:', b)
        super().sub_method(b + 1)


if __name__ == '__main__':
    c = C()
    c.sub_method(1)

Jetons un coup d’œil à la sortie de l’exemple super Python 3 ci-dessus avec un héritage à plusieurs niveaux.

Initializing: class C
Initializing: class B
Initializing: class A
Printing from class C: 1
Printing from class B: 2
Printing from class A: 3

Donc, à partir de la sortie, nous pouvons clairement voir que la fonction __init__() de la classe C a été appelée en premier, puis la classe B et ensuite la classe A. La même chose s’est produite en appelant la fonction sub_method().

Pourquoi avons-nous besoin de la fonction super Python

Si vous avez une expérience antérieure dans le langage Java, alors vous devriez savoir que la classe de base est également appelée par un objet super là-bas. Ainsi, ce concept est réellement utile pour les codeurs. Cependant, Python offre également la possibilité au programmeur d’utiliser le nom de la superclasse pour les référencer. De plus, si votre programme contient une héritage à plusieurs niveaux, alors cette fonction super() vous sera utile. Voilà tout ce qu’il y a à savoir sur la fonction super de Python. Espérons que vous avez bien compris ce sujet. N’hésitez pas à utiliser la boîte de commentaires pour toute question.

Vous pouvez consulter le script Python complet et plus d’exemples Python sur notre Dépôt GitHub.

Référence : Documentation officielle