Quelle est la manière correcte et efficace d'implémenter __hash __ ()?

Quelle est la manière correcte et efficace de mettre en œuvre __hash__()?

Je parle de la fonction qui renvoie un hashcode qui est ensuite utilisé pour insérer des objets dans des hashtables aka dictionnaires.

Comme __hash__()renvoie un entier et est utilisé pour "regrouper" des objets dans des tables de hachage, je suppose que les valeurs de l'entier retourné doivent être uniformément distribuées pour les données communes (pour minimiser les collisions). Quelle est une bonne pratique pour obtenir de telles valeurs? Les collisions sont-elles un problème? Dans mon cas, j'ai une petite classe qui agit comme une classe conteneur contenant des entiers, des flotteurs et une chaîne.

Une manière simple et correcte d'implémenter __hash__()consiste à utiliser un tuple clé. Ce ne sera pas aussi rapide qu'un hachage spécialisé, mais si vous en avez besoin, vous devriez probablement implémenter le type en C.

Voici un exemple d'utilisation d'une clé pour le hachage et l'égalité:

class A:
    def __key(self):
        return (self.attr_a, self.attr_b, self.attr_c)

    def __hash__(self):
        return hash(self.__key())

    def __eq__(self, other):
        if isinstance(other, A):
            return self.__key() == other.__key()
        return NotImplemented

En outre, la documentation de__hash__ contient plus d'informations, qui peuvent être utiles dans certaines circonstances.

John Millikin a proposé une solution similaire à celle-ci:

class A(object):

    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c

    def __eq__(self, othr):
        return (isinstance(othr, type(self))
                and (self._a, self._b, self._c) ==
                    (othr._a, othr._b, othr._c))

    def __hash__(self):
        return hash((self._a, self._b, self._c))

Le problème avec cette solution est que le fichier hash(A(a, b, c)) == hash((a, b, c)). En d'autres termes, le hachage entre en collision avec celui du tuple de ses membres clés. Peut-être que cela n'a pas d'importance très souvent dans la pratique?

Mise à jour: la documentation Python recommande désormais d'utiliser un tuple comme dans l'exemple ci-dessus. Notez que la documentation indique

La seule propriété requise est que les objets qui se comparent égaux ont la même valeur de hachage

Notez que l'inverse n'est pas vrai. Les objets qui ne sont pas comparables peuvent avoir la même valeur de hachage. Une telle collision de hachage n'entraînera pas le remplacement d'un objet par un autre lorsqu'il est utilisé comme clé de dict ou élément d'ensemble tant que les objets ne se comparent pas également .

Solution obsolète / mauvaise

La documentation Python sur__hash__ suggère de combiner les hachages des sous-composants en utilisant quelque chose comme XOR , ce qui nous donne ceci:

class B(object):

    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c

    def __eq__(self, othr):
        if isinstance(othr, type(self)):
            return ((self._a, self._b, self._c) ==
                    (othr._a, othr._b, othr._c))
        return NotImplemented

    def __hash__(self):
        return (hash(self._a) ^ hash(self._b) ^ hash(self._c) ^
                hash((self._a, self._b, self._c)))

Mise à jour: comme le souligne Blckknght, changer l'ordre de a, b et c pourrait poser des problèmes. J'ai ajouté un élément supplémentaire ^ hash((self._a, self._b, self._c))pour capturer l'ordre des valeurs hachées. Cette finale ^ hash(...)peut être supprimée si les valeurs combinées ne peuvent pas être réorganisées (par exemple, si elles ont des types différents et par conséquent, la valeur de _ane sera jamais attribuée à _bou _c, etc.).

Paul Larson de Microsoft Research a étudié une grande variété de fonctions de hachage. Il m'a dit que

for c in some_string:
    hash = 101 * hash  +  ord(c)

fonctionnait étonnamment bien pour une grande variété de cordes. J'ai trouvé que des techniques polynomiales similaires fonctionnent bien pour calculer un hachage de sous-champs disparates.

Je peux essayer de répondre à la deuxième partie de votre question.

Les collisions ne résulteront probablement pas du code de hachage lui-même, mais du mappage du code de hachage à un index dans une collection. Ainsi, par exemple, votre fonction de hachage peut renvoyer des valeurs aléatoires de 1 à 10000, mais si votre table de hachage ne contient que 32 entrées, vous obtiendrez des collisions lors de l'insertion.

De plus, je pense que les collisions seraient résolues par la collection en interne, et il existe de nombreuses méthodes pour résoudre les collisions. Le plus simple (et le pire) est, étant donné une entrée à insérer à l'index i, d'ajouter 1 à i jusqu'à ce que vous trouviez un emplacement vide et l'insérez là. La récupération fonctionne alors de la même manière. Cela entraîne des récupérations inefficaces pour certaines entrées, car vous pourriez avoir une entrée qui nécessite de parcourir toute la collection pour la trouver!

D'autres méthodes de résolution de collision réduisent le temps de récupération en déplaçant les entrées dans la table de hachage lorsqu'un élément est inséré pour répartir les choses. Cela augmente le temps d'insertion mais suppose que vous lisez plus que vous n'insérez. Il existe également des méthodes qui essaient de dériver différentes entrées en collision afin que les entrées se regroupent à un endroit particulier.

De plus, si vous avez besoin de redimensionner la collection, vous devrez tout remanier ou utiliser une méthode de hachage dynamique.

En bref, selon ce que vous utilisez pour le code de hachage, vous devrez peut-être implémenter votre propre méthode de résolution de collision. Si vous ne les stockez pas dans une collection, vous pouvez probablement vous en tirer avec une fonction de hachage qui ne génère que des codes de hachage dans une très large plage. Si tel est le cas, vous pouvez vous assurer que votre conteneur est plus grand que nécessaire (le plus gros sera le mieux bien sûr) en fonction de vos problèmes de mémoire.

Voici quelques liens si vous êtes plus intéressé:

hachage coalescent sur wikipedia

Wikipedia propose également un résumé des différentes méthodes de résolution des collisions:

De plus, " File Organization And Processing " de Tharp couvre de nombreuses méthodes de résolution de collision. IMO c'est une excellente référence pour les algorithmes de hachage.

Une très bonne explication sur le moment et la manière d'implémenter la __hash__fonction sur le site Web de programiz :

Juste une capture d'écran pour donner un aperçu: (Récupéré le 13/12/2019)

Quant à une implémentation personnelle de la méthode, le site mentionné ci-dessus fournit un exemple qui correspond à la réponse de millerdev .

class Person:
def __init__(self, age, name):
    self.age = age
    self.name = name

def __eq__(self, other):
    return self.age == other.age and self.name == other.name

def __hash__(self):
    print('The hash is:')
    return hash((self.age, self.name))

person = Person(23, 'Adam')
print(hash(person))

Dépend de la taille de la valeur de hachage que vous renvoyez. Il est logique que si vous avez besoin de renvoyer un int 32 bits basé sur le hachage de quatre ints 32 bits, vous allez avoir des collisions.

Je préférerais les opérations de bits. Comme, le pseudo code C suivant:

int a;
int b;
int c;
int d;
int hash = (a & 0xF000F000) | (b & 0x0F000F00) | (c & 0x00F000F0 | (d & 0x000F000F);

Un tel système pourrait également fonctionner pour les flottants, si vous les preniez simplement comme leur valeur en bits plutôt que de représenter réellement une valeur à virgule flottante, peut-être mieux.

Pour les cordes, j'ai peu / aucune idée.