Detaillierte Erläuterung der Python-Magie-Methode zur Attributkonvertierung und Klassendarstellung

Typkonvertierungsmagie

Typkonvertierungsmagie ist eigentlich das Ergebnis der Implementierung von Factory-Funktionen wie str und int. Normalerweise verfügen diese Funktionen auch über Typkonvertierungsfunktionen:

•__int__(self)

•In einen Ganzzahltyp konvertieren, entsprechend der int-Funktion.

•__long__(selbst)

•In einen Long-Integer-Typ konvertieren, entsprechend der Long-Funktion.

•__float__(self)

•In einen Gleitkommatyp konvertieren, entsprechend der Float-Funktion.

•__komplex__(selbst)

•Konvertieren Sie in einen komplexen Zahlentyp, der der komplexen Funktion entspricht.

•__oct__(selbst)

•In Oktal konvertieren, entsprechend der Oktalfunktion.

•__hex__(self)

•Umwandeln in Hexadezimalzahl, entsprechend der Hex-Funktion.

•__index__(self)

•Zuerst sollte diese Methode eine Ganzzahl zurückgeben, die int oder long sein kann. Diese Methode ist an zwei Stellen gültig. Erstens ist der von der Indexfunktion im Operatormodul erhaltene Wert der Rückgabewert dieser Methode. Die folgende Codedemonstration wird speziell durchgeführt.

•__trunc__(self)

• Wird aufgerufen, wenn math.trunc(self) verwendet wird. __trunc__ gibt eine Ganzzahlkürzung vom Typ self zurück (normalerweise ein long).

•__zwingen__(sich selbst, andere)

• Diese Methode entspricht dem Ergebnis der integrierten Funktion „coerce“ (diese Funktion wurde seit Python 3.0 entfernt, was bedeutet, dass diese magische Methode bedeutungslos ist. Ob nachfolgende Versionen erneut Unterstützung hinzufügen werden, Es hängt von der offiziellen Website ab.)

•Die Funktion dieser Funktion besteht darin, zwei verschiedene numerische Typen zwangsweise in denselben Typ umzuwandeln, zum Beispiel:

Die Methode

gibt ein Grundelement zurück, das den beiden konvertierten Zahlen entspricht. Seine Priorität ist: komplexe Zahl > Gleitkommazahl > lange Ganzzahl > Ganzzahl. Bei der Konvertierung wird er in den Typ mit der höheren Priorität unter den beiden Parametern konvertiert. Wenn die Konvertierung nicht abgeschlossen werden kann, wird ein TypeError ausgelöst.

Wenn wir diese magische Methode definieren und die Konvertierung nicht abgeschlossen werden kann, sollte None zurückgegeben werden.

Hier gibt es einen wichtigen Mechanismus, z. B. 1 1.0. Es ruft zuerst die Coerce-Funktion auf, um sie in denselben Typ umzuwandeln, und führt sie dann aus. Aus diesem Grund ist 1 1.0 = 2.0 Der tatsächliche Betrieb nach der Konvertierung ist 1.0 1.0. Es ist nicht überraschend, ein solches Ergebnis zu erzielen.

Codebeispiel:

class Foo(object):
  def __init__(self, x):
    self.x = x

  def __int__(self):
    return int(self.x) + 1

  def __long__(self):
    return long(self.x) + 1

a = Foo(123)
print int(a)
print long(a)
print type(int(a))
print type(long(a))

Hier ist zu beachten, dass der Rückgabewert der magischen Methode den Erwartungen entsprechen muss. Beispielsweise sollte __int__ einen Typ

int zurückgeben, wenn wir willkürlich andere Typen zurückgeben, z. B. string (str). , list (list) usw. wird ein Fehler gemeldet.

def __int__(self):
    return str(self.x)

def __int__(self):
    return list(self.x)

Aber int kann long zurückgeben, und long wird automatisch in long verarbeitet, wenn int zurückgegeben wird:

class Foo(object):
  def __init__(self, x):
    self.x = x

  def __int__(self):
    return long(self.x) + 1

  def __long__(self):
    return int(self.x) + 1

a = Foo(123)
print int(a)
print long(a)
print type(int(a))
print type(long(a))

Das oben Gesagte ist bei Python 2.7.11 passiert. Dies ist ein so seltsames Verhalten, dass es meiner Meinung nach ein Fehler sein könnte. Kurz gesagt, wir sollten darauf achten, den entsprechenden Typ zurückzugeben, wenn wir ihn verwenden, um Fehler zu vermeiden.

__index__(self):

Erstens entspricht es Operator.index(), Operator.index(a) entspricht a.__index__():

import operator

class Foo(object):
  def __init__(self, x):
    self.x = x

  def __index__(self):
    return self.x + 1

a = Foo(10)
print operator.index(a)

Noch eine, die erstaunlich ist, wenn sie in einer Sequenz verwendet wird:

class Foo(object):
  def __init__(self, x):
    self.x = x

  def __index__(self):
    return 3

a = Foo('scolia')
b = [1, 2, 3, 4, 5]
print b[a]
print b[3]

kann als Index verwendet und in Scheiben geschnitten werden:

class Foo(object):
  def __init__(self, x):
    self.x = x

  def __index__(self):
    return int(self.x)

a = Foo('1')
b = Foo('3')
c = [1, 2, 3, 4, 5]
print c[a:b]

Tatsächlich kann die im Slice verwendete Funktion Slice diese Funktion kennenlernen:

a = Foo('1')
b = Foo('3')
c = slice(a, b)
print c
d = [1, 2, 3, 4, 5]
print d[c]

__coerce__(selbst, andere):

Codebeispiel:

class Foo(object):
  def __init__(self, x):
    self.x = x

  def __coerce__(self, other):
    return self.x, str(other.x)

class Boo(object):
  def __init__(self, x):
    self.x = x

  def __coerce__(self, other):
    return self.x, int(other.x)

a = Foo('123')
b = Boo(123)
print coerce(a, b)
print coerce(b, a)

Zusammenfassung: Es ist eine magische Methode, die den ersten Parameter aufruft.

Klassenvertretung:

Die Darstellung der Klasse sind tatsächlich die externen Merkmale. Wenn beispielsweise die print-Anweisung verwendet wird, ist das, was gedruckt wird, tatsächlich die Ausgabe der entsprechenden Funktion:

•__str__(self)

• Definieren Sie das Verhalten, das auftreten soll, wenn str() für eine Instanz Ihrer Klasse aufgerufen wird. Weil print standardmäßig die Funktion str() aufruft.

•__repr__(self)

• Definieren Sie das Verhalten, das auftreten soll, wenn repr() für eine Instanz Ihrer Klasse aufgerufen wird. Der Hauptunterschied zwischen str() und repr() ist ihre Zielgruppe. repr() gibt eine maschinenlesbare Ausgabe zurück, während str() eine menschenlesbare Ausgabe zurückgibt. Die Funktion repr() wird standardmäßig im Austauschmodus aufgerufen

•Funktion.

•__unicode__(self)

• Definieren Sie das Verhalten, das auftreten soll, wenn unicode() für eine Instanz Ihrer Klasse aufgerufen wird. unicode() ist str() sehr ähnlich, gibt jedoch einen Unicode-String zurück. Beachten Sie, dass, wenn str() für Ihre Klasse aufgerufen wird, Sie aber nur __unicode__() definieren, dies nicht der Fall ist

•Arbeiten. Sie sollten __str__() definieren, um sicherzustellen, dass beim Aufruf der richtige Wert zurückgegeben wird. Nicht jeder hat Lust, unicode() zu verwenden.

•__format__(self, formatstr)

• Definieren Sie das Verhalten, das auftritt, wenn eine Instanz Ihrer Klasse zum Formatieren mithilfe der neuen Formatzeichenfolgenmethoden verwendet wird. Beispielsweise führt „Hallo, {0:abc}!“.format(a) dazu, dass a.__format__(„abc“) aufgerufen wird. Dies ist nützlich, um Ihre eigenen numerischen oder Zeichenfolgentypen

zu definieren

• ist sehr aussagekräftig, Sie können einige spezielle Formatierungsoptionen angeben.

•__hash__(self)

• Definieren Sie das Verhalten, das auftreten soll, wenn hash() für eine Instanz Ihrer Klasse aufgerufen wird. Für einen schnellen Vergleich in einem Wörterbuch muss es eine Ganzzahl zurückgeben.

•Bitte beachten Sie, dass Sie bei der Implementierung von __hash__ normalerweise auch __eq__ implementieren. Es gibt die folgende Regel: a == b impliziert hash(a) == hash(b) . Mit anderen Worten: Die Rückgabewerte der beiden magischen Methoden sollten konsistent sein.

•Das Konzept des „hashbaren Objekts“ wird hier vorgestellt. Zunächst sollte der Hashwert eines hashbaren Objekts während seines Lebenszyklus unverändert bleiben, und um den Hashwert zu erhalten, muss die Methode __hash__ implementiert werden. Hash-Objekte sind vergleichbar, was bedeutet, dass __eq__ oder

implementiert werden

•Die __cmp__-Methode und wenn die Hash-Objekte gleich sind, müssen ihre Hash-Werte gleich sein. Um diese Funktion zu implementieren, muss der Rückgabewert von __eq__ mit __hash__ identisch sein.

•Hashbare Objekte können als Wörterbuchschlüssel und Sammlungsmitglieder verwendet werden, da diese Datenstrukturen intern Hashwerte verwenden. Alle in Python integrierten unveränderlichen Objekte wie Tupel, Zeichenfolgen, Zahlen usw. können gehasht werden, während veränderliche Objekte wie Listen nicht gehasht werden können

• Wörterbücher und mehr.

• Instanzen benutzerdefinierter Klassen sind standardmäßig hashbar und nicht mit irgendjemandem außer sich selbst gleich, da ihr Hashwert von der ID-Funktion stammt. Dies bedeutet jedoch nicht, dass Hash (a) == id (a) ist. Bitte achten Sie auf diese Funktion.

•__nonzero__(self)

• Definieren Sie das Verhalten, das auftreten soll, wenn bool() für eine Instanz Ihrer Klasse aufgerufen wird. Diese Methode sollte „True“ oder „False“ zurückgeben, je nachdem, welchen Wert sie zurückgeben soll. (In python3.x in __bool__ geändert)

•__dir__(self)

• Definieren Sie das Verhalten, das auftreten soll, wenn dir() für eine Instanz Ihrer Klasse aufgerufen wird. Diese Methode sollte eine Liste von Eigenschaften an den Benutzer zurückgeben.

•__sizeof__(self)

• Definieren Sie das Verhalten, das auftreten soll, wenn sys.getsizeof() für eine Instanz Ihrer Klasse aufgerufen wird. Diese Methode sollte die Größe Ihres Objekts in Bytes zurückgeben. Dies ist normalerweise sinnvoller für Python-Klassen, die als C-Erweiterungen implementiert sind, was zum Verständnis dieser Erweiterungen hilfreich sein kann.

Hier gibt es nichts besonders Schwieriges zu verstehen, daher wird das Codebeispiel weggelassen.

Die obige Python-Zaubermethode – detaillierte Erläuterung der Attributkonvertierung und Klassendarstellung – ist der gesamte vom Herausgeber geteilte Inhalt. Ich hoffe, dass er Ihnen eine Referenz geben kann, und ich hoffe, dass Sie Script Home unterstützen.