operadores - python operador diferente de

Sobrecarga del operador en Python: manejo de diferentes tipos y orden de parámetros

Question

Esta pregunta ya tiene una respuesta aquí:

• El operador conmutativo Python anula 1 respuesta

Tengo una clase simple que ayuda con operaciones matemáticas en vectores (es decir, listas de números). Mi Vector se puede multiplicar por otras instancias de Vector o un escalar ( float o int ).

En otros lenguajes más fuertemente tipados, crearía un método para multiplicar dos vector y un método separado para multiplicar un vector por y int / float . Todavía soy bastante nuevo en Python y no estoy seguro de cómo implementarlo. La única forma en que puedo pensar en hacerlo es anular __mul__() y probar el parámetro entrante:

class Vector(object):
  ...
 def __mul__(self, rhs):
  if isinstance(rhs, Vector):
     ...
  if isinstance(rhs, int) or isinstance(rhs, float):
    ...

Incluso si lo hago de esa manera, me veré obligado a multiplicar un Vector por un escalar como este:

v = Vector([1,2,3])

result = v * 7

¿Qué sucede si quiero invertir el orden de los operandos en la multiplicación?

result = 7 * v

¿Cuál es la forma correcta de hacerlo en Python?

Answer 1

Hay métodos especiales para operaciones inversas :

• __rmul__ por el reverso de __mul__
• y __radd__ por __add__ ,
• ...

Se NotImplemented cuando el operador del lado izquierdo devuelve NotImplemented para la operación normal (por lo que la operación 2 + vector_instance probará primero: (2).__add__(vector_instance) pero si esto devuelve NotImplemented entonces se vector_instance.__radd__(2) ).

Sin embargo, no utilizaría isinstance comprobaciones de isinstance en los métodos aritméticos especiales, que darán lugar a mucha repetición de código.

En realidad, podría crear un caso especial en __init__ e implementar una conversión de escalares a un Vector allí:

class Vector(object):
    def __init__(self, x, y=None, z=None):
        if y is None and z is None:
            if isinstance(x, Vector):
                self.x, self.y, self.z = x.x, x.y, x.z
            else:
                self.x, self.y, self.z = x, x, x
        elif y is None or z is None:
            raise ValueError(''Either x, y and z must be given or only x'')
        else:
            self.x, self.y, self.z = x, y, z

    def __mul__(self, other):
        other = Vector(other)
        return Vector(self.x*other.x, self.y*other.y, self.z*other.z)

    __rmul__ = __mul__   # commutative operation

    def __sub__(self, other):
        other = Vector(other)
        return Vector(self.x-other.x, self.y-other.y, self.z-other.z)

    def __rsub__(self, other):   # not commutative operation
        other = Vector(other)
        return other - self

    def __repr__(self):
        return ''Vector({self.x}, {self.y}, {self.z})''.format(self=self)

Esto debería funcionar como se esperaba:

>>> 2 - Vector(1, 2, 3)
Vector(1, 0, -1)

>>> Vector(1, 2, 3) - 2
Vector(-1, 0, 1)

>>> Vector(1, 2, 3) * 2
Vector(2, 4, 6)

>>> 2 * Vector(1, 2, 3)
Vector(2, 4, 6)

Tenga en cuenta que este fue un borrador rápido y sucio (que podría tener varios errores). Solo quería presentar la "idea general" de cómo podría resolverse sin una carcasa especial del tipo en cada operación aritmética.

Answer 2

También necesita implementar __rmul__ . Cuando falla la llamada inicial a int.__mul__(7, v) , Python intentará luego con el type(v).__rmul__(v, 7) .

def __rmul__(self, lhs):
    return self * lhs  # Effectively, turn 7 * v into v * 7

Como señala Rawing, simplemente podría escribir __rmul__ = __mul__ para esta definición. __rmul__ existe para permitir la multiplicación no conmutativa en la que simplemente diferir a __mul__ con los operandos invertidos no es suficiente.

Por ejemplo, si estaba escribiendo una clase de Matrix y deseaba apoyar la multiplicación por una lista anidada, por ejemplo,

m = Matrix(...)  # Some 2 x 2 matrix
n = [[1, 2], [3,4]]
p = n * m

Aquí, la clase de list no sabría cómo hacer una lista múltiple por una instancia de Matrix , así que cuando la list.__mul__(n, m) falla, Python probaría Matrix.__rmul__(m, n) . Sin embargo, n * m y m * n son dos resultados diferentes en general, entonces Matrix.__rmul__(m, n) != Matrix.__mul__(m, n) ; __rmul__ tiene que hacer un poco de trabajo extra para generar la respuesta correcta.