Redéfinir un opérateur

>>> int.__add__ = lambda s, v: s + v
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't set attributes of built-in/extension type 'int'

import math

class Int:
    def __init__(self, v):
        self.v = v

    def __mul__(self, v):
        print('on me demande de multiplier')
        return round(self.v * v, 3)

sqrt = lambda n: round(math.sqrt(n), 3)

print(Int(5) * sqrt(2))

pi = 3.141592653589793238462

e = 2.71828182845904523536

phi = 1.618033988749894848204

G = 6.6743015e-11

i = 1j
j = 1j

c = 299792458

E = 1.602176634e-19

# Plus loin...
# Je ne mets qu'une seule classe, il en a trois, mais elles fonctionnent de la même façon

class MeasuresConstants:  # In meters
    def __init__ (self):
        self._inch = 0.0254   # Le programme stocke les valeurs exactes et les renvoie formatées à la demande avec des property
        self._foot = 0.3048
        self._yard = 0.9144
        self._nauticalMile = 1852
        self._league = 4828.032
        self._ua = 149597870000
        self._ly = 9460730472580800
        self._parsec = 30856775670528308


    def _getInch (self):
        return trans (self._inch)  # Valeur de retour formatée

    def _getFoot (self):
        return trans (self._foot)

    def _getYard (self):
        return trans (self._yard)
    
    def _getNauticalMile (self):
        return trans (self._nauticalMile)
    
    def _getLeague (self):
        return trans (self._league)

    def _getUa (self):
        return trans (self._ua)

    def _getLy (self):
        return trans (self._ly)

    def _getParsec (self):
        return trans (self._parsec)


    def _setSomething (self, nValue):  # On ne peut rien changer ici, on se fait donc gronder si on tente de modifier quoi que ce soit !
        print ("\n You aren't allowed to change a constant value !\n")


    inch = property (_getInch, _setSomething)
    foot = property (_getFoot, _setSomething)
    yard = property (_getYard, _setSomething)
    nauticalMile = property (_getNauticalMile, _setSomething)
    league = property (_getLeague, _setSomething)
    ua = property (_getUa, _setSomething)
    ly = property (_getLy, _setSomething)
    parsec = property (_getParsec, _setSomething)


m = MeasuresConstants ();  # L'utilisateur y accède par m.nom_de_la_constante

def frequence (duration, t = 1):  # Renvoie une fréquence à partir d'une période et du nombre de répétitions dans cette période
    return trans (1 / (duration / t))


def sRadius (x):  # Renvoie le rayon de Schwarzschild d'un trou noir en mètres
    return trans ((2 * 6.67408e-11 * x) / 299792458**2)


def average (*params):  # Revoie la moyenne de ses arguments
    values = list (params)

    summ = 0
    i = len (values) - 1
    
    while i > -1:
        summ += values[i]
        i -= 1

    return trans (summ / len (values))

class Cube:
    def __init__ (self, edge = 1):  # Quand on créé le cube
        if isOK (edge):
            self._edge = edge

        else:
            print ("\n Invalid edge : it must be a positive non-zero real number !\n Initialization of default values...\n Done\n")
            self._edge = 1


    def _getEdge (self):
        return formated (self._edge)  # Retour formaté

    def _getVolume (self):
        return formated (self._edge**3)

    def _getSurface (self):
        return formated (self._edge**2 * 6)

    def _getDiagonale (self):
        return formated (self._edge * 1.732050807568878)


    def _setEdge (self, nEdge):  # Quand on veut changer l'arête du cube
        if isOK (nEdge):
            self._edge = nEdge

        else:
            print ("\n Invalid new edge : it must be a positive non-zero real number !\n")

    def _setVolume (self, nVolume):
        if isOK (nVolume):
            self._edge = nVolume**(1 / 3)

        else:
            print ("\n Invalid new volume : it must be a positive non-zero real number !\n")

    def _setSurface (self, nSurface):
        if isOK (nSurface):
            self._edge = (nSurface / 6)**0.5

        else:
            print ("\n Invalid new surface : it must be a positive non-zero real number !\n")

    def _setDiagonale (self, nDiadonale):
        if isOK (nDiagonale):
            self._edge = nDiadonale / 1.732050807568878

        else:
            print ("\n Invalid new diagonale : it must be a positive non-zero real number !\n")


    def __getattr__ (self, name):  # Si l'utilisateur essaie d'accéder à un attribut qui n'existe pas
        print ("\n I'm so sorry, but there's no attribute named \"{}\" in this object !\n".format (name))

    def __repr__ (self):  # Lance une représentation graphique du cube
        print ("\n Loading resources...")
        system ('Graphics.pyw cube {0} {1} {2} {3}'.format (self.edge, self.volume, self.surface, self.diagonale))

        return "\n Done !\n"


    edge = property (_getEdge, _setEdge)
    volume = property (_getVolume, _setVolume)
    surface = property (_getSurface, _setSurface)
    diagonale = property (_getDiagonale, _setDiagonale)