Superargumente in Python

1. Superargumente in Python
2. Super verwendet Vererbungskonzept
3. Genaue Verwendung von Superargumenten in Python
4. Verwenden Sie Super, um Argumente an Konstruktoren in der Python-Mehrfachvererbung zu übergeben

Das Thema dieses Artikels verwendet die Python-Argumente super korrekt. Wir werden auch etwas über das Konzept von super und Vererbung, geeignete Codebeispiele mit super-Argumenten und das Konzept von Basisklassen lernen.

Superargumente in Python

In Python ruft super eine Methode einer anderen Klasse auf. Sie wird Elternklasse, Basisklasse oder Oberklasse genannt, wenn eine Klasse von einer anderen Klasse erbt.

Es ist ziemlich einfach, super zu verwenden, da es direkt zur übergeordneten Klasse geht und ihre Methoden aufruft.

An super können Argumente übergeben werden. Es braucht zwei Argumente, eine Klasse und eine Klasseninstanz.

Beispielcode:

class A:
    def roo(self):
        return "roo() from A"


class B(A):
    def roo(self):
        print("roo() from B")
        return super().roo()


class C(A):
    def roo(self):
        print("roo() from C")
        return super().roo()


class D(B, C):
    def roo(self):
        print("roo() from D")
        return super(C, self).roo()


a = A()
b = B()
c = C()
d = D()
print(a.roo())
print(b.roo())
print(c.roo())
print(d.roo())

Ausgang:

roo() from A
roo() from B
roo() from A
roo() from C
roo() from A
roo() from D
roo() from A

Super verwendet Vererbungskonzept

Vererbung mag Ihnen ungewohnt erscheinen, wenn Sie mit objektorientierten Programmierkonzepten nicht vertraut sind. In der objektorientierten Programmierung bezieht sich Vererbung auf die Fähigkeit einer Klasse, Attribute und Verhaltensweisen von einer anderen Klasse abzuleiten (oder zu erben), ohne sie erneut zu implementieren.

Der bequeme Weg, diese Konzepte zu verstehen, besteht darin, sich einen Code anzusehen. Lassen Sie uns also einige Klassen erstellen, um einige Formen zu beschreiben.

Beispielcode:

class Rectangle_Shape:
    def __init__(self, len, wid):
        self.length = len
        self.width = wid

    def area(self):
        return self.length * self.width

    def perimeters(self):
        return 2 * self.length + 2 * self.width


class Square_Shape:
    def __init__(self, len):
        self.length = len

    def area(self):
        return self.length * self.length

    def perimeters(self):
        return 4 * self.length


s = Square_Shape(4)
print(s.area())
r = Rectangle_Shape(3, 5)
print(r.area())

Diese Klasse hat zwei entsprechende Klassen: Rectangle_Shape und Square_Shape.

Ausgang:

16
15

Das Beispiel zeigt zwei Formen, die miteinander verwandt sind: Ein Quadrat ist eine Art Rechteck. Der Code spiegelt diese Beziehung nicht wider, was zu einem im Wesentlichen wiederholten Code führt.

Durch die Verwendung von Vererbung können Sie die Menge des von Ihnen geschriebenen Codes reduzieren und gleichzeitig die reale Beziehung zwischen Rechtecken und Quadraten widerspiegeln.

Beispielcode:

class Rectangle_Shape:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

    def perimeters(self):
        return 2 * self.length + 2 * self.width


# Making the Square_Shape class that initiates the Rectangle_Shape class
class Square_Shape(Rectangle_Shape):
    def __init__(self, len):
        super().__init__(len, len)


s = Square_Shape(4)
print(s.area())

In diesem Fall ruft super() init() der Klasse Rectangle_Shape auf, die dann in der Klasse Square_Shape verwendet wird, ohne dass der Code neu geschrieben werden muss.

Ausgang:

16

Wie im Beispiel gezeigt, ist Rectangle_Shape die übergeordnete Klasse und Square_Shape die untergeordnete Klasse.

Genaue Verwendung von Superargumenten in Python

Der Code für die Klassen M, N und O ist unten.

class M:
    def __init__(self):
        print("M initiated successfully")


class N(M):
    def __init__(self):
        super().__init__()
        print("N initiated successfully")


class O(N):
    def __init__(self):
        super(O, self).__init__()
        print("O initiated successfully")


o = O()

Wie der obige Code annimmt, überladen alle Klassen ihre direkte Elternmethode init(). super() benötigt keine Attribute, daher reicht es aus, es ohne Argumente zu verwenden.

Ausgang:

M initiated successfully
N initiated successfully
O initiated successfully

Angenommen, wir möchten, dass die Klasse M2 die init()-Methode von N überspringt, aber stattdessen die init()-Methode von M ausführt. Die Methode init() sollte von M geerbt werden, nicht von N, obwohl der direkte Elternteil unserer Klasse N ist.

Hier kommt die Klasse M2. Werfen wir einen Blick auf seine Ausführung.

class M:
    def __init__(self):
        print("M initiated successfully")


class N(M):
    def __init__(self):
        super().__init__()
        print("N initiated successfully")


class O(N):
    def __init__(self):
        super(O, self).__init__()
        print("O initiated successfully")


class M2(N):
    def __init__(self):
        super(N, self).__init__()
        print("other O initiated successfully")


m2 = M2()

Aus dem obigen Code kann man annehmen, dass wir Attribute an die Methode super() übergeben, um diesmal die richtige Oberklasse auszuwählen. Als Ergebnis der Ausführung von m2 = M2() erhalten wir die folgende Ausgabe.

M initiated successfully
other O initiated successfully

Anstatt die direkt übergeordnete Methode __init__() aufzurufen, haben wir stattdessen die Python-Methode init() von M aufgerufen.

Für implizite Suchen mit diesen Anweisungen oder Operatoren wie super()[name] ist super() nicht definiert.

Darüber hinaus ist super() nicht auf die Verwendung von Insider-Methoden abgesehen von der Null-Argument-Form beschränkt. Die Verwendung der Form mit zwei Argumenten identifiziert die Argumente genau und stellt die entsprechenden Referenzen her.

In einer Klassendefinition funktionieren Nullargumente nur, weil der Compiler die erforderlichen Details zum Abrufen der Klasse und der Instanz ausfüllt.

Verwenden Sie Super, um Argumente an Konstruktoren in der Python-Mehrfachvererbung zu übergeben

Eine Basisklasse sollte auf Mehrfachvererbung ausgelegt sein, wenn es generell um verschiedene Vererbungen geht.

Es gibt Zeiten, in denen zwei Klassen ähnliche Parameternamen haben. In diesem Fall können Sie Schlüssel-Wert-Paare nicht aus **kwargs oder aus *args entfernen.

Es ist möglich, eine Base-Klasse zu definieren, die im Gegensatz zu einem Objekt Argumente aufnimmt/ignoriert.

Beispielcode:

class Base(object):
    def __init__(self, *args, **kwargs):
        pass


class P(Base):
    def __init__(self, *args, **kwargs):
        print("P")
        super(P, self).__init__(*args, **kwargs)


class Q(Base):
    def __init__(self, *args, **kwargs):
        print("Q")
        super(Q, self).__init__(*args, **kwargs)


class R(P):
    def __init__(self, arg, *args, **kwargs):
        print("R", "arguments=", arg)
        super(R, self).__init__(arg, *args, **kwargs)


class S(Q):
    def __init__(self, arg, *args, **kwargs):
        print("S", "arguments=", arg)
        super(S, self).__init__(arg, *args, **kwargs)


class T(R, S):
    def __init__(self, arg, *args, **kwargs):
        print("T", "arguments=", arg)
        super(T, self).__init__(arg, *args, **kwargs)
        print("MRO---", [x.__name__ for x in T.__mro__])


t = T(10)

Ausgang:

T arguments= 10
R arguments= 10
P
S arguments= 10
Q
MRO--- ['T', 'R', 'P', 'S', 'Q', 'Base', 'object']

Es ist wichtig zu beachten, dass Base die vorletzte Klasse in der MRO sein muss, damit dies funktioniert.

Die Programmiersprache Python bietet eine Vielzahl von Funktionen für die objektorientierte Programmierung. In diesem Satz spielen die Argumente der super-Funktion eine wichtige Rolle, insbesondere wenn sie richtig verwendet werden.

Hoffentlich hat Ihnen dieser Artikel geholfen, besser zu verstehen, wie Sie die Argumente der super-Funktion in Python verwenden.