python - overloading several operators at once

Question

I have a custom class and I want to overload several artihmetic operators, and wonder if there is a way to avoid having to write out the code for each one individually. I haven't been able to find any examples that don't explicity overload each operator one-by-one.

class Foo(object):
    a=0 

    def __init__(self, a):
        self.a=a            

    def __add__(self, other):
        #common logic here
        return Foo(self.a+other.a)

    def __sub__(self, other):
        #common logic here  
        return Foo(self.a-other.a)

    def __mul__(self, other):
        #common logic here
        return Foo(self.a*other.a)

#etc...

The logic is slightly more complex than this, but the common pattern is that each operator overload method contains some identical code to check that the operation is allowed, and then constructs an operation using the class members. I want to reduce the redundant code. This works:

class Foo(object):
    a=0 

    def __init__(self, a):
        self.a=a            

    def operate(self, other, operator):
        #common logic here
        a = constructOperation(self.a, other.a, operator)
        return Foo(a)

    def __add__(self, other):
        return self.operate(other, "+")

    def __sub__(self, other):       
        return self.operate(other, "-")     


def constructOperation(operand0, operand1, operator):
    if operator=="+": 
        return operand0 + operand1
    if operator=="-": 
        return operand0 - operand1

But it seems kind of silly to be constructing operations manually like that. Does this approach make sense, or is there a better way here?

functools defines a decorator total_ordering, which I think does what you are looking for, just for relational operators. The source isn't too difficult, so you could easily adapt it's behaviour. — phipsgabler
– phipsgabler, Commented Mar 4, 2013 at 8:10
Look at the MagicNumber class in my answer to this question: stackoverflow.com/questions/7820771/… — PaulMcG
– PaulMcG, Commented Mar 4, 2013 at 9:18

Antimony · Accepted Answer · 2013-03-04 07:26:03Z

7

You can do it via reflection and higher order functions, though this may not play well with inheritance.

import operator

def apply_a(func):
    def inner(self, other):
        return Foo(func(self.a, other.a))
    return inner

class Foo(object):
    def __init__(self, a=0):
        self.a = a

for name in ['__add__','__mul__','__sub__']:
    setattr(Foo, name, apply_a(getattr(operator, name)))

answered Mar 4, 2013 at 7:26

Antimony

39.8k13 gold badges103 silver badges115 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

pteehan Over a year ago

I think I prefer the simplicity of NPE's answer, but I've marked this as correct since it answers the question I've asked. Thanks.

NPE · Accepted Answer · 2013-03-04 07:28:29Z

5

I would just use the operator module:

import operator

class Foo(object):

    a=0 

    def __init__(self, a):
        self.a=a            

    def operate(self, other, op):
        #common logic here
        return Foo(op(self.a, other.a))

    def __add__(self, other):
        return self.operate(other, operator.add)

    def __sub__(self, other):       
        return self.operate(other, operator.sub)

answered Mar 4, 2013 at 7:28

NPE

503k114 gold badges970 silver badges1k bronze badges

1 Comment

pteehan Over a year ago

Thank you, this is definitely an improvement.

shx2 · Accepted Answer · 2013-03-04 07:29:33Z

I don't know if there's a way to avoid defining all (or at least most) of the operators. It makes sense that there isn't one. After all, there is no one single way to define __sub__ given __add__ (and __mul__). However, one improvement would be to pass callables to constructOperation() instead of the symbolic operators.

E.g.

class Foo(object):
    a=0 

    def __init__(self, a):
        self.a=a            

    def operate(self, other, operator):
        #common logic here
        a = constructOperation(self.a, other.a, operator)
        return Foo(a)

    def __add__(self, other):
        return self.operate(other, sum)

    def __sub__(self, other):       
        return self.operate(other, lambda x, y: x - y)     


def constructOperation(operand0, operand1, operator):
    return operator(operand0, operand1)

Bakuriu · Accepted Answer · 2013-03-04 07:38:33Z

You must define the methods. This is because python does a special look-up when calling special methods, and thus something like this:

import operator

class Foo(object):

    def __init__(self, a):
        self.a = a
    def __getattr__(self, attr):
        try:
            func = getattr(operator, attr)
            return lambda x: Foo(func(self.a, x.a))
        except AttributeError:
            raise AttributeError(attr)

Doesn't work:

>>> f = Foo(1)
>>> g = Foo(3)
>>> f * g     #no __mul__?
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for *: 'Foo' and 'Foo'
>>> getattr(f, '__mul__')
<function <lambda> at 0x2975140>
>>> f.__mul__(g)
<__main__.Foo object at 0x2922ed0>
>>> f.__mul__(g).a
3

The "best" you can do is to use Antimony's solution, which is the most DRY.

Collectives™ on Stack Overflow

python - overloading several operators at once

4 Answers 4

1 Comment

1 Comment

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

1 Comment

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related