Y at-il un surcoût important en utilisant différentes versions de sha hachage (module hashlib)

Question

Le module hashlib Python fournit les algorithmes de hachage suivants: constructeurs md5(), sha1(), sha224() , sha256(), sha384() et sha512().

En supposant que je ne veux pas utiliser md5, est-il une grande différence dans l'utilisation, par exemple, SHA1 au lieu de SHA512? Je veux utiliser quelque chose comme hashlib.shaXXX(hashString).hexdigest(), mais comme il est juste pour la mise en cache, je ne suis pas sûr besoin de la charge supplémentaire (éventuelle) de 512 ...

Est-ce que les frais généraux existent, et si oui, quelle est sa taille?

Answer 1

Pourquoi ne pas simplement référence il?

>>> def sha1(s):
...     return hashlib.sha1(s).hexdigest()
...
>>> def sha512(s):
...     return hashlib.sha512(s).hexdigest()
...
>>> t1 = timeit.Timer("sha1('asdf' * 100)", "from __main__ import sha1")
>>> t512 = timeit.Timer("sha512('asdf' * 100)", "from __main__ import sha512")
>>> t1.timeit()
3.2463729381561279
>>> t512.timeit()
6.5079669952392578

sur ma machine, hash512 est deux fois plus lent que sha1. Mais comme GREGS dit, pourquoi voudriez-vous utiliser hachage sécurisé pour la mise en cache? Essayez les algorithmes de hachage BUILTIN qui devrait être très rapide et à l'écoute:

>>> s = "asdf"
>>> hash(s)
-618826466
>>> s = "xxx"
>>> hash(s)
943435
>>> hash("xxx")
943435

Ou mieux encore, utilisez les dictionnaires Python intégré. Peut-être que vous pouvez nous en dire plus sur ce que vous envisagez de mise en cache.

EDIT: Je pense que vous essayez d'atteindre quelque chose comme ceci:

hash = hashlib.sha1(object_to_cache_as_string).hexdigest()
cache[hash] = object_to_cache

Ce que je refferring par « utiliser les dictinoaries Python builtin » est que vous pouvez simplifier ci-dessus:

cache[object_to_cache_as_string] = object_to_cache

De cette façon, Python prend en charge le hachage de sorte que vous n'avez pas!

En ce qui concerne votre problème, vous pouvez consulter Python hashable dicts afin de faire un dictionnaire hashable . Ensuite, tout ce que vous aurez besoin de faire pour mettre en cache l'objet est:

cache[object_to_cache] = object_to_cache

Answer 2

Peut-être un test naïf ... mais il semble que cela dépend de combien vous hachant. 2 blocs de SHA512 est plus rapide que 4 blocs de SHA256?

>>> import timeit
>>> import hashlib
>>> for sha in [ x for x in dir(hashlib) if x.startswith('sha') ]:
...   t = timeit.Timer("hashlib.%s(data).hexdigest()" % sha,"import hashlib; data=open('/dev/urandom','r').read(1024)")
...   print sha + "\t" + repr(t.timeit(1000))
...
sha1    0.0084478855133056641
sha224  0.034898042678833008
sha256  0.034902095794677734
sha384  0.01980900764465332
sha512  0.019846916198730469