Bonjour
 
D'après le livre de gérard swinen l'opérateur de comparaison == regarde si les deux variables pointent sur le même objet.
Par exemple:

 
J'aimerai savoir comment est ce que l'on compare la valeur de deux objets.
En gros je recherche l'équivalent de la méthode equals() en java.
 
Merci d'avance de votre aide .

Python a tout un jeu de "méthodes magiques" qui fournissent des hooks pour ce genre de trucs.

Tu peux les trouver dans la doc, reference > Data Model > Special Method Names

Pour l'égalité, tu veux soit __eq__

>>> class Test(object):
    def __init__(self, value):
        self.v = value
    def __eq__(self, other):
        return self.v == other.v
 
    
>>> x = Test(0)
>>> y = Test(0)
>>> x == y
True
>>> x is y
False
>>>

soit __cmp__

>>> class Test(object):
    def __init__(self, value):
        self.v = value
    def __cmp__(self, other):
        return cmp(self.v, other.v)
 
    
>>> x = Test(0)
>>> y = Test(0)
>>> x == y
True
>>> x is y
False
>>>

note: en Python, "==" teste l'égalité, pas l'idéntité (testée avec l'opérateur "is" ). C'est juste que par défaut Python définit l'égalité comme étant l'identité s'il n'a pas plus d'infos

>>> class Test(object):
    def __init__(self, value):
        self.v = value
    def __eq__(self, other):
        return self.v == other.v
 
    
>>> x = Test(0)
>>> y = Test(0)
>>> x == y
True
>>> x is y
False
>>>

>>> class Test(object):
    def __init__(self, value):
        self.v = value
    def __cmp__(self, other):
        return cmp(self.v, other.v)
 
    
>>> x = Test(0)
>>> y = Test(0)
>>> x == y
True
>>> x is y
False
>>>

 
Merci beaucoup voila une info super utile que je ne trouvais pas ailleurs     .
 
Sinon tant que tu est la faut-il privilégier une des deux méthodes? Ou il n'y a aucune différence?
 
 
 

Dans ton cas, si tu as juste besoin de l'égalité donc j'aurais tendance à juste implémenter __eq__, pas besoin de s'embêter avec __cmp__ (autrement plus complexe)

Au fait est-ce que tu saurai si lorsque je crée deux objets identiques la référence aux deux objets ne sera pas la même?
Car en java la machine virtuelle optimise la chose ne créant qu'un objet pour deux variables identique.
 
Or je travaille sur un programme qui va me créer des objets pointant sur d'autres qui eux même pointent sur d'autre objets qui repointent sur les premiers.
Ca va me créer en une sorte de graphe très complexe (Un MCD représenté en objet).
 
Donc créer une méthode __eq__() sur des objets de se type est très complexe (Il faut grosso modo comparer deux graphes).
La plupart du temps je n'ai besoin de savoir que si deux variables pointent sur le même objet. Il ne faudrait pas que l'opérateur "is" soit mis en défaut par la machine virtuelle.  

Non. Si tu crées deux objets identiques, tu obtiens en Python deux instances différentes dans deux variables distinctes. Tu peux d'ailleurs le vérifier en allant modifier un des deux objets.
Maintenant, je présume que ton objet contient lui-même des objets plus simple. Ben faut que tu implémentes une méthode "eq" sur chaque objet simple. Puis tu implémentera la méthode "eq" de l'objet complexe en comparant chaque objet simple.
Exemple => un programme qui crée deux rectangles et qui les compare

#!/usr/bin/env python
# coding: Latin-1 -*-
 
class cPoint:
    "Point mathématique"
 
    def __init__(self, x=0, y=0):
        self.x=x;
        self.y=y;
    def __eq__ (self, other):
        return self.x == other.x and self.y == other.y
 
class cRectangle:
    "Rectangle"
    def __init__(self, l, L):
        self.l=l
        self.L=L
        self.coin=[]
        self.coin.append(cPoint(0, 0))
        self.coin.append(cPoint(0, L))
        self.coin.append(cPoint(l, L))
        self.coin.append(cPoint(l, 0))
 
    def __eq__(self, other):
        for i in range(4):
            if not self.coin[i] == other.coin[i]: return False
        return True 
  
a=cRectangle(20, 10)
b=cRectangle(20, 10)
print a == b

 
Petite remarque => j'ai été obligé d'utiliser "not ==" car je n'avais pas redéfini l'opérateur "!=" pour la classe cPoint...

Je sais pas où t'as vu jouer ça, mais c'est n'importe quoi.
 
Même pour les chaînes de caractères, c'est pas nécessairement le cas, alors avec les objets userland...

Faut implementer __eq__ récursivement

 
Ok merci

"récursivement" n'est pas vraiment le terme adéquat. Faut implémenter un "__eq__" qui va comparer chaque sous-objet, charge au programmeur du sous-objet d'implémenter son propre "__eq__"...

 
Ouais sauf que quand t'as un objet "object1" qui à un sous-objet "object2" qui a un sous-objet "object3" qui, lui même, à un sous objet "object1".
Bah ça boucle.

En effet, c'est une sale boucle. Mais on en est à comparer deux objets de type "object1". Donc comment envisagerais-tu de comparer deux objets "object1" définis comme ci-dessus ?
Si t'arrives pas à envisager cette comparaison avec des mots (des dessins, des schémas) tu pourras jamais le programmer en Python.  Et si tu trouves un raisonnement qui te permette de comparer ces deux objets, alors tu pourras adapter ce raisonnement à Python.
 
Quoi qu'il en soit, un objet tel que décrit ci-dessus est très difficile à traiter quel que soit le traitement que tu voudras y faire... mais la base de la comparaison sera quand-même d'implémenter un "__eq__" sur chaque objectX. Charge à toi de t'arranger pour que le "__eq__" s'arrête quand il faut.