[Python] So erzwingen Sie, dass eine Methode einer Unterklasse einen bestimmten Prozess ausführt

Ich möchte einer Unterklasse einen bestimmten Prozess aufzwingen

Wenn Sie eine Unterklasse entwerfen, die eine bestimmte Klasse in Python erbt, kann es vorkommen, dass das geerbte Ziel diese Art der Verarbeitung ausführt.

Zum Beispiel möchte ich, dass Sie super () .__ init __ () aufrufen, wenn __init __ aufgerufen wird ...

Nicht beschränkt auf "init", der Prozess "Ich möchte die Methode der übergeordneten Klasse überschreiben, aber ich möchte die Methode der übergeordneten Klasse so aufrufen, wie sie ist!" Wird häufig angezeigt, aber ich habe vergessen, den Prozess des Aufrufs der Methode der übergeordneten Klasse zu schreiben. Ich möchte keinen Fehler machen, und die Spezifikation selbst, die die Methode der übergeordneten Klasse aufruft, ist in erster Linie problematisch.

Dieses Mal, wenn die Methode f der untergeordneten Klasse aufgerufen wird, werden wir versuchen, eine Implementierung zu implementieren, bei der die Methode f der übergeordneten Klasse nach der Verarbeitung immer aufgerufen wird.

Weise

** Schreiben Sie "untergeordnete Klassenfunktion f" in "Funktion new_f, die die untergeordnete Klassenfunktion f und die übergeordnete Klassenfunktion f ausführt" um ** Schreiben Sie eine Metaklasse, die das tut

Was ist eine Metaklasse? Die Geschichte wird diesmal anders sein. Stellen Sie sich dies vorerst als eine Klasse vor, die die Art und Weise ändert, wie Klassen definiert werden.

Ich glaube, dass selbst Leute, die nicht damit vertraut sind, alles tun können, indem sie den folgenden Code kopieren und einfügen und die "Dekorations" -Methode neu schreiben.

Annahme

Python: 3.7.2 (Möglicherweise OK für Python3, nur die Metaklassenspezifikationsmethode unterscheidet sich für Python2)

Code

class ParentCaller(type):
    def __new__(cls, name, base, attr):
        #Verhindern Sie, dass f in der übergeordneten Klasse f in der übergeordneten Klasse aufruft
        if name != "Parent":
            #Machen Sie die Funktion f automatisch dekoriert, wenn die Klasse erstellt wird
            attr["f"] = cls.decorate(attr["f"])
        return super().__new__(cls, name, base, attr)

    @classmethod
    def decorate(cls, f):
        #Wenn die Funktion f empfangen wird, f und Parent.Führen Sie f als neuen Satz aus_Rückgabe f
        def new_f(self, x):
            f(self, x)
            Parent.f(self, x)
        return new_f


class Parent(metaclass=ParentCaller):
    def f(self, x):
        print(f"parent's f says: {x}")


class Child(Parent):
    def f(self, x):
        print(f"child's f says: {x}")


child = Child()
child.f("Hello World!")

#  child's f says: Hello World!
#  parent's f says: Hello World!

Zusammenfassung

Wenn ich eine Bibliothek wie Tensorflow schreibe, die von Menschen geerbt und verwendet wird, möchte ich das Versprechen "Run hogehoge here!" So weit wie möglich vermeiden. Schreiben Sie in einem solchen Fall eine Metaklasse und rufen Sie ohne Ihr Wissen hogehoge an.

Es scheint, dass Meta-Programmierung in der Gruppenentwicklung schwer zu lesen und zu hassen ist. Ich denke, dass es eine Essenz ist, die die Anzahl der Schritte für die persönliche Entwicklung minimiert.