Getting unary operators to work with Python classes

Question

The code:

>>> class Negative: 
...      pass

>>> class Positive:
...    @classmethod
...    def __neg__(cls):
...        return Negative

So I try

>>> -Positive is Negative
TypeError: bad operand type for unary -: 'type'

this works though

>>> -Positive() is Negative
True

The same goes with other unary operators and their related "magic" methods (e.g. ~ and __invert__, + and __pos__, etc).

Why does it work with instances but not with classes? How can I get it to work?

Edit: I have modified the code as suggested to move the magic method in a metaclass.

class Negative: pass

class PositiveMeta(type):
    def __neg__(cls):
        return Negative

class Positive(metaclass=PositiveMeta): pass

The class of a class is it's metaclass. Define the methods in a custom metaclass, not in a classmethod. Magic methods are only recognized when they are defined in a class. — Mad Physicist, Dec 28 '17 at 08:19
@Jean-FrançoisFabre why not? They'd just have to go in a metaclass to take effect. — Mad Physicist, Dec 28 '17 at 08:20
In fact, this is probably not restricted to unary operators. You could probably add and multiply classes together if you define the appropriate methods in the metaclass. — Mad Physicist, Dec 28 '17 at 08:23
@MadPhysicist: yes it works. I think my issue was that I was originally mixing Python2 metaclass syntax with Python3. Thanks — Michael Ekoka, Dec 28 '17 at 08:27
Nice. The sheer majesty of Python's object orientedness never ceases to amaze me. Go apeshit: define some binary operators for your classes. Let them divide and exponentiate each other. — Mad Physicist, Dec 28 '17 at 08:32
yeah. nice. I don't have much use for metaclasses but still, interesting. — Jean-François Fabre, Dec 28 '17 at 08:38
@Jean-FrançoisFabre. I've posted an answer explaining what is going on a bit better than the current batch of folks that read my comment managed to do :) — Mad Physicist, Dec 28 '17 at 09:15
@MadPhysicist yeah, that sounded like guesswork but I wouldn't have thought of it. — Jean-François Fabre, Dec 28 '17 at 10:17
@Jean-FrançoisFabre it was guesswork. I was putting my faith in the consistency and general awesomeness of Python :) — Mad Physicist, Dec 28 '17 at 15:26
@Jean-FrançoisFabre. You caught me :) I literally made an educated guess, had the other guys test it out for me and wrote up a detailed report on the result. — Mad Physicist, Dec 28 '17 at 15:59

Mad Physicist · Accepted Answer · 2017-12-28T09:20:44.957

The reason your code does not work as originally written is that you can not define a magic method in an instance. According to the docs:

For custom classes, implicit invocations of special methods are only guaranteed to work correctly if defined on an object’s type, not in the object’s instance dictionary.

This applies to classes (which are instances of some metaclass), just as much as it does to "regular" objects. In that sense, this question is equivalent to any of the following: Overriding special methods on an instance, Why does Python's bool builtin only look at the class-level __bool__ method, Assigning (instead of defining) a __getitem__ magic method breaks indexing.

Decorating your magic method with @classmethod is analagous to assigning a bound method obtained through __get__ to an instance. In both cases, Python simply ignores any descriptors not defined in the class.

That is also the reason that -Positive() is Negative works. When you negate an instance of Positive, the interpreter looks up __neg__ in the class. Decorating with @classmethod is totally superfluous here since you ignore the input parameters anyway. But now you have a magic method that returns a class object.

To properly define a magic method on your class object, you need to define it on the metaclass:

class MetaPositive(type):
    def __neg__(self):
        return Negative

class Negative: pass

class Positive(metaclass=MetaPositive): pass

The interesting thing here is that this is not restricted to unary operators. You can define any dunder method on the metaclass and have your classes support the corresponding operations:

class MetaPositive(type):
    def __gt__(self, other):
        if other is Negative:
            return True
        return False

Now you can use the > operator to compare your classes. I'm not implying that you should ever do something like that, but the possibility is definitely there.

The question remains, as it often does, as to why you would want to do something like this in the first place.

Thanks for the more complete explanation. I moved the accepted answer, as your comment was the one to originally put me back on track. I had in fact already tried to go through metaclasses to do this, but being new to Python3 I had not realized that the old syntax (`__metaclass__ = PositiveMeta`) wasn't doing anything and the error message threw me off (bad operant type). Your comments confirmed that some of my assumptions were correct, while others needed rechecking. Good catch and thank you. — Michael Ekoka, Dec 28 '17 at 11:29
@mike_e. Good call, my answer is only suitable for Python 3. Thanks for selecting it. While I agree that it offers a much more detailed explanation, I have to give credit to the other answers too. They confirmed what was initially just a very educated guess on my part, made on a mobile device with no access to an interpreter. — Mad Physicist, Dec 28 '17 at 15:33

asherbret · Answer 2 · 2017-12-28T09:32:24.573

3

This seems to work:

class Negative: pass

class PositiveMeta(type):
    def __neg__(self):
        return Negative

class Positive(metaclass=PositiveMeta):
    pass

print(-Positive is Negative)  # prints True

edited Dec 28 '17 at 09:32

answered Dec 28 '17 at 08:25

asherbret

5,439
4
38
58

Why do you have a classmethod in your example? – Mad Physicist Dec 28 '17 at 09:07
What I meant is, why do you bother defining `__pos__` the way you do right after you show the correct way of defining `__neg__`? – Mad Physicist Dec 28 '17 at 09:21
It was copied from OP's code. However, it's not needed and may confuse future readers so I edited my answer. – asherbret Dec 28 '17 at 09:23
It's outright counterproductive. The whole point of answering a question is to fix OP's code, not to make it more convoluted. – Mad Physicist Dec 28 '17 at 09:24

score 3 · Answer 3 · answered Dec 28 '17 at 08:25

3

Try this one:

class Negative:
    pass

class meta(type):
    def __neg__(cls):
        return Negative

class Positive(metaclass=meta):
    pass

-Positive
#output __main__.Negative

answered Dec 28 '17 at 08:25

Sraw

18,892
11
54
87

Getting unary operators to work with Python classes

3 Answers3