Python "Magic Methods" (C) 2018-2025 T.Birnthaler OSTC GmbH ====================== Python kennt 95 spezielle Methoden ("Dunder" Methods = "Double Underscore" = "Special Methods" = "Magic Methods"), die Python AUTOMATISCH aufruft, falls die entsprechende Operation mit einem Objekt (oder einer Klasse) durchgeführt wird (PY2/PY3 = gibt es nur in Python 2/3, 3.x = gibt es seit Python 3.x). Doku --> http://docs.python.org/3/reference/datamodel.html#specialnames +-------------------+-----------------------------+--------------------------+ | Magische Methode | Aufruf durch ... | Bedeutung | +-------------------+-----------------------------+--------------------------+ | __new__ | CLS() | Subclass im-mutable type | | __init__ | CLS() | Konstruktor | | __del__ | del OBJ garbage collector | Destruktor | | __slots__ | CLS attributes | Attribute | +-------------------+-----------------------------+--------------------------+ | __enter__ | with ... as ... | Kontext-Manager | | __exit__ | with ... as ... | " | +-------------------+-----------------------------+--------------------------+ | __iter__ | for ... in ..., enumerate() | Iterator-Protokoll | | __next__ | for ... in ..., enumerate() | " | +-------------------+-----------------------------+--------------------------+ | __getinitargs__ | pickle.dump()/.restore() | Pickling-Protokoll | | __getnewargs__ | pickle.dump()/.restore() | " | | __getstate__ | pickle.dump()/.restore() | " | | __setstate__ | pickle.dump()/.restore() | " | | __reduce__ | pickle.dump()/.restore() | " | | __reduce_ex__ | pickle.dump()/.restore() | " | +-------------------+-----------------------------+--------------------------+ | __copy__ | copy.copy() | Flache Kopie (shallow) | | __deepcopy__ | copy.deepcopy() | Tiefe Kopie (deep) | | __replace__ | copy.replace() | Kopie mit Ersetzung | 3.13 +-------------------+-----------------------------+--------------------------+ | __repr__ | repr() print() | Maschinen-Repräsentation | | __str__ | str() print() | Menschliche Darstellung | | __format__ | F"..." "...".format() | Formatierung | | __unicode__ | unicode() | __str__ + __byte__ in PY3| PY2 | __hash__ | hash() | Fingerprint, Kondensat | | __nonzero__ | bool() | __bool__ in PY3 | PY2 +-------------------+-----------------------------+--------------------------+ | __bool__ | bool() | Datentyp-Konvertierung | | __bytes__ | bytes() | " | | __complex__ | complex() | " | | __int__ | int() | " | | __long__ | long() | " | PY2 | __float__ | float() | " | +-------------------+-----------------------------+--------------------------+ | __oct__ | oct() | Zahlen-Konvertierung | | __hex__ | hex() | " | | __bin__ | bin() | " | +-------------------+-----------------------------+--------------------------+ | __index__ | OBJ[N:M:S] | Slice-Operator | | __dir__ | dir() | Objekt-Attributliste | 3.7 | __call__ | OBJ() called as function | x() --> x.__call__() | | __coerce__ | | Mixed mode arithmetic | PY2 +-------------------+-----------------------------+--------------------------+ | __getattr__ | OBJ.ATTR getattr() | Objekt-Attribute | 3.7 | __getattribute__ | OBJ.ATTR getattr() | " | | __setattr__ | OBJ.ATTR = VAL setattr() | " | | __delattr__ | del OBJ.ATTR delattr() | " | +-------------------+-----------------------------+--------------------------+ | __get__ | | Deskriptor-Klasse TODO | | __set__ | | " TODO | | __delete__ | | " TODO | | __set_name__ | | " TODO | +-------------------+-----------------------------+--------------------------+ | __init_subclass__ | | TODO | | __instancecheck__ | isinstance() | TODO | | __subclasscheck__ | issubclass() | TODO | | __class_getitem__ | | TODO | +-------------------+-----------------------------+--------------------------+ | __len__ | len() | Element-Anz. (Container) | | __length_hint__ | | TODO | | __reversed__ | reversed() | Reihenfolge umdrehen | | __contains__ | in not in | Enthält-Operator (nicht) | +-------------------+-----------------------------+--------------------------+ | __getitem__ | OBJ[KEY] | Indexzugriff auf Element | | __missing__ | OBJ[KEY] | dict-Subklasse | | __setitem__ | OBJ[KEY] = VALUE | " | | __delitem__ | del OBJ[KEY] | " | +-------------------+-----------------------------+--------------------------+ | __eq__ | x == y | Wert-Vergleich "equal" | | __ne__ | x != y | " "not equal" | | __lt__ | x < y | " "less than" | | __le__ | x <= y | " "less equal" | | __gt__ | x > y | " "greater than" | | __ge__ | x >= y | " "greater equal" | | __cmp__ | x y --> -1/0/1 | " "compare" | PY2 +-------------------+-----------------------------+--------------------------+ | __add__ | + | Arithmetische Operatoren | | __sub__ | - | " | | __mul__ | * | " | | __matmul__ | @ | " | | __div__ | / | " | PY2 | __truediv__ | / | " | PY3 | __floordiv__ | // | " | PY3 | __mod__ | % | " | | __divmod__ | divmod() | " | | __pow__ | ** pow() | " | | __lshift__ | << | " | | __rshift__ | >> | " | | __and__ | & | " | | __or__ | | | " | | __xor__ | ^ | " | +-------------------+-----------------------------+--------------------------+ | __iadd__ | += | "Inplace" arith. Op. | | __isub__ | -= | " | | __imul__ | *= | " | | __imatmul__ | @= | " | | __idiv__ | /= | " | | __itruediv__ | /= | " | PY2 | __ifloordiv__ | //= | " | PY3 | __imod__ | %= | " | PY3 | __ipow__ | **= | " | | __ilshift__ | <<= | " | | __irshift__ | >>= | " | | __iand__ | &= | " | | __ior__ | |= | " | | __ixor__ | ^= | " | +-------------------+-----------------------------+--------------------------+ | __radd__ | + | "Reflected" arith. Op. | | __rsub__ | - | " | | __rmul__ | * | " | | __rmatmul__ | @ | " | | __rdiv__ | / | " | PY2 | __rtruediv__ | / | " | PY3 | __rfloordiv__ | // | " | PY3 | __rmod__ | % | " | | __rdivmod__ | divmod() | " | | __rpow__ | ** | " | | __rlshift__ | << | " | | __rrshift__ | >> | " | | __rand__ | & | " | | __ror__ | | | " | | __rxor__ | ^ | " | +-------------------+-----------------------------+--------------------------+ | __neg__ | - (Vorzeichen) | Unäre arithmetische Op. | | __pos__ | + (Vorzeichen) | " | | __abs__ | abs() | " | | __invert__ | ~ | " | +-------------------+-----------------------------+--------------------------+ | __round__ | round() | Fließkomma-Konvertierung | | __floor__ | floor() | " | | __ceil__ | ceil() | " | | __trunc__ | trunc() | " | +-------------------+-----------------------------+--------------------------+ | __aenter_ | async with ... | Asynchroner Kontex-Manag.| TODO | __aexit__ | async with ... | " | TODO +-------------------+-----------------------------+--------------------------+ | __aiter__ | async for ... | Asynchrones Iterator-P. | TODO | __anext__ | async for ... | " | TODO | __await__ | await FUNK() | " | TODO +-------------------+-----------------------------+--------------------------+ | __class__ | | Klasse des Objekts | TODO | __metaclass__ | | TODO | TODO | __subclasses__ | | TODO | TODO | __mro__ | | Method Resolution Order | TODO | __mro_entries__ | | Method Resolution Order | TODO +-------------------+-----------------------------+--------------------------+ | __closure__ | | TODO | TODO | __code__ | | Code-Objekt (Fkt, Klasse)| TODO | __defaults__ | | Defaultwerte von Fkt. | TODO | __kwdefaults__ | | Defaultwerte von Fkt. | TODO +-------------------+-----------------------------+--------------------------+ | __fspath__ | | TODO | TODO | __import__ | | TODO | TODO | __prepare__ | | TODO | TODO | __weakref__ | | TODO | TODO +-------------------+-----------------------------+--------------------------+ TODO | __getslice__ | | Deprecated | TODO | __delslice__ | | Deprecated | TODO | __setslice__ | | Deprecated | TODO +-------------------+-----------------------------+--------------------------+ HINWEISE: * Die ZUWEISUNG "=" ist KEIN Operator und kann daher nicht überladen werden (weist der linken Seite immer die ID des Objekts auf der rechten Seite zu). var = ... * Der WALRUS OPERATOR ":=" ist eine ZUWEISUNG im Rahmen eines Rechenausdrucks und kann daher nicht überladen werden (weist der linken Seite immer die ID des Objekts auf der rechten Seite zu). if erg := (2 + 3) * 4: ... * "is" und "is not" vergleichen die IDENTITÄT zweier OBJEKTE anhand ihrer beiden IDs und können nicht überladen werden. Sind eine Abkürzung für: a is b # --> id(a) == id(b) a is not b # --> id(a) != id(b) * __iOP__ ("Inplace") wird aufgerufen bei der abgekürzten Zuweisung a OP= b (entspricht a = a OP b) a += b # --> type(a).__iadd__(a, b) aufgerufen * __rOP__ ("Reflected") wird aufgerufen, falls die von a OP b aufgerufene Funktion type(a).__OP__(a, b) den Wert "NotImplemented" zurückgibt oder falls diese Funktion fehlt. Dann wird type(b).__rOP__(a, b) aufgerufen. a + b --> type(a).__add__(a, b) aufgerufen --> Nicht vorhanden oder Ergebnis "Not Implemented" --> type(b).__radd__(a, b) aufgerufen * Die logischen Operatoren "and", "or" und "not" können nicht überladen werden. Sie konvertieren Objekt(e) nach bool() per Methode __bool__() und verwenden dieses Ergebnis für die Ermittlung des Endergebnisses. "and" und "or" machen eine Short-Cut/Short-Circuit-Evaluation, d.h. sie brechen die Auswertung ab, falls das Ergebnis bereits aufgrund der linken Seite feststeht. not a # --> not bool(a) --> not type(a).__bool__(a) a and b # --> bool(a) == True? --> b # bool(a) == False? --> a a or b # --> bool(a) == True? --> a # bool(a) == False? --> b --------------------------------------------------------------------------------