3

Say I have two Python classes which both define the add and radd operator overloads, and I add one instance of one class to another instance of another class. The chosen implementation depends on the order in which the items are added (Python looks for an add method on the LHS first, etc).

Is it possible for me to define a precedence on which object's implementation is preferred? I want, for example, that radd is called on the RHS if its precedence is higher than that of the LHS.

I really want to do this for all overloaded operators, so a more general solution is what I'm eventually after.

[edit: added example]

For example, I may have a custom number type class, and I might wish to silently typecast ints to my custom type. Hence I need add and radd (and all the other operator overloads with their 'r' cousins).

Next, I want a generic polynomial class, whose coefficients are some generic number type. I also want to typecast things to polynomials, so I implement add and radd functions for it. However, if I add a custom number on the left with and a polynomial on the right, I want it to be typecast up to a polynomial instead of Python trying to typecast it down to a custom number type. Hence, I want radd to be called instead of add.

Improve this question
6
  • An example would be good, because I appear to have failed to help you so far. Commented Mar 9, 2014 at 22:57
  • You had not helped me so far because you misread my question, and after two revisions have said far less than BrenBarn did in his short answer. Commented Mar 9, 2014 at 23:06
  • Sure, Just trying to explain for the benefit of all who read this what's going on with Python's object methods. I was really interested to see your use-case for this precedence idea. Commented Mar 9, 2014 at 23:09
  • @AaronHall Just added the example. Commented Mar 9, 2014 at 23:10
  • I think your edit strays a bit from the real issue. Builtin types already do defer to custom __radd__ methods, in that if you do 3 + MyCustomInt(), your custom class's __radd__ will indeed be called. If I understand right, the essence of your question is that you want to be able to do the same thing with your custom classes. Commented Mar 9, 2014 at 23:11

2 Answers 2

Reset to default
2

There's no builtin mechanism for defining a "precedence" as you describe. What you could do is implement the precedence checking yourself within the magic methods. That is, you could define the object's __add__ method so that it checks the "precedence" of the other object (however that's defined), and calls that object's __add__ (or __radd__) if its precedence is higher.

Note that, if you just want the LHS __add__ to defer to the RHS __radd__ you can return NotImplemented, which will essentially tell Python "act as if the __add__ method you just called didn't exist".

Here is a sketch of how this could be done with a decorator on the magic methods:

def deco(op):
    def newOp(self, other):
        if other.precedence > self.precedence:
            return NotImplemented
        return op(self, other)
    return newOp

class Thing(object):
    precedence = 0

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

    @deco
    def __add__(self, other):
        print "Called", self, "__add__"
        return self.__class__(self.val + other.val)

    def __radd__(self, other):
        print "Called", self, "__radd__"
        return self.__class__(self.val + other.val)

class Weak(Thing):
    precedence = 1

class Strong(Thing):
    precedence = 2

This results in the Strong version always being called regardless of the order of operands, so it always returns a Strong:

>>> Weak(1) + Strong(1)
Called <__main__.Strong object at 0x01F96BF0> __radd__
<__main__.Strong object at 0x01F96BD0>
>>> Strong(1) + Weak(1)
Called <__main__.Strong object at 0x01F96B90> __add__
<__main__.Strong object at 0x01F96250>
Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

I am trying to come up with an elegant way to do this, but the best I can think of is having a decorator that checks the function's name, splices an 'r' after the second underscore (Python 3 compatibility, augh!) and calls it if the precedence is higher. It doesn't seem all that elegant... any better ideas?
@JeremyKun: See my edited answer. You can return NotImplemented to pass the buck. However, your comment suggests you're trying to do something a bit more general than what your question asks. If you just want to call __radd__, you don't need to check the name and splice or anything so fancy; you just rewrite the __add__ method so it literally calls other.__radd__ in the appropriate situation.
Raising (returning?) NotImplemented is a great tip! The reason I want a more general way to do it is because I want to do the same thing for sub, mul, div, and lots of other overloads.
My mistake, just learned that NotImplemented is actually a built in constant.
@JeremyKun: Might be good to add that to your question. As in many situations, it may be that there's a simple but relatively inflexible way to do it for one method, and a more complex but comprehensive way if you need to do it for many. From your comment I gather you may be able to figure out how to do it with NotImplemented using your decorator idea though.
|
1

Python will use __radd__ if __add__ is not implemented on the first of the items using the + operator.

foo + bar

will attempt to use foo's __add__ operator on the other, bar. If that is not implemented, it will call bar's __radd__.

class Foo(object):
    pass

class Bar(object):
    def __radd__(self, other):
        print('Bar.__radd__ was called!')

>>> foo = Foo()
>>> bar = Bar()
>>> foo + bar
Bar.__radd__ was called!

And when Foo has __add__ it gets precedence:

class Foo(object):
    def __add__(self, other):
        print('Foo.__add__ was called!')

>>> foo = Foo()
>>> foo + bar
Foo.__add__ was called!

You cannot force Python to do anything special if both are implemented, the order of precedence is predefined. You can check for the other's existence however:

class Foo(object):
    def __add__(self, other):
        if hasattr(other, '__radd__'):
            return other.__radd__(self)
        else:
            print('Foo.__add__ was called!')

>>> foo = Foo()
>>> foo + bar
Bar.__radd__ was called!
Improve this answer

4 Comments

This does not answer my question, which is about forcing Python to do something special if both add and radd are defined on both objects.
@JeremyKun Updated my answer, what do you think?
The last sentence is the only relevant one (it's clear from my question that I understand the existing precedence rules), and that answer was already given by BrenBarn.
@JeremyKun I demonstrate how to do that now.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.