Guia Python: redefinición de los operadores matemáticos.

Python es un lenguaje de script desarrollado por Guido van Rossum.
Podemos codificar empleando programación lineal, estructurada y orientada a objetos (tengamos en cuenta que esta última es la que se ha impuesto en la actualidad).
Se cuenta con intérpretes de Python en múltiples plataformas: Windows, Linux, Mac etc. Se pueden desarrollar aplicaciones de escritorio como aplicaciones web. Empresas como Google, Yahoo, Nasa etc. utilizan este lenguaje para sus desarrollos (actualmente el creador de Python Guido van Rossum trabaja para Google.)
Se puede ejecutar instrucciones de Python desde la línea de comando o creando archivos con extensión *.py. Cuando uno comienza a aprender este lenguaje la línea de comandos nos provee una retroalimentación del resultado en forma inmediata.
El objetivo de este tutorial es presentar en forma progresiva los conceptos fundamentales de este lenguaje y poder analizar los problemas resueltos y codificar los problemas propuestos en este mismo sitio, sin tener que instalar en un principio el Python en su equipo (o luego de instalado poder avanzar con el tutorial en cualquier máquina conectada a internet).
Redefinición de los operadores matemáticos con objetos.

Python nos permite redefinir los operadores matemáticos cuando planteamos una clase.
Los métodos especiales que debemos implementar son los siguientes:
Para el operador +:

__add__(self,objeto2)

Para el operador -:

__sub__(self,objeto2)

Para el operador *:

__mul__(self,objeto2)

Para el operador /:

__div__(self,objeto2)

Veamos con un ejemplo la sintaxis para redefinir el operador +. Crearemos una clase Cliente de un banco y redefiniremos el operador + para que nos retorne la suma de los depósitos de los dos clientes que estamos sumando.
class Cliente:
   def __init__(self,nom,mon):
   self.nombre=nom
   self.monto=mon
   def __add__(self,objeto2):
   s=self.monto+objeto2.monto
   return s
cli1=Cliente('Ana',1200)
cli2=Cliente('Luis',1500)
print 'El total depositado es '
print cli1+cli2

Es muy importante tener en cuenta que debemos redefinir un operador matemático siempre y cuando haga nuestro programa más legible.
Debemos redefinir los operadores +,-,*,/ etc. solo para las clases que con solo leer su nombre el programador intuya que operación implementaría dicho operador.
Redefinición de los operadores relacionales con objetos.

Python también nos permite redefinir los operadores relacionales cuando planteamos una clase.
Los métodos especiales que podemos implementar son los siguientes:
Para el operador ==:

__eq__(self,objeto2)

Para el operador !=:

__ne__(self,objeto2)

Para el operador >:

__gt__(self,objeto2)

Para el operador >=:

__ge__(self,objeto2)

Para el operador <:

__lt__(self,objeto2)

Para el operador <=:

__le__(self,objeto2)

Es importante recordar que una redefinición de un operador tiene sentido si ayuda y hace más claro nuestro algoritmo.
Veamos con un ejemplo la sintaxis para redefinir todos estos operadores relacionales. Crearemos una clase Persona que tiene como atributo el nombre y la edad. El operador == retornará verdadero si las dos personas tienen la misma edad, el operador > retornará True si la edad del objeto de la izquierda tiene una edad mayor a la edad del objeto de la derecha del operador >, y así sucesivamente
class Persona:
   def __init__(self,nom,ed):
   self.nombre=nom
   self.edad=ed
   def __eq__(self,objeto2):
   if self.edad==objeto2.edad:
   return True
   else:
   return False
   def __ne__(self,objeto2):
   if self.edad!=objeto2.edad:
   return True
   else:
   return False
   def __gt__(self,objeto2):
   if self.edad>objeto2.edad:
   return True
   else:
   return False
   def __ge__(self,objeto2):
   if self.edad>=objeto2.edad:
   return True
   else:
   return False
   def __lt__(self,objeto2):
   if self.edad<objeto2.edad:
   return True
   else:
   return False
   def __le__(self,objeto2):
   if self.edad<=objeto2.edad:
   return True
   else:
   return False
per1=Persona('juan',22)
per2=Persona('ana',22)
if per1==per2:
   print 'Las dos personas tienen la misma edad.'
else:
   print 'No tienen la misma edad.'
Como pedemos observar planteamos un método por cada operdor relacional:
def __eq__(self,objeto2):
   if self.edad==objeto2.edad:
   return True
   else:
   return False
El método recibe como referencia (self) la dirección del objeto ubicado a la izquierda del operador relacionar y como parámetro (objeto2) la referencia del objeto ubicado a la derecha del operador. Solo nos queda analizar el atributo edad de cada objeto y retornar True si los dos almacenan el mismo valor, en caso contrario retornar False.