class Temperature(int):
    
    def __new__(cls, val, unit):
        return super().__new__(cls, val)
    
    def __init__(self, val, unit):
        super().__init__()
        self.unit = unit
        
    def __str__(self):  
        return '%g %s' % (self, self.unit)
    
    def __add__(self, other):
        if self.unit != other.unit:
            raise ValueError("Choux et carottes, connard !")
        return Temperature(super().__add__(other), self.unit)


t1 = Temperature(1, "C")
t2 = Temperature(2, "C")
t3 = Temperature(2, "K")

print(t1 + t2)
print(t2 + t3)

Mais bon autant utiliser une lib existante type https://pypi.python.org/pypi/units/

Du style une pseudo surcharge d’opérateur comme en C++

Et si on peut, peut on aussi renvoyer une exception dans le cas où l’unité ne serait pas la même ?

Merci pour les typos.

def init(self, value, unit):

…super(Temperature, cls).init(value)

remplacer cls par self

ça ne change pas le message d’erreur car l’erreur se produit avant, à l’appel de new

>>> class Foo:
...     pass

>>> Foo.__new__
 # note l'id
>>> type(Foo.__new__(Foo)) # note l'effet


>>> object.__new__ 
 # meme id !
>>> type(object.__new__(Foo)) # meme effet !

__new__ est n’est pas une méthode de Foo mais de object, qui est attachée à Foo. C’est aussi une méthode statique. Toute classe custo en Python hérite de object, mais comme new est appelée très souvent, plutot que de faire un look up au parent à chaque fois ce qui est couteux, Python utilise cette astuce pour avoir la meme methode partout.

je m’étonne qu’il faille passer cls en argument de new

Quand on utilise super() pour aller chercher le init d’une classe parente, on utilise la syntaxe:

super(MyClass, self).init()

il n’y a pas le self passé en argument du init(). il est passé automatiquement.

Alors pourquoi cls est passé en argument de new ?

@jpcw: Oui mais dans les docs on lit immutable partout, donc je garde volontairement le terme pour qu’un débutant puisse faire facilement le lien. Il faut faire des concessions.