Phrases fixes souvent vues dans les constructeurs Tkinter, wxPython

Lors de la création d'une classe qui hérite de n'importe quel widget tel que tk.Frame, wx.Panel dans Tkinter, wxPython, il existe une phrase fixe qui est toujours dans l'exemple et qui est également utilisée par moi-même.

class MyTkinterFrame(tk.Frame):
    def __init__(self, master = None):
        #cette!
        tk.Frame.__init__(self, master)
        ...

class MyWxPanel(wx.Panel):
    def __init__(self, parent = None):
        #Cela aussi!
        wx.Frame.__init__(self, master = None):
        ...

Je ne comprends pas la signification de ce processus, mais si je ne l'ajoute pas, une erreur se produira, alors j'ai pensé que c'était un sort pour le moment, mais quand j'y réfléchis attentivement, j'appelle juste le constructeur de la classe source d'héritage **. Je l'ai remarqué, alors prenez note.

N'est-ce pas trop évident pour ceux qui le savent? De plus, même si vous ne le savez pas, vous pouvez passer un merveilleux Tkinter, wxPython Life si vous l'écrivez pour le moment. Veuillez l'utiliser comme une connaissance du haricot.

Supplément @ 2017-01-18

J'ai reçu un commentaire, mais j'ai fait une erreur. Dans le texte, init ___ '' est appelé le constructeur, et l'appel à __ init``` est appelé l'appel du constructeur. Mais __init __ '' de Python n'est pas un constructeur. Je suis désolé de comprendre que c'est probablement un processus d'initialisation lorsqu'on lui demande quelque chose, mais ... Référence: [À propos de la classe de base `` init () '' ''](http://kk6.hateblo.jp/entry/20110429/1304074964) Je ne connaissais pas le remplacement approprié, donc je n'ai pas corrigé toute la phrase. Veuillez lire attentivement la partie appelée constructeur dans le texte. )

Argument implicite de soi

En Python, l'argument implicite `` self``` est masqué lors de l'appel d'une méthode d'instance d'une classe. L'appel suivant peut appeler le même processus.

class SomeClass:
    def SomeMethod(self):
        # do something
        ...
    
    def OtherMethod(self):
        self.SomeMethod()   #Partie 1

    def AnotherMethod(self):
        # SomeMethod(self)    #Partie 2<-Postscript:Cet appel entraînera une erreur, mais je l'ai écrit faute de confirmation, alors je l'ai corrigé.
        SomeClass.SomeMethod(self)   #Partie 2

À propos, il pourrait être appelé à la fois en notation * 2 * et en dehors de la classe.

instance = SomeClass()
instance.SomeMethod()     #Partie 1
SomeClass.SomeMethod(instance)  #Partie 2

La notation de la partie 2 * est rarement utilisée. Et puisque vous passez les valeurs requises dans les arguments, vous devriez pouvoir l'appeler. ** Je suis surpris de pouvoir écrire ceci. ** Vous pouvez écrire comme ça! C'est vrai si vous le dites! Je ne peux que dire ça. C'est une spécification de langage. Est-ce que c'est comme Python?

Appelez `` init``` de la classe héritière de la classe héritière

En Python, le constructeur de la classe héritée n'appelle pas implicitement la classe héritée. Par conséquent, lors de l'héritage, il est nécessaire d'appeler explicitement le constructeur source héritant.

class MyInherit(MySuper):
    def __init__(self):
       #Appelez le constructeur héritier
       #La notation suivante ne peut être utilisée qu'avec Python3
       super().__init__()

class MyInherit(MySuper):
    def __init__(self):
       #Appelez le constructeur héritier,Python 2 est OK
       super(MySuper, self).__init__()

C'est une affaire très personnelle, mais je programme rarement avec héritage. Cependant, cela semble être tout à fait normal en Python, Tkinter et wxPython, donc je l'ai appris.

(Référence: Comment utiliser la fonction super () de Python)

Aligner l'auto-spécification explicite avec l'appel init de la classe héritière

Et la phrase fixe en question.

Les appels au constructeur __init __ de la classe héritière peuvent être effectués sans utiliser `` `` super () '' ``. Cela peut être plus courant comme un appel `` `` __ init__ à la classe héritière. self``` est explicitement passé en argument et appelé.

class MyInherit(MySuper):
    def __init__(self):
       #Appelez le constructeur héritier
       # Python 2,Possible dans les deux Python 3
       MySuper.__init__(self)
       ...

Je vois!

Pourquoi n'avez-vous pas remarqué cela?

~~ Fierté et croyance ~~ Le langage que j'ai le plus utilisé jusqu'à présent était C #, et la méthode d'appel du constructeur de source d'héritage était différente. De plus, en ce qui concerne les méthodes de classe, j'ai pensé qu'il était naturel d'appeler <instance variable>. <Method> (...).

Le constructeur de la source d'héritage C # est appelé lorsque le constructeur est déclaré.

class MyInherit : MySuper
{
    //constructeur
    public MyInherit(int val) : MySuper(val)
    {
        // do initialize...
    }
}

Je n'ai pas touché C ++ ou Java, mais il semble qu'un appel de constructeur de source d'héritage implicite soit également effectué.

(Référence: Constructeur et destructeur C #)

Résumé

En Python, un appel explicite au constructeur de classe d'héritage init``` est ** requis **.
La phrase fixe pour l'héritage consiste à spécifier explicitement l'argument de `` self ''.
Vous vous êtes un peu familiarisé avec les différences entre les langages de programmation.

Pour moi personnellement, je voudrais me rappeler comment utiliser et écrire, et expliquer pourquoi il y a une telle différence que ** différence culturelle ** et passer à l'étape suivante.

Aussi, je pense que `` super () .__ init__ () '' est excellent en termes de lisibilité et de facilité de communication du sens, mais si c'est une fonction de Python3, elle sera pénétrée à partir de maintenant. Ce sera une histoire. Je veux l'utiliser positivement.

Environnement confirmé

OS : Windows 10
Python : 3.5.2 --Installé avec Anaconda --Tkinter: Python 3.5.2 inclus, version non confirmée
wxPython : wxPython-Phoenix 3.0.3.dev2749

__init__ appelé par wxPython ou Tkinter était un appel __init__ de la classe héritée en Python