Ereditarietà e sostituzione __init__ in python

Stavo leggendo "Dive Into Python" e nel capitolo sulle lezioni fornisce questo esempio:

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

L'autore afferma quindi che se si desidera sovrascrivere il __init__metodo, è necessario chiamare esplicitamente il genitore __init__con i parametri corretti.

1. E se quella FileInfoclasse avesse avuto più di una classe antenata?
   • Devo chiamare esplicitamente tutti i __init__metodi delle classi antenate ?
2. Inoltre, devo fare questo con qualsiasi altro metodo che voglio sovrascrivere?

Il libro è un po 'datato rispetto alla chiamata sottoclasse-superclasse. È anche un po 'datato rispetto alla sottoclasse delle classi incorporate.

Oggi sembra così:

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

Nota quanto segue:

1. Siamo in grado di creare una sottoclasse direttamente classi incorporate, come dict, list, tuple, etc.

2. La superfunzione gestisce il rintracciamento delle superclassi di questa classe e il richiamo delle funzioni in esse in modo appropriato.

In ogni classe da cui devi ereditare, puoi eseguire un ciclo di ogni classe che deve essere avviata all'avvio della classe figlio ... un esempio che può essere copiato potrebbe essere meglio compreso ...

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

Non è davvero necessario chiamare i __init__metodi della classe di base (es), ma di solito si desidera farlo, perché le classi di base faranno alcune inizializzazioni importanti c'è che sono necessari per il riposo dei metodi classi per lavoro.

Per altri metodi dipende dalle tue intenzioni. Se vuoi solo aggiungere qualcosa al comportamento delle classi di base, dovrai chiamare il metodo delle classi di base in aggiunta al tuo codice. Se si desidera cambiare radicalmente il comportamento, è possibile che non si chiami il metodo della classe base e si implementino tutte le funzionalità direttamente nella classe derivata.

Se la classe FileInfo ha più di una classe antenata, allora dovresti assolutamente chiamare tutte le loro funzioni __init __ (). Dovresti anche fare lo stesso per la funzione __del __ (), che è un distruttore.

Sì, devi chiamare __init__per ogni classe genitore. Lo stesso vale per le funzioni, se si sostituisce una funzione esistente in entrambi i genitori.