Mutable 2d Vector classs
There are no docstrings.
I would suggest reconsidering the mutability of the vectors. The advantages of mutability are:

a. You get to reuse the original storage for the original vector when you make a change, avoiding a couple of memory management operations.

b. You save a couple of characters when writing some update operations, for example you can write v.normalize() instead of, say, v = v.normalized().

But the disadvantage of mutability is that it is harder to reason about operations. If you see a function that takes some vectors, let's say

def collide(p: VectorType, q: VectorType, r: Real) -&gt; Bool:
    "Return True if p and q are separated by no more than r."


is it safe to pass p=sprite.position, or do you need to make a copy? With mutability, then for all you know, the function is implemented like this:

p -= q
return p.magnitude &lt;= r


So in a world where vectors are mutable, you have to worry about this possibility, and perhaps document for each function which arguments get mutated and which don't. If vectors are immutable, then all this is unnecessary and reasoning about the behaviour of code is easier.

Immutability would avoid the need to implement the __iadd__ and __isub__ methods. Also, you could inherit from tuple and save some memory. See this vector class on github for some implementation ideas.
The __truediv__ method has different behaviour based on the type of the argument. This is inconsistent with the behaviour of __mul__ and __rmul__ and __rtruediv__, none of which have this behaviour. Also, dispatching based on the type makes it harder to read and reason about code. If you know that v is a vector and then you read the expression v / a, you can't immediately deduce that a must be a scalar as you could in the case of v * a.

I guess that you added the variant operation because of some use case. But nonetheless I would recommend giving the variant operation a different method name, for example scaled.
In __radd__ the operations should be reversed, with the other values on the left (just in case they have unusual implementations of __add__ method):

def __radd__(self, other):
    return Vector(other[0] + self.x, other[1] + self.y)


Similarly for __rmul__.
There's no checking that the other vector has the right length. There's nothing stopping me from writing:

Vector(1, 2) + [3, 4, 5]


which ought to be an error.
In __repr__ I suggest writing type(self) rather than self.__class__, just as you would write len(s) rather than s.__len__().
In from_polar you should call cls rather than Vector, to support subclasses.
normalize has the operations the wrong way round: you need to divide by the magnitude, not multiply. But it would be simpler to write self.magnitude = 1.
In magnitude it would be clearer to call the argument length or magnitude rather than value.
In magnitude, consider writing math.hypot(self.x, self.y).
In rotation it would be clearer to call the argument theta or angle rather than value.