Python Operatorüberladung

Sie können die Bedeutung von Operatoren in Python ändern, basierend auf den Operanden, die Sie verwenden. Dies wird als Operator-Überladung bezeichnet.

Was ist das Operator-Überladen in Python?

Python-OperatorFür eingebettete Klassen. Aber derselbe Operator verhält sich unterschiedlich für verschiedene Typen. Zum Beispiel,+Der Operator führt Arithmetische Addition auf zwei Zahlen aus, kombiniert zwei Listen und verbindet zwei Zeichenfolgen.

Diese Funktion in Python ermöglicht es, dass derselbe Operator je nach Kontext unterschiedliche Bedeutungen hat, was als Operator-Überladung bezeichnet wird.

Was passiert, wenn wir sie mit Objekten von benutzerdefinierten Klassen verwenden? Sehen wir uns die folgende Klasse an, die versucht, einen Punkt in einem zweidimensionalen Koordinatensystem zu modellieren.

class Point:
　　　　def __init__(self, x = 0, y = 0):
　　　　　　　　self.x = x
　　　　　　　　self.y = y

Führen Sie nun den Code aus und versuchen Sie, zwei Punkte im Python-Shell hinzuzufügen.

>>> p1　= Point(2,3)
>>> p2　= Point(-1,2)
>>> p1　+　p2
Traceback (most recent call last):
...
TypeError: Unsupported operand types for　+: 'Point' und 'Point'

Wow! Das sind viele Fehler. Ein TypeError wird ausgelöst, da Python nicht weiß, wie man zwei Point-Objekte zusammen addiert.

Die gute Nachricht ist, dass wir Python dies durch Operator-Überladung beibringen können. Aber zunächst sollten wir uns mit den speziellen Funktionen vertraut machen.

Spezielle Funktionen in Python

Klassenfunktionen, die mit einem doppelten Unterstrich __ beginnen, werden in Python als spezielle Funktionen bezeichnet. Dies liegt daran, dass sie keine gewöhnlichen Funktionen sind. Der von uns oben definierte __init__() -Funktion ist eine davon. Er wird jedes Mal aufgerufen, wenn wir ein neues Objekt dieser Klasse erstellen. In Python gibt es viele spezielle Funktionen.

Using special functions, we can make our class compatible with built-in functions.

>>> p1　= Point(2,3)
>>> print(p1)
<__main__.Point object at 0x00000000031F8CC0>

The print output did not achieve the expected effect. However, if we define the __str__() method in the class, we can control its print output. We add this to our class.

class Point:
　　　　def __init__(self, x = 0, y = 0):
　　　　　　　　self.x = x
　　　　　　　　self.y = y
　　　　
　　　　def __str__(self):
　　　　　　　　return "({0},{1})".format(self.x, self.y)

Now, let's try the function again with print().

>>> p1　= Point(2,3)
>>> print(p1)
(2,3)

　It turns out that it is better when we use the built-in functions str() or format(), as they call the same method format().

>>> str(p1)
'('2,3)'
>>> format(p1)
'('2,3)'

Therefore, when you execute str(p1) or format(p1) Python internally executes p1__str__() are called special functions. Let's continue with operator overloading.

in Python+operators

to overload+symbol, we will need to implement the __add__() function in the class. With rights come great responsibilities. We can do anything we like within this function. However, it is wise to return a Point object that is the sum of the coordinates.

class Point:
　　　　def __init__(self, x = 0, y = 0):
　　　　　　　　self.x = x
　　　　　　　　self.y = y
　　　　
　　　　def __str__(self):
　　　　　　　　return "({0},{1})".format(self.x, self.y)
　　　　
　　　　def __add__(self, other):
　　　　　　　　x = self.x　+　other.x
　　　　　　　　y = self.y　+　other.y
　　　　　　　　return Point(x, y)

Now, let's try again.

>>> p1　= Point(2,3)
>>> p2　= Point(-1,2)
>>> print(p1　+　p2)
(1,5)

What actually happens is, when you execute p1 + p2when Python will call p1 __add__(p2), which is Point.__add__(p1, p2). Similarly, we can also overload other operators. The list of special functions that we need to implement is as follows.

Überladung von Vergleichsoperatoren in Python

Python beschränkt die Überladung von Operatoren nicht auf arithmetische Operatoren. Wir können auch Vergleichsoperatoren überladen.

Angenommen, wir möchten den Vergleichsoperator (<) in der Point-Klasse implementieren. Lassen Sie uns die Punkte von Nullpunkt aus vergleichen und das Ergebnis zu diesem Zweck zurückgeben. Dies kann wie folgt implementiert werden.

class Point:
　　　　def __init__(self, x = 0, y = 0):
　　　　　　　　self.x = x
　　　　　　　　self.y = y
　　　　
　　　　def __str__(self):
　　　　　　　　return "({0},{1})".format(self.x, self.y)
　　　　
　　　　def __lt__(self, other):
　　　　　　　　self_mag = (self.x　**　2)　+　(self.y　**　2)
　　　　　　　　other_mag = (other.x　**　2)　+　(other.y　**　2)
　　　　　　　　return self_mag < other_mag

Versuchen Sie, diese Beispiele im Python-Shell auszuführen.

>>> Point(1,1) < Point(-2,-3)
True
>>> Point(1,1) < Point(0.5,-0.2)
False
>>> Point(1,1) < Point(1,1)
False

Ähnlich wie, unten sind die speziellen Funktionen aufgeführt, die wir implementieren müssen, um andere Vergleichsoperatoren zu überladen.