Question

I have a simple vector class that overloards several arithmetic operators:

class vec2:
    x = 0.0
    y = 0.0

    def __add__(self,other):
        self.x = other.x
        self.y = other.y

    def __mul__(self,scalar):
        self.x *= scalar
        self.y *= scalar

However, somewhere else I call the method like this:

class foo:
    position = vec2()
    velocity = vec2()

    def update(self,dt):
        self.position += self.velocity * dt;

However, once I get to the update function, the interpreter gives an error:

'tuple' object has no attribute 'x'

inside the __add__ function.

Why is “other” in __add__ passed as a tuple, and not a vec2?

The entire code is here.

Answer 1

Return new vectors when using __add__ and __mul__, and handle ‘strange’ types:

class vec2:
    x = 0.0
    y = 0.0

    def __init__(self, x=0.0, y=0.0):
        self.x, self.y = x, y

    def __add__(self, other):
        if not isinstance(other, self.__class__):
            return NotImplemented
        result = self.__class__(self.x, self.y)
        result.x += other.x
        result.y += other.y
        return result

    def __iadd__(self, other):
        if not isinstance(other, self.__class__):
            return NotImplemented
        self.x += other.x
        self.y += other.y
        return self

    def __mul__(self, other):
        if not isinstance(other, self.__class__):
            return NotImplemented
        result = self.__class__(self.x, self.y)
        result.x *= other.x
        result.y *= other.y
        return result

    def __imul__(self, other):
        if not isinstance(other, self.__class__):
            return NotImplemented
        self.x *= other.x
        self.y *= other.y
        return self

To modify the vectors in-place, use __iadd__ and __imul__; these still need to return the new value; this can be self.

Note that this does not handle just passing in a tuple of (x, y) coordinates. If you want to support that usecase, you need to specially handle it:

class foo:
    def __init__(self, position=(0.0, 0.0), velocity=(1.0, 1.0)):
        self.position = vec2()
        self.velocity = vec2(*velocity)

    def update(self, dt):
        if isinstance(dt, tuple):
            dt = vec2(*dt)
        self.position += self.velocity * dt;

Note also that you should not really use class attributes for your position and velocity values; I’ve used instance attributes instead above, and took the opportunity to set both position and velocity to sane values.

Demo:

>>> f = foo()
>>> f.position.x, f.position.y
(0.0, 0.0)
>>> f.update((1, 2))
>>> f.position.x, f.position.y
(1.0, 2.0)