Héritage et remplacement de __init__ en python

Je lisais 'Dive Into Python' et dans le chapitre sur les classes, il donne cet exemple:

class FileInfo(UserDict):
    "store file metadata"
    def __init__(self, filename=None):
        UserDict.__init__(self)
        self["name"] = filename

L'auteur dit ensuite que si vous souhaitez remplacer la __init__méthode, vous devez appeler explicitement le parent __init__avec les paramètres corrects.

1. Et si cette FileInfoclasse avait plus d'une classe d'ancêtres?
   • Dois-je appeler explicitement toutes les __init__méthodes des classes ancêtres ?
2. Dois-je également le faire pour toute autre méthode que je souhaite remplacer?

Le livre est un peu daté en ce qui concerne les appels de sous-classe-superclasse. Il est également un peu daté en ce qui concerne la sous-classification des classes intégrées.

Cela ressemble à ceci de nos jours:

class FileInfo(dict):
    """store file metadata"""
    def __init__(self, filename=None):
        super(FileInfo, self).__init__()
        self["name"] = filename

Notez ce qui suit:

1. Nous pouvons sous - classe directement intégrée dans les classes, comme dict, list, tuple, etc.

2. La superfonction gère le suivi des superclasses de cette classe et l'appel des fonctions dans celles-ci de manière appropriée.

Dans chaque classe dont vous devez hériter, vous pouvez exécuter une boucle de chaque classe qui doit être initiée lors de l'initiation de la classe enfant ... un exemple qui peut être copié pourrait être mieux compris ...

class Female_Grandparent:
    def __init__(self):
        self.grandma_name = 'Grandma'

class Male_Grandparent:
    def __init__(self):
        self.grandpa_name = 'Grandpa'

class Parent(Female_Grandparent, Male_Grandparent):
    def __init__(self):
        Female_Grandparent.__init__(self)
        Male_Grandparent.__init__(self)

        self.parent_name = 'Parent Class'

class Child(Parent):
    def __init__(self):
        Parent.__init__(self)
#---------------------------------------------------------------------------------------#
        for cls in Parent.__bases__: # This block grabs the classes of the child
             cls.__init__(self)      # class (which is named 'Parent' in this case), 
                                     # and iterates through them, initiating each one.
                                     # The result is that each parent, of each child,
                                     # is automatically handled upon initiation of the 
                                     # dependent class. WOOT WOOT! :D
#---------------------------------------------------------------------------------------#



g = Female_Grandparent()
print g.grandma_name

p = Parent()
print p.grandma_name

child = Child()

print child.grandma_name

Vous n'avez pas vraiment besoin d'appeler les __init__méthodes de la (des) classe (s) de base, mais vous voulez généralement le faire parce que les classes de base y effectueront des initialisations importantes qui sont nécessaires pour que les autres méthodes de classes fonctionnent.

Pour les autres méthodes, cela dépend de vos intentions. Si vous voulez simplement ajouter quelque chose au comportement des classes de base, vous voudrez appeler la méthode des classes de base en plus de votre propre code. Si vous souhaitez modifier fondamentalement le comportement, vous ne pouvez pas appeler la méthode de la classe de base et implémenter toutes les fonctionnalités directement dans la classe dérivée.

Si la classe FileInfo a plus d'une classe ancêtre, vous devez absolument appeler toutes leurs fonctions __init __ (). Vous devez également faire de même pour la fonction __del __ (), qui est un destructeur.

Oui, vous devez appeler __init__pour chaque classe parent. Il en va de même pour les fonctions, si vous remplacez une fonction qui existe dans les deux parents.