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

tr> del td>X[key], Indexzuweisung__contains__

方法名	重载说明	运算符调用方式
__init__	构造函数	对象创建: X = Class(args)
__del__	析构函数	X对象收回
__add__/__sub__	加减运算	X+Y， X+=Y/X-Y， X-=Y
__or__	运算符|	X|Y, X|=Y
_repr__／__str__	打印／转换	print(X)、repr(X)／str(X)
__call__	函数调用	X(*args, **kwargs)
__getattr__	属性引用	X.undefined
__setattr__	属性赋值	X.any=value
__delattr__	属性删除	del X.any
__getattribute__	属性获取	X.any
__getitem__	索引运算	X[key]，X[i:j]
__setitem__	索引赋值	X[key]，X[i:j]=sequence
__delitem__	索引和分片删除	del X[key]，del X[i:j]
__len__	长度	len(X)
__bool__	布尔测试	bool(X)
__lt__, __gt__,  __le__, __ge__,  __eq__, __ne__	特定的比较	依次为Xee3d56296b359dd6e2fa348252a69563Y，X0c053491a77177952c95ffb33c7e0a8b=Y，  X==Y，X!=Y  注释：（lt: less than, gt: greater than,    le: less equal, ge: greater equal,    eq: equal, ne: not equal  ）
__radd__	右侧加法	other+X
__iadd__	实地（增强的）加法	X+=Y(or else __add__)
__iter__, __next__	迭代	I=iter(X), next()
__contains__	成员关系测试	item in X(X为任何可迭代对象)
__index__	整数值	hex(X), bin(X),  oct(X)
__enter__, __exit__	环境管理器	with obj as var:
__get__, __set__,  __delete__	描述符属性	X.attr, X.attr=value, del X.attr
__new__	创建	在__init__之前创建对象

Methodenname

Überladungsbeschreibung

Operator-Aufrufmethode

__init__

Konstruktor

Objekterstellung: X = Class(args)

__del__

Destruktor

X-Objekt zurückgefordert

__add__/__sub__

Additions- und Subtraktionsoperationen

X +Y, X+ =Y/X-Y,

X|Y, X|=Y

_repr__／__str__

Drucken/Konvertieren

print(X), repr(X)／str(X)

__call__

Funktionsaufruf

X(*args, **kwargs) td>

__getattr__

Attributreferenz

X .undefiniert

__setattr__

Attributzuweisung

X.any= Wert

__delattr__

Attributlöschung

X[key], X[i:j]=sequence

__delitem__

Index- und Shard-Löschung

del X [key], del X[i:j]

__len__

Länge /td>

len(X) td>

__bool__

Boolescher Test

bool(X)

__lt__, __gt__, __le__, __ge__, __eq__, __ne__

Spezifische Vergleiche

Die Reihenfolge ist X632bf1420c84fd56a79a6bad534b1b35Y, X< =Y, __radd__

Rechte Addition

andere+X

__iadd__

Feldergänzung (erweitert)

X+=Y(oder sonst __add__)

__iter__, __next__

Iteration

I=iter(X) , next()

Mitgliedschaftstest

Element in 🎜>

hex(X), bin(X), oct(X)

__enter__, __exit__

Environment Manager

mit obj als var:

__get__, __set__, __delete__

Deskriptorattribut

X.attr, X.attr=value , del X.attr

__new__

Erstellen

Erstellen Sie das Objekt vor __init__ td>

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!