## Example

Magic (also called dunder as an abbreviation for double-underscore) methods in Python serve a similar purpose to operator overloading in other languages. They allow a class to define its behavior when it is used as an operand in unary or binary operator expressions. They also serve as implementations called by some built-in functions.

Consider this implementation of two-dimensional vectors.

``````import math

class Vector(object):
# instantiation
def __init__(self, x, y):
self.x = x
self.y = y

# unary negation (-v)
def __neg__(self):
return Vector(-self.x, -self.y)

return Vector(self.x + other.x, self.y + other.y)

# subtraction (v - u)
def __sub__(self, other):
return self + (-other)

# equality (v == u)
def __eq__(self, other):
return self.x == other.x and self.y == other.y

# abs(v)
def __abs__(self):
return math.hypot(self.x, self.y)

# str(v)
def __str__(self):
return '<{0.x}, {0.y}>'.format(self)

# repr(v)
def __repr__(self):
return 'Vector({0.x}, {0.y})'.format(self)
``````

Now it is possible to naturally use instances of the `Vector` class in various expressions.

``````v = Vector(1, 4)
u = Vector(2, 0)

u + v           # Vector(3, 4)
print(u + v)    # "<3, 4>" (implicit string conversion)
u - v           # Vector(1, -4)
u == v          # False
u + v == v + u  # True
abs(u + v)      # 5.0
``````