Überladungsoperator in Python

1. Überladeoperatoren in Python
2. Überladen Sie den Operator + in Python
3. Überladen Sie den Operator > in Python
4. Überladen Sie den Operator == in Python

Das Überladen von Operatoren bedeutet, das Verhalten von Operatoren in verschiedenen Situationen zu ändern. Es ist eine Art von Polymorphismus.

Durch das Überladen von Operatoren können wir einem Operator zusätzliche Bedeutung oder Funktionalität hinzufügen, um mehr als eine Operation auszuführen.

Beispielsweise führt der Operator + eine Addition mit ganzzahligen Operanden durch. Aber wenn es mit String-Operanden verwendet wird, führt es eine Verkettung durch, weil der +-Operator überladen ist.

Überladeoperatoren in Python

Python bietet eine Möglichkeit, Operatoren mit benutzerdefinierten Datentypen durch die Magic-Methoden zu überladen. Dies sind spezielle Methoden, die automatisch aufgerufen werden, wenn wir den ihnen zugeordneten Operator verwenden.

Sie werden auch als Dunder-Methoden bezeichnet, da sie mit einem doppelten Unterstrich beginnen und enden.

Wenn wir beispielsweise den Operator + schreiben, wird im Backend automatisch die magische Methode __add__() aufgerufen. Wenn wir also eine Operatorüberladung mit bestimmten Operatoren durchführen wollen, müssen wir nur den Code ihrer magischen Methoden ändern.

Überladen Sie den Operator + in Python

Im folgenden Code haben wir eine benutzerdefinierte Klasse, in der wir die magische Methode __add__() implementiert haben, um den +-Operator zu überladen.

Wenn wir int1 + int2 schreiben, wird die magische Methode __add()__ tatsächlich im Backend als int1.__add__(int2) aufgerufen. Die gleiche Arbeitsweise gilt auch für die Saiten.

Wenn wir str1 + str2 schreiben, wird die magische Methode intern als str1.__add__(str2) bezeichnet.

Beispielcode:

# Python 3.x
class MyAddion:
    def __init__(self, a):
        self.a = a

    def __add__(self, b):
        return self.a + b.a


int1 = MyAddion(2)
int2 = MyAddion(2)
str1 = MyAddion("Delft")
str2 = MyAddion("Stack")
print(int1 + int2)
print(str1 + str2)

Ausgang:

#Python 3.x
4
DelftStack

Überladen Sie den Operator > in Python

Hier haben wir den Operator > in der Klasse MyComp überladen. Wenn wir den Operator > schreiben, wird intern die magische Methode __gt__() aufgerufen.

Wenn wir also int1 > int2 schreiben, wird die magische Methode __gt__() als int1.__gt__(int2) aufgerufen. Diese Methode gibt true zurück, wenn die Bedingung wahr ist; andernfalls gibt es false zurück.

Beispielcode:

# Python 3.x
class MyComp:
    def __init__(self, a):
        self.a = a

    def __gt__(self, b):
        if self.a > b.a:
            return True
        else:
            return False


int1 = MyComp(5)
int2 = MyComp(3)
if int1 > int2:
    print(int1.a, "is greater than", int2.a)
else:
    print(int2.a, "is greater than", int1.a)

Ausgang:

#Python 3.x
5 is greater than 3

Überladen Sie den Operator == in Python

Hier haben wir den Gleichheitsoperator == in unserer Klasse MyEquality überladen. Wenn wir int1 == int2 schreiben, wird intern die magische Methode __eq__() als int1.__eq__(int2) aufgerufen.

Wenn beide Operanden gleich sind, wird Equal zurückgegeben; andernfalls wird Ungleich zurückgegeben.

Beispielcode:

# Python 3.x
class MyEquality:
    def __init__(self, a):
        self.a = a

    def __eq__(self, b):
        if self.a == b.a:
            return "Equal"
        else:
            return "Not equal"


int1 = MyEquality(3)
int2 = MyEquality(3)
print(int1 == int2)

Ausgang:

#Python 3.x
Equal

Es ist erwähnenswert, dass wir die Anzahl der Operanden für einen Operator im Falle einer Operatorüberladung nicht ändern können. Wir können einen unären Operator nicht als binären Operator überladen und umgekehrt.

Zum Beispiel können wir den Invert-Operator ~ (einen unären Operator) nicht als binären Operator überladen.