Ausführliche Erläuterung des Code-Sharing-Beispiels zum Überladen von Python-Operatoren

In diesem Artikel werden hauptsächlich relevante Informationen zur detaillierten Erläuterung der Beispielcodefreigabe für Python-Operatoren vorgestellt. Freunde, die sie benötigen, können sich auf

Python-Operatorüberladung

Python beziehen Die Sprache bietet eine Funktion zum Überladen von Operatoren und erhöht die Flexibilität der Sprache. Dies ähnelt C++, unterscheidet sich jedoch etwas davon. Aufgrund seiner besonderen Natur werden wir heute die Überladung von Python-Operatoren besprechen.

Die Python-Sprache selbst bietet viele magische Methoden, und die Überladung ihrer Operatoren wird durch Umschreiben dieser in Python integrierten magischen Methoden erreicht. Diese magischen Methoden beginnen und enden alle mit doppelten Unterstrichen, ähnlich der Form von __X__. Python fängt Operatoren durch diese spezielle Benennungsmethode ab, um eine Überladung zu erreichen. Wenn die integrierten Operationen von Python auf ein Klassenobjekt angewendet werden, sucht Python nach der angegebenen Methode im Objekt und ruft sie auf, um die Operation abzuschließen.

Klassen können integrierte Operationen wie Addition und Subtraktion, Drucken, Funktionsaufrufe, Indizierung usw. überlasten. Durch die Überladung von Operatoren verhalten sich unsere Objekte genauso wie integrierte Objekte. Python ruft eine solche Methode automatisch auf, wenn ein Operator aufgerufen wird. Wenn eine Klasse beispielsweise die Methode __add__ implementiert, wird diese Methode aufgerufen, wenn ein Objekt der Klasse im Operator + erscheint.

Gemeinsame Methoden zum Überladen von Operatoren

Das Folgende ist eine Einführung in die Verwendung häufig verwendeter Operatormethoden.

Konstruktor und Destruktor: __init__ und __del__

Ihre Hauptfunktion besteht darin, Objekte zu erstellen und zu recyceln, wenn Instanzen erstellt werden angerufen. Wenn das Instanzobjekt zurückgefordert wird, wird der Destruktor __del__ automatisch ausgeführt.

>>> class Human(): 
...   def __init__(self, n): 
...     self.name = n 
...       print("__init__ ",self.name) 
...   def __del__(self): 
...     print("__del__") 
...  
>>> h = Human('Tim') 
__init__ Tim 
>>> h = 'a' 
__del__

Additions- und Subtraktionsoperationen: __add__ und __sub__

Überladung dieser beiden Methoden können +-Operator-Operationen zu gewöhnlichen Objekten hinzufügen. Der folgende Code zeigt, wie der +-Operator verwendet wird. Wenn die __sub__-Methode aus dem Code entfernt wird und dann der Minus-Operator aufgerufen wird, tritt ein Fehler auf.

>>> class Computation(): 
...   def __init__(self,value): 
...     self.value = value 
...   def __add__(self,other): 
...     return self.value + other 
...   def __sub__(self,other): 
...     return self.value - other 
...  
>>> c = Computation(5) 
>>> c + 5 
10 
>>> c - 3 
2

String-Darstellung des Objekts: __repr__ und __str__

Diese beiden Methoden werden verwendet, um den Zeichenfolgenausdruck des Objekts darzustellen: Die Methoden print() und str() rufen die Methode __str__ auf, und die Methoden print(), str() und repr() rufen die Methode __repr__ auf. Wie aus dem folgenden Beispiel ersichtlich ist, sucht Python bei der gleichzeitigen Definition zweier Methoden zunächst nach der Methode __str__ und ruft sie auf.

>>> class Str(object): 
...   def __str__(self): 
...     return "__str__ called"   
...   def __repr__(self): 
...     return "__repr__ called" 
...  
>>> s = Str() 
>>> print(s) 
__str__ called 
>>> repr(s) 
'__repr__ called' 
>>> str(s) 
'__str__ called'

Indexwerterfassung und -zuweisung: __getitem__, __setitem__

Durch Implementierung dieser beiden Methoden Sie können Objekte in der Form X[i] abrufen und ihnen Werte zuweisen, und Sie können auch Slicing-Operationen für Objekte verwenden.

>>> class Indexer: 
  data = [1,2,3,4,5,6] 
  def __getitem__(self,index): 
    return self.data[index] 
  def __setitem__(self,k,v): 
    self.data[k] = v 
    print(self.data) 
>>> i = Indexer() 
>>> i[0] 
1 
>>> i[1:4] 
[2, 3, 4] 
>>> i[0]=10 
[10, 2, 3, 4, 5, 6]

Attribute festlegen und darauf zugreifen: __getattr__, __setattr__

Wir können __getattr__ und __setattr__ überladen, um den Zugriff abzufangen Mitglieder zu beanstanden. __getattr__ wird automatisch aufgerufen, wenn auf ein Mitglied zugegriffen wird, das im Objekt nicht vorhanden ist. Die Methode __setattr__ wird zum Aufrufen beim Initialisieren von Objektmitgliedern verwendet, dh die Methode __setattr__ wird aufgerufen, wenn das Element von __dict__ festgelegt wird. Das konkrete Beispiel lautet wie folgt:

class A(): 
  def __init__(self,ax,bx): 
    self.a = ax 
    self.b = bx 
  def f(self): 
    print (self.__dict__) 
  def __getattr__(self,name): 
    print ("__getattr__") 
  def __setattr__(self,name,value): 
    print ("__setattr__") 
    self.__dict__[name] = value 
 
a = A(1,2) 
a.f() 
a.x 
a.x = 3 
a.f()

Das laufende Ergebnis des obigen Codes ist wie folgt Wenn auf die nicht vorhandene Variable x zugegriffen wird, wird die Methode __getattr__ aufgerufen. Wenn __init__ aufgerufen wird, ruft die Zuweisungsoperation auch die Methode __setattr__ auf.

__setattr__ 
__setattr__ 
{'a': 1, 'b': 2} 
__getattr__ 
__setattr__ 
{'a': 1, 'x': 3, 'b': 2}

Iteratorobjekt: __iter__, __next__

Die Iteration in Python kann direkt erfolgen Dies wird durch Überladen der Methode __getitem__ erreicht, siehe Beispiel unten.

>>> class Indexer: 
...   data = [1,2,3,4,5,6] 
...   def __getitem__(self,index): 
...       return self.data[index] 
...  
>>> x = Indexer() 
>>> for item in x: 
...   print(item) 
...  
1 
2 
3 
4 
5 
6

Eine Iteration kann mit der oben genannten Methode erreicht werden, ist jedoch nicht die beste Methode. Die Iterationsoperation von Python versucht zunächst, die Methode __iter__ aufzurufen, und versucht dann, __getitem__ aufzurufen. Die iterative Umgebung wird implementiert, indem mit iter versucht wird, die Methode __iter__ zu finden, die ein Iteratorobjekt zurückgibt. Wenn diese Methode bereitgestellt wird, ruft Python wiederholt die next()-Methode des Iteratorobjekts auf, bis eine StopIteration-Ausnahme auftritt. Wenn __iter__ nicht gefunden wird, versucht Python, den __getitem__-Mechanismus zu verwenden. Schauen wir uns ein Beispiel eines Iterators an.

class Next(object): 
  def __init__(self, data=1): 
    self.data = data 
  def __iter__(self): 
    return self 
  def __next__(self): 
    print("__next__ called") 
    if self.data > 5: 
      raise StopIteration 
    else: 
      self.data += 1 
      return self.data 
for i in Next(3): 
  print(i) 
print("-----------") 
n = Next(3) 
i = iter(n) 
while True: 
  try: 
    print(next(i)) 
  except Exception as e: 
    break

Die laufenden Ergebnisse des Programms sind wie folgt:

__next__ called 
4 
__next__ called 
5 
__next__ called 
6 
__next__ called 
----------- 
__next__ called 
4 
__next__ called 
5 
__next__ called 
6 
__next__ called

Es ist ersichtlich, dass das Objekt nach der Implementierung der Methoden __iter__ und __next__ über die Methode for in oder über die Methoden iter() und next() iteriert werden kann.

Vielen Dank fürs Lesen, ich hoffe, es kann Ihnen helfen, vielen Dank für Ihre Unterstützung dieser Website!

Das obige ist der detaillierte Inhalt vonAusführliche Erläuterung des Code-Sharing-Beispiels zum Überladen von Python-Operatoren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!