3.3.7 Emulazione dei tipi numerici

Per emulare gli oggetti numerici si possono definire i seguenti metodi. Non bisognerebbe definire i metodi corrispondenti ad operazioni che non sono supportate da una data tipologia di numero implementato (per esempio per i numeri non integrali le operazioni bit per bit).

__add__( self, other)
__sub__( self, other)
__mul__( self, other)
__floordiv__( self, other)
__mod__( self, other)
__divmod__( self, other)
__pow__( self, other[, modulo])
__lshift__( self, other)
__rshift__( self, other)
__and__( self, other)
__xor__( self, other)
__or__( self, other)
Questi metodi vengono chiamati per il calcolo delle operazioni di aritmetica binaria (+, -, *, //, %, divmod(), pow(), **, <<, >>, &, ^, |). Per esempio, si chiama x.__add__(y) per calcolare l'espressione x+y, dove x è un'istanza di classe con un metodo __add__(). Il metodo __divmod__() è equivalente all'uso di __floordiv__() e __mod__(); da non correlare a __truediv__() (descritto qui sotto). Notare che, se bisogna supportare la versione ternaria della funzione built-in pow(), __pow__() dovrebbe essere definito in modo da accettare un terzo argomento.

__div__( self, other)
__truediv__( self, other)
L'operazione di divisione (/) viene effettuata mediante questi metodi. Il metodo __truediv__() viene utilizzato quando __future__.division è in uso, altrimenti viene usato __div__(). Se viene definito solamente uno dei due metodi, l'oggetto non effettuerà la divisione nel diverso contesto; verrà invece sollevata l'eccezione TypeError.

__radd__( self, other)
__rsub__( self, other)
__rmul__( self, other)
__rdiv__( self, other)
__rtruediv__( self, other)
__rfloordiv__( self, other)
__rmod__( self, other)
__rdivmod__( self, other)
__rpow__( self, other)
__rlshift__( self, other)
__rrshift__( self, other)
__rand__( self, other)
__rxor__( self, other)
__ror__( self, other)
Questi metodi vengono richiamati per compiere le operazioni di aritmetica binaria (+, -, *, /, %, divmod(), pow(), **, <<, >>, &, ^, |) con gli operandi riflessi (NdT: scambiati). Tali funzioni vengono chiamate solamente se l'operando di sinistra non supporta l'operazione corrispondente. Ad esempio, per valutare l'espressione x-y, dove y è un'istanza di classe con un metodo __rsub__(), viene chiamata y.__rsub__(x). Notare che la funzione ternaria pow() non tenterà la chiamata a __rpow__() (le regole coercitive diventano troppo complesse).

__iadd__( self, other)
__isub__( self, other)
__imul__( self, other)
__idiv__( self, other)
__itruediv__( self, other)
__ifloordiv__( self, other)
__imod__( self, other)
__ipow__( self, other[, modulo])
__ilshift__( self, other)
__irshift__( self, other)
__iand__( self, other)
__ixor__( self, other)
__ior__( self, other)
Questi metodi sono chiamati per compiere le operazioni aritmetiche di aumento (+=, -=, *=, /=, %=, **=, <<=, >>=, &=, ^=, |=). Dovrebbero svolgere l'operazione appropriata (modificando self) e restituendo il risultato (che potrebbe, ma non per forza, essere self). Se non viene definito un metodo specifico, l'operazione di aumento fa ricorso ai metodi consueti. Per esempio, per il calcolo dell'espressione x+=y, dove x è un'istanza di classe con un metodo __iadd(), richiama x.__add__(y). Se x è un'istanza di classe che non ha un metodo __iadd(), per il calcolo di x+y, considera i metodi x.__add__(y) e y.__radd__(x).

__neg__( self)
__pos__( self)
__abs__( self)
__invert__( self)
Richiamati per il calcolo delle operazioni matematiche unarie (-, +, abs() e ~).

__complex__( self)
__int__( self)
__long__( self)
__float__( self)
Questi metodi vengono usati per valutare le funzioni built-in complex(), int(), long() e float(). Dovrebbero restituire un valore del tipo appropriato.

__oct__( self)
__hex__( self)
Chiamati per il calcolo delle funzioni built-in oct() ed hex(). Dovrebbero restituire un valore stringa.

__coerce__( self, other)
Viene chiamato per il calcolo matematico numerico a ``modalità misto''. Deve restituire una doppia tupla che contiene self ed other convertiti in un tipo numerico comune, oppure None se tale conversione non è fattibile. Quando il tipo comune diventa quello che era other, è sufficiente che venga restituito None, siccome l'interprete richiederà anche l'altro l'oggetto per tentare la forzatura a quel tipo (ma talvolta, è utile a questo punto effettuare la conversione nell'altro tipo, se la sua implementazione non può essere modificata). Un valore di ritorno pari a NotImplemented è come se fosse restituito None.

Vedete Circa questo documento... per informazioni su modifiche e suggerimenti.