In python, How to make right operand takes the priority (of __rmul__ method) when multiplying two different class?

Question

I am trying to make the following thing work but without success: I defined my own type `Unit` (inherit from build-in type `float`) to implement algebra for quantities with units. It does things in the way that: ``` class Unit(float): """provide a simple unit converter for a given quantity""" def __new__(cls, unit, num=1.): return super(Unit, cls).__new__(cls, num) def __init__(self, unit, num=1.): """set up base unit""" self.unit = unit def __str__(self,): return '{:s} {:s}'.format(super(Unit, self).__str__(), self.unit) def __rmul__(self, other): print 'rmul: {:f}'.format(super(Unit, self).__rmul__(other)) return Unit(self.unit, super(Unit, self).__rmul__(other)) def to(self,target): fun_conv = _conv(self.unit, target) return Unit(target, num=fun_conv(self)) c = 3e8 * Unit('m/s') # this will 1) create a Unit instance with magnitude '1' and unit 'm/s', # 2) invoke __rmul__ to return a new instance with number 3e8 and unit 'm/s' to variable 'c' print c.to('km/s') # returns 3e5 km/s ``…

Accepted Answer

If you don't inhereit from float, but instead create a new type wrapping float (so float._ mul_(yourtype) does not work), rmul will do what you want. The wrapping will of course not be free, though... and you'll have to implement all operations you want the type to support.

```
class T(object):
  def __init__(self, val):
    self.val = val

def __mul__(self, x):
    print("mul")
    return T(self.val*x)

def __rmul__(self, x):
    print("rmul")
    return T(self.val*x)

def __repr__(self):
    return str(self.val)

>>> t = T(2)
>>> t * 2
mul
4
>>> 2*t
rmul
4
```

In python, How to make right operand takes the priority (of rmul method) when multiplying two different class?

Solution

Problem