__lt__ au lieu de __cmp__

| | | | | | |

Python 2.x a deux façons de surcharger les opérateurs de comparaison, __cmp__ ou les "opérateurs de comparaison riches" tels que __lt__. On dit que les surcharges de comparaison riches sont préférées, mais pourquoi en est-il ainsi ?

Les opérateurs de comparaison riches sont plus simples à implémenter chacun, mais vous devez en implémenter plusieurs avec une logique presque identique . Cependant, si vous pouvez utiliser le cmp intégré et l'ordre des tuples, alors __cmp__ devient assez simple et remplit toutes les comparaisons :

classe A (object): def __init__(self, name, age, other): self.name = name self.age = age self.other = other def __cmp__(self, other): assert isinstance(other, A) # hypothèse pour ceci example return cmp((self.name, self.age, self.other), (other.name, other.age, other.other)) 

Cette simplicité semble répondre à mes besoins bien mieux que de surcharger les 6 (!) Des comparaisons riches. (Cependant, vous pouvez le réduire à "seulement" 4 si vous vous fiez à "l'argument échangé"/au comportement réfléchi, mais cela entraîne une nette augmentation de la complication, à mon humble avis.)

< strong>Y a-t-il des pièges imprévus dont je dois être averti si je ne surcharge que __cmp__ ?

Je comprends le < , <=, ==, etc. les opérateurs peuvent être surchargés à d'autres fins et peuvent renvoyer n'importe quel objet de leur choix. Je ne pose pas de questions sur les mérites de cette approche, mais uniquement sur les différences lors de l'utilisation de ces opérateurs pour des comparaisons dans le même sens qu'ils signifient pour les nombres.

Mise à jour : Comme Christopher indiqué, cmp disparaît en 3.x. Existe-t-il des alternatives qui rendent la mise en œuvre des comparaisons aussi simple que le __cmp__ ci-dessus ?