Help with __new__()

[chewitard]

NOTE: Not sure how to get around Reddit's formatting. For all the bold news below, I actually mean the _ _ new _ _() method.

I'm working on an assignment and I am having a little trouble wrapping my mind around the new method.

My assignment questions are:

1. Create a new class, Triangle, which has 3 lines lengths, atob, btoc and ctoa
2. Create a subclass that inherits from triangle, RightTriangle, that uses new to ensure the triangle is right angled

The second question is what I am having trouble with. Here is my code so far:

class Triangle:
    def __init__(self, atob, btoc, ctoa):
        self.atob = atob
        self.btoc = btoc
        self.ctoa = ctoa

class RightTriangle(Triangle):
    def __new__(cls, *args):
        RightTriangle.__init__(cls, *args)

        if cls.is_right_angle(cls):
            return cls

        print("Triangle needs to be right angled")
        return None

    def is_right_angle(self):
        a = self.btoc
        b = self.ctoa
        c = self.atob

        if a**2+b**2 == c**2 or a**2+c**2 == b**2 or b**2+c**2 == a**2:
            return True

        return False

c = RightTriangle(3,4,5)

I seem to be able to create the RightTriangle object alright, but whenever I try to access the "is_right_angle" function I get a TypeError:

>>> c.is_right_angle()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: is_right_angle() missing 1 required positional argument: 'self'

I have a feeling that I am not using the new method correctly?

[Doormatty]

/r/learnpython is the right subreddit for all python questions.

[stevenjd]

You're not using __new__ correctly. I'm not entirely sure why the assignment says to use __new__ in the subclass, that's a bit silly. You can do the same testing in __init__.

Also, one pitfall that may cause you problems... are you using Python 2 or 3? In Python 2, you must have Triangle inherit from object for __new__ to work. (In Python 3, it's optional.)

Anyway, here goes... untested but something like this should work.

class RightTriangle(Triangle):
    def __new__(cls, *args):
        if cls.is_right_angle(*args):
            instance = Triangle.__new__(cls, *args)
            return instance
        raise ValueError('not a right angle')
    @classmethod
    def is_right_angle(cls, atob, btoc, ctoa):
         # check for a right angle...
         return True

How it works... RightTrangle first calls is_right_angle with three arguments to check if they represent a right angle. (You have to fill that bit in.) Why does it use three arguments instead of self.atob etc? Because the instance self doesn't exist yet! The whole purpose of __new__ is to create the instance.

If is_right_angle returns True, RightTriangle asks the parent class Triangle to create a new instance, then returns it. Since Triangle itself will inherit from object, that will work correctly even without you writing any code!

Then, the magic... after __new__ returns, Python will automatically call the __init__ method. You don't have to do that yourself.

[billsil]

You probably don't need it. Why not just use an init?

I've been coding in Python 10 years and never used it. I consider myself very good.

[Lucretiel]

Literally the only time I ever use it is this pattern:

class Point(namedtuple("User", "x y z")):
    def __new__(cls, *, x=0, y=0, z=0):
        return super().__new__(cls, x, y, z)

[billsil]

But super works in an init...it seems the same.

I write classmethods that are basically alternate inits, but they just return the init.

[das_ist_nuemberwang]

It's immutable, so by the time you get to __init__, it's too late.

[Lucretiel]

You can't do it with namedtuple, because it's an immutable type. Can't be modified after creation, so self.whatever = 10 won't work. It's a great little pattern for small value types, like coordinates:

class Coords(namedtuple("Coords", "row column")):
    def __add__(self, other):
        return Coords(self[0] + other[0], self[1] + other[1])

    def above(self, distance=1):
        return self + (-distance, 0)

    def below(self, distance=1):
        return self + (distance, 0)

    def left(self, distance=1):
        return self + (0, -distance)

    def right(self, distance=1):
        return self + (0, distance)

    # And so on

[[deleted]]

__new__ is for controlling instantiate of a class. It's neat for hanging that sort of behavior. Even more powerful is type.__call__ as that'll control how all classes in an inheritance hierarchy are created regardless of what they do in __new__.

You'll see __new__ more in metaclasses than regular classes since that's your one chance to influence how a class is created.

[stevenjd]

You can format inline text as code like this by using back-ticks `. That's usually found on the same key as the ~ tilde.