Utilisation de la fonction super() dans les classes Python

Points clés à retenir

• La fonction super() de Python vous permet d'appeler des méthodes de superclasse à partir d'une sous-classe, ce qui facilite la mise en œuvre de l'héritage et du remplacement de méthodes.
• La fonction super() est étroitement liée à l'ordre de résolution de méthode (MRO) en Python, qui détermine l'ordre dans lequel les classes ancêtres sont recherchées pour les méthodes ou les attributs.
• L'utilisation de super() dans les constructeurs de classe est une pratique courante pour initialiser des attributs communs dans la classe parent et des attributs plus spécifiques dans la classe enfant. Ne pas utiliser super() peut entraîner des conséquences inattendues, telles que des initialisations d'attributs manquantes.

L'une des principales fonctionnalités de Python est son paradigme POO, que vous pouvez utiliser pour modéliser des entités du monde réel et leurs relations.

Lorsque vous travaillez avec des classes Python, vous utiliserez souvent l'héritage et remplacerez les attributs ou les méthodes d'une superclasse. Python fournit un super() fonction qui vous permet d’appeler les méthodes de la superclasse depuis la sous-classe.

Qu'est-ce que super() et pourquoi en avez-vous besoin?

Grâce à l'héritage, vous pouvez créer une nouvelle classe Python qui hérite des fonctionnalités d'une classe existante. Vous pouvez également remplacer les méthodes de la superclasse dans la sous-classe, fournissant ainsi des implémentations alternatives. Cependant, vous souhaiterez peut-être utiliser la nouvelle fonctionnalité en plus de l’ancienne plutôt qu’à sa place. Dans ce cas, super() est utile.

Vous pouvez utiliser le super() fonction pour accéder aux attributs de la superclasse et invoquer les méthodes de la superclasse. Super est essentiel pour programmation orientée objet car cela facilite la mise en œuvre de l'héritage et du remplacement de méthode.

Comment fonctionne super()?

Intérieurement, super() est étroitement lié à Ordre de résolution de la méthode (MRO) en Python, déterminé par l'algorithme de linéarisation C3.

Voici comment super() travaux:

1. Déterminer la classe et l'instance actuelles: Quand vous appelez super() à l'intérieur d'une méthode d'une sous-classe, Python détermine automatiquement la classe actuelle (la classe contenant la méthode qui a appelé super()) et l'instance de cette classe (c'est-à-dire, soi).
2. Déterminer la superclasse: super() prend deux arguments: la classe actuelle et l'instance, que vous n'avez pas besoin de transmettre explicitement. Il utilise ces informations pour déterminer la superclasse à qui déléguer l'appel de méthode. Pour ce faire, il examine la hiérarchie des classes et le MRO.
3. Invoquer la méthode sur la Superclasse: Une fois la superclasse déterminée, super() vous permet d'appeler ses méthodes comme si vous les appeliez directement depuis la sous-classe. Cela vous permet d'étendre ou de remplacer des méthodes tout en utilisant l'implémentation d'origine de la superclasse.

Utiliser super() dans un constructeur de classe

En utilisant super() dans un constructeur de classe est une pratique courante, car vous souhaiterez souvent initialiser des attributs communs dans la classe parent et des attributs plus spécifiques dans la classe enfant.

Pour le démontrer, définir une classe Python, Père, lequel un Fils la classe hérite de :

classFather:
def__init__(self, first_name, last_name):
 self.first_name = first_name
 self.last_name = last_name
classSon(Father):
def__init__(self, first_name, last_name, age, hobby):
# Call the parent class constructor (Father)
 super().__init__(first_name, last_name)
 self.age = age
 self.hobby = hobby
defget_info(self):
returnf"Son's Name: {self.first_name}{self.last_name}, \
Son's Age: {self.age}, Son's Hobby: {self.hobby}"
# Create an instance of the Son class
son = Son("Pius", "Effiong", 25, "Playing Guitar")
# Access attributes
print(son.get_info())

À l'intérieur de Fils constructeur, l'appel à super().init() invoque le Père constructeur de classe, en le passant prénom et nom de famille comme paramètres. Cela garantit que le Père la classe peut toujours définir correctement les attributs de nom, même sur un Fils objet.

Si vous n'appelez pas super() dans un constructeur de classe, le constructeur de sa classe parent ne s'exécutera pas. Cela peut entraîner des conséquences inattendues, telles que des initialisations d'attributs manquantes ou une configuration incomplète de l'état de la classe parent :

...
classSon(Father):
def__init__(self, first_name, last_name, age, hobby):
 self.age = age
 self.hobby = hobby
...

Si vous essayez maintenant d'appeler le get_info méthode, cela soulèvera un Erreur d'attribut parce que le soi.prénom_ et soi.nom_de_famille les attributs n'ont pas été initialisés.

Utilisation de super() dans les méthodes de classe

Vous pouvez utiliser super() dans d'autres méthodes, en dehors des constructeurs, de la même manière. Cela vous permet d'étendre ou de remplacer le comportement de la méthode de la superclasse.

classFather:
defspeak(self):
return"Hello from Father"
classSon(Father):
defspeak(self):
# Call the parent class's speak method using super()
 parent_greeting = super().speak()
returnf"Hello from Son\n{parent_greeting}"
# Create an instance of the Son class
son = Son()
# Call the speak method of the Son class
son_greeting = son.speak()
print(son_greeting)

Le Fils la classe hérite de Père et a son parler méthode. Le parler méthode du Fils utilisations en classe super().parler() appeler le parler méthode du Père classe. Cela lui permet d'inclure le message de la classe parent tout en l'étendant avec un message spécifique à la classe enfant.

Ne pas utiliser super() dans une méthode qui en remplace une autre, la fonctionnalité présente dans la méthode de la classe parent ne prendra pas effet. Cela entraîne un remplacement complet du comportement de la méthode, ce qui peut conduire à un comportement que vous n'aviez pas prévu.

Comprendre l'ordre de résolution des méthodes

L'ordre de résolution des méthodes (MRO) est l'ordre dans lequel Python recherche les classes ancêtres lorsque vous accédez à une méthode ou à un attribut. MRO aide Python à déterminer quelle méthode appeler lorsque plusieurs hiérarchies d'héritage existent.

classNigeria():
defculture(self):
print("Nigeria's culture")
classAfrica():
defculture(self):
print("Africa's culture")

Voici ce qui se passe lorsque vous créez une instance de Lagos classe et appelle le culture méthode:

1. Python commence par rechercher le culture méthode dans le Lagos classe elle-même. S'il le trouve, il appelle la méthode. Dans le cas contraire, on passe à la deuxième étape.
2. S'il ne trouve pas le culture méthode dans le Lagos classe, Python examine les classes de base dans l'ordre dans lequel elles apparaissent dans la définition de classe. Dans ce cas, Lagos hérite d'abord de Afrique et puis de Nigeria. Ainsi, Python recherchera le culture méthode dans Afrique d'abord.
3. S'il ne trouve pas le culture méthode dans le Afrique classe, Python regardera alors dans la classe Nigeria classe. Ce comportement continue jusqu'à ce qu'il atteigne la fin de la hiérarchie et génère une erreur s'il ne trouve la méthode dans aucune des superclasses.

La sortie montre l'ordre de résolution de la méthode de Lagos, en commençant de gauche à droite.

Pièges courants et meilleures pratiques

Lorsque vous travaillez avec super(), il y a quelques pièges courants à éviter.

1. Soyez attentif à l’ordre de résolution des méthodes, en particulier dans les scénarios d’héritage multiple. Si vous devez utiliser l'héritage multiple complexe, vous devez connaître le Algorithme de linéarisation C3 que Python utilise pour déterminer le MRO.
2. Évitez les dépendances circulaires dans votre hiérarchie de classes, qui peuvent conduire à un comportement imprévisible.
3. Documentez clairement votre code, surtout lors de l'utilisation super() dans des hiérarchies de classes complexes, pour le rendre plus compréhensible pour les autres développeurs.

Utilisez super() de la bonne manière

Les Pythons super() La fonction est une fonctionnalité puissante lorsque vous travaillez avec l’héritage et le remplacement de méthodes. Comprendre comment super() fonctionne et suivre les meilleures pratiques vous permettra de créer un code plus maintenable et plus efficace dans vos projets Python.