class et set-Problème technique

Bonjour,
voici un code qui me pose problème.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#! /usr/bin/env python3   class bidon(): def __init__(self, a): self.a = a   def __eq__(self, oneObject): if isinstance(oneObject, bidon): return self.a == oneObject.a   return a == oneObject   a = bidon('r') b = bidon('r')   print(a == b)   oneList = [a, b]   print(set(oneList))

---

Ce code me renvoie l'erreur suivante :

Code:

---

1 2 3 4 5 6

True Traceback (most recent call last): File "/Users/.../pitfall/set.py", line 20, in <module> print(set(oneList)) TypeError: unhashable type: 'bidon'

---

Tout vient de ma redéfinition de la méthode spéciale __eq__.

Que faire ?

Un coup de Google m'a donné le lien suivant : voir ceci.

Il faut en fait toujours redéfinir la méthode spéciale __hash__ en parallèle de __eq__ sous Python 3. Le code suivant fonctionne :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

#! /usr/bin/env python3   class bidon(): def __init__(self, a): self.a = a   def __eq__(self, oneObject): if isinstance(oneObject, bidon): return self.a == oneObject.a   return a == oneObject   # If the following method is missing, there is a problem. def __hash__(self): return id(self)   a = bidon('r') b = bidon('r')   print(a == b)   oneList = [a, b]   print(set(oneList))

---

Ceci étant, quelles règles faut-il suivre pour la valeur que __hash__ renvoie ?

Peut-on dire que cette valeur est un identifiant attaché à l'instance de la classe ? Dans ce cas, vous parait-il correct, dans le cas de mon exemple bidon, que le "hash" soit directement obtenu à partir de celle de a, ou suis-je en train de faire un raisonnement fumeux (désolé pour ce mauvais jeu de mots) ?

Enfin, Python donne-t-il des outils qui construisent un hash à partir de données comme par exemples des nombres, des chaînes, des listes ?..

Salut,

Citation:

---

Envoyé par rambc

Ceci étant, quelles règles faut-il suivre pour la valeur que __hash__ renvoie ?

---

la documentation dit:

Citation:

---

Called by built-in function hash() and for operations on members of hashed collections including set, frozenset, and dict. __hash__() should return an integer. The only required property is that objects which compare equal have the same hash value; it is advised to somehow mix together (e.g. using exclusive or) the hash values for the components of the object that also play a part in comparison of objects

---

Si on part de sont égaux si "self.a == oneObject.a"... Deux instances pourront être égales (égalité de l'attribut "a") sans pour autant être identiques (même id)
- W.

Merci.

Du coup, si je veux que deux instances d'objets identiques, c'est un peu compliqué. Par objet, j'entends par là des classes dont seuls les attributs m'intéressent. Voici un exemple.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

#! /usr/bin/env python3   class bidon(): def __init__(self, a, l): self.a = a self.l = l   def __eq__(self, oneObject): if isinstance(oneObject, bidon): return (self.a == oneObject.a \ and self.l == oneObject.l)   return a == oneObject   # Que faire ici ???? def __hash__(self): # Méthode à la c-- mais qui montre la difficulté return id([self.a] + self.l)   a = bidon('r', [1, 2]) b = bidon('r', [1, 2])   print(a == b)   oneList = [a, b]   print(set(oneList))

---

J'aimerais que a et b soient identiques et non simplement égaux. Quelles sont les techniques à utiliser dans ce genre de situation ?

Merci.

Du coup, si je veux deux instances d'objets identiques, c'est un peu compliqué. Par objet, j'entends des classes dont seuls les attributs m'intéressent. Voici un exemple.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

#! /usr/bin/env python3   class bidon(): def __init__(self, a, l): self.a = a self.l = l   def __eq__(self, oneObject): if isinstance(oneObject, bidon): return (self.a == oneObject.a \ and self.l == oneObject.l)   return a == oneObject   # Que faire ici ???? def __hash__(self): # Méthode à la c-- mais qui montre la difficulté return id([self.a] + self.l)   a = bidon('r', [1, 2]) b = bidon('r', [1, 2])   print(a == b)   oneList = [a, b]   print(set(oneList))

---

Ceci renvoie:

Code:

---

1 2 3

True {<__main__.bidon object at 0x532490>, <__main__.bidon object at 0x532550>}

---

J'aimerais que a et b soient identiques et non simplement égaux. Quelles sont les techniques à utiliser dans ce genre de situation ?

Citation:

---

J'aimerais que a et b soient identiques et non simplement égaux. Quelles sont les techniques à utiliser dans ce genre de situation ?

---

Ben çà dépend.
La fonction de hash permettra de mettre l'ensemble des instances dans un dict et d'écrire un __new__ qui retournera une instance déjà crée si nécessaire. On réalise là une sorte de table de base de donnée en mémoire: un certain nombre d'attributs servant de clé...
Si les objets sont "simples" - string, entier,... - cela revient à appliquer la fonction de hash sur l'ensemble des valeurs.
Si les objets sont composites - plusieurs attributs simples ou pas - on peut s'y ramener en sérialisant via pickle par exemple et en construisant la fonction de hash sur cette représentation.
Mais la clé est sur l'ensemble des....
=> créer un nouvel objet dès qu'un des attributs est modifié.
Ce qui rend cette option difficilement applicable dès qu'on a beaucoup d'attributs.
- W

J'arrive plus à te suivre... :calim2:

Aurais-tu un mini exemple ? :)

voir la discussion
- W.

Merci.

Je regarde cela et je propose ensuite une réponse ici.

Comme l'a cité wiztricks: The only required property is that objects which compare equal have the same hash value.
Autrement dit, __hash__ doit renvoyer la même valeur si __eq__ retourne True, mais on ne dit rien sur ce qui doit être renvoyé pour des objets différents.

Donc en fait, cette implémentation est toujours valable (mais inefficace):

Code:

---

1 2	def __hash__(self): return 0

---

Dans ton exemple tu pourrais définir hash comme ceci:

Code:

---

1 2	def __hash__(self): return hash(self.a) ^ hash(self.l)

---

Mais cela ne fonctionne pas car self.l est une liste et que seuls les objets immutables sont hashables.
Le mieux a faire dans ton cas est sans doute de remplacer la liste par un tuple, qui lui est hashable.
Il est très dangereux de définir une méthode __hash__ sur des objets mutables.

Un peu compliqué tout ceci. Pour le tuple, cela ne sera pas possible. Il est vrai que tu pointes un souci. Tout ceci commence à se clarifier.

Je vais en fait laisser ceci en suspens pour le moment. J'ai même retiré la ligne où j'utilisais set dans mon programme. Je ferais sans.