Recherche de site Web

Python super() - Python 3 super()

La fonction super() en Python nous permet de référence la classe parente de manière explicite. C'est utile en cas d'héritage où nous souhaitons appeler des fonctions de la super classe.

Python super

Pour comprendre la fonction super de Python, vous devez connaître l'héritage en Python. Dans l'héritage en 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 de Python rend notre tâche plus facile et plus confortable. En nous référant à la superclasse depuis 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 en Python

Au début, regardez simplement le code suivant que nous avons utilisé dans notre tutoriel sur l'héritage en Python. Dans cet exemple de code, la classe parente était Personne et la sous-classe était Étudiant. Le code est donc montré ci-dessous.

class Person:
    # initializing the variables
    name = ""
    age = 0

    # defining constructor
    def __init__(self, person_name, person_age):
        self.name = person_name
        self.age = person_age

        # defining class methods

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

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


definition of subclass starts here
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


end of subclass definition


Create an object of the superclass
person1 = Person("Richard", 23)
call member methods of the objects
person1.show_age()
Create an object of the subclass
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 parente comme suit :

Person.__init__(self, student_name, student_age)

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

super().__init__(student_name, student_age)

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

Python 3 super

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

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

Le premier changement est d'avoir object comme classe de base pour Person. Il est nécessaire d'utiliser la fonction super dans les versions 2.x de Python. 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

Le deuxième changement dans la syntaxe de la fonction super elle-même. Comme vous pouvez le voir, la fonction super de Python 3 est beaucoup plus facile à utiliser et la syntaxe est également claire.

Fonction super de Python avec héritage multilevel

Comme nous l'avons déjà dit, la fonction super() de Python nous permet de faire référence à la superclasse de manière implicite. Mais dans le cas des héritages multi-niveaux, à quelle classe fera-t-elle référence ? Eh bien, la fonction super() de Python fera toujours référence à la superclasse immédiate. De plus, la fonction super() de Python peut non seulement faire référence à la fonction __init__(), mais elle peut aussi appeler toutes les autres fonctions de la superclasse. Ainsi, dans l'exemple suivant, nous allons voir 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)

Voyons le résultat de l'exemple super ci-dessus en python 3 avec l'héritage multi-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, d'après le résultat, 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. Une chose similaire s'est produite en appelant la fonction sub_method().

Pourquoi avons-nous besoin de la fonction super de Python

Si vous avez une expérience préalable en 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 en fait utile pour les programmeurs. Cependant, Python offre également la possibilité au programmeur d'utiliser le nom de la superclasse pour se y référer. Et, si votre programme contient un héritage multi-niveaux, alors cette fonction super() vous sera utile. Voilà donc tout ce qu'il y a à savoir sur la fonction super de Python. J'espère que vous avez compris ce sujet. N'hésitez pas à utiliser la boîte de commentaires pour toute question.

Vous pouvez consulter le script Python complet et d'autres exemples de Python sur notre dépôt GitHub.

Référence : Documentation officielle