Feste Phrasen, die häufig in Tkinter- und wxPython-Konstruktoren vorkommen

Beim Erstellen einer Klasse, die ein Widget wie tk.Frame, wx.Panel in Tkinter, wxPython erbt, gibt es eine feste Phrase, die immer im Beispiel enthalten ist und auch von mir selbst verwendet wird.

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

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

Ich verstehe die Bedeutung dieses Prozesses nicht, aber wenn ich ihn nicht hinzufüge, tritt ein Fehler auf, und ich dachte, es sei vorerst ein Zauber, aber wenn ich mir das genau überlege, habe ich nur den Konstruktor der Vererbungsquellenklasse ** aufgerufen. Ich habe es bemerkt, also mach dir eine Notiz.

Ist es nicht zu offensichtlich für diejenigen, die es wissen? Auch wenn Sie es nicht wissen, können Sie ein wunderbares Tkinter, wxPython Life, verbringen, wenn Sie es vorerst schreiben. Bitte verwenden Sie es als Bohnenwissen.

Nachtrag @ 2017-01-18

Ich habe einen Kommentar erhalten, aber einen Fehler gemacht. Im Text wird `__init ___` als Konstruktor bezeichnet, und der Aufruf von __init __``` wird als Konstruktoraufruf bezeichnet. Aber Pythons __init __``` ist kein Konstruktor. Es tut mir leid zu verstehen, dass es wahrscheinlich ein Initialisierungsprozess ist, wenn etwas gefragt wird, aber ... Referenz: [Informationen zur Basisklasse `` init ()` ``](http://kk6.hateblo.jp/entry/20110429/1304074964) Ich kannte den richtigen Ersatz nicht, also habe ich nicht den ganzen Satz korrigiert. Bitte lesen Sie den Teil, der im Text als Konstruktor bezeichnet wird, sorgfältig durch. )

Implizites Argument selbst

In Python wird das implizite Argument `` `self``` beim Aufrufen einer Instanzmethode einer Klasse ausgeblendet. Der nächste Aufruf kann denselben Prozess aufrufen.

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

    def AnotherMethod(self):
        # SomeMethod(self)    #Teil 2<-Nachtrag:Dieser Aufruf führt zu einem Fehler, aber ich habe ihn aufgrund fehlender Bestätigung geschrieben und ihn behoben.
        SomeClass.SomeMethod(self)   #Teil 2

Übrigens könnte es sowohl in * 2 * -Notation als auch außerhalb der Klasse aufgerufen werden.

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

Teil 2 * Notation wird selten verwendet. Und da Sie die erforderlichen Werte in den Argumenten übergeben, sollten Sie sie aufrufen können. ** Ich bin überrascht, dies schreiben zu können. ** Du kannst so schreiben! Das ist richtig, wenn du es sagst! Das kann ich nur sagen. Es ist eine Sprachspezifikation. Ist es wie Python?

Rufen Sie `` `init``` der ererbenden Klasse von der ererbenden Klasse auf

In Python ruft der Konstruktor der ererbenden Klasse die geerbte Klasse nicht implizit auf. Daher ist es beim Erben erforderlich, den erbenden Quellkonstruktor explizit aufzurufen.

class MyInherit(MySuper):
    def __init__(self):
       #Rufen Sie den Vererbungskonstruktor auf
       #Die folgende Notation kann nur mit Python3 verwendet werden
       super().__init__()

Oder

class MyInherit(MySuper):
    def __init__(self):
       #Rufen Sie den Vererbungskonstruktor auf,Python 2 ist in Ordnung
       super(MySuper, self).__init__()

Es ist eine sehr persönliche Angelegenheit, aber ich programmiere selten mit Vererbung. In Python, Tkinter und wxPython scheint es jedoch ganz normal zu sein, also habe ich es gelernt.

(Referenz: Verwendung der super () - Funktion von Python)

Ordnen Sie die explizite Selbstspezifikation dem Aufruf init der ererbenden Klasse zu

Und die fragliche feste Phrase.

Aufrufe an den Konstruktor `__init __``` der ererbenden Klasse können ohne Verwendung von` super () `erfolgen. Dies kann häufiger als __ init__``` Aufruf an die erbende Klasse sein. `` self``` wird explizit als Argument übergeben und aufgerufen.

class MyInherit(MySuper):
    def __init__(self):
       #Rufen Sie den Vererbungskonstruktor auf
       # Python 2,Möglich in beiden Python 3
       MySuper.__init__(self)
       ...

Aha!

Warum hast du das nicht bemerkt?

~~ Stolz und Glaube ~~ Die Sprache, die ich bisher am häufigsten verwendet habe, war C #, und die Methode zum Aufrufen des Vererbungsquellenkonstruktors war unterschiedlich. Auch wenn es um Klassenmethoden geht, dachte ich, es sei natürlich, <Instanzvariable> aufzurufen. <Methode> (...) `.

Der C # -Vererbungsquellkonstruktor muss aufgerufen werden, wenn der Konstruktor deklariert wird.

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

Ich habe C ++ oder Java nicht berührt, aber es scheint, dass auch ein impliziter Aufruf des Vererbungsquellenkonstruktors erfolgt.

(Referenz: C # -Konstruktor und -Destruktor)

Zusammenfassung

In Python ist ein expliziter Aufruf des Vererbungsklassenkonstruktors `` `init``` ** erforderlich **.
Der feste Ausdruck für die Vererbung besteht darin, das Argument "Selbst" explizit anzugeben.
Sie sind mit den Unterschieden zwischen den Programmiersprachen ein wenig vertraut geworden.

Für mich persönlich möchte ich mich daran erinnern, wie man verwendet und schreibt, und erklären, warum es so einen Unterschied wie ** kulturellen Unterschied ** gibt, und mit dem nächsten Schritt fortfahren.

Ich denke auch, dass `` super () .__ init__ () `in Bezug auf Lesbarkeit und einfache Kommunikation der Bedeutung ausgezeichnet ist, aber wenn es eine Funktion von Python3 ist, wird es von nun an durchdrungen. Es wird eine Geschichte sein. Ich möchte es positiv nutzen.

Bestätigte Umgebung

OS : Windows 10
Python : 3.5.2
Mit Anaconda installiert --Tkinter: Python 3.5.2 enthalten, Version nicht bestätigt
wxPython : wxPython-Phoenix 3.0.3.dev2749

__init__, das von wxPython oder Tkinter aufgerufen wurde, war ein __init__ -Aufruf der geerbten Klasse in Python