¿Hay una sobrecarga significativa mediante el uso de diferentes versiones de hashing sha (módulo hashlib)

Question

El hashlib Python módulo proporciona los siguientes algoritmos de hash constructores: md5(), sha1(), sha224() , sha256(), sha384() y sha512().

Suponiendo que no quiero utilizar MD5, es que hay una gran diferencia en el uso de, por ejemplo, en lugar de sha1 sha512? Quiero usar algo como hashlib.shaXXX(hashString).hexdigest(), pero ya que es sólo para el almacenamiento en caché, no estoy seguro de que necesito la (eventual) sobrecarga adicional de 512 ...

¿Existe esta sobrecarga, y si es así, cómo es de grande?

Answer 1

¿Por qué no se referencia?

>>> 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

Así que en mi máquina, hash512 es dos veces tan lento como sha1. Pero a medida que gregs dice, ¿para qué usar hash seguro para almacenar en caché? Pruebe los algoritmos hash incorporadas, que sean realmente rápido y afinado:

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

O mejor aún, usar los diccionarios de Python incorporada. Tal vez usted puede decirnos más sobre lo que planea en el almacenamiento en caché.

EDIT: Estoy pensando que usted está tratando de lograr algo como esto:

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

Lo que estaba a refferring por "utilizar los dictinoaries Python incorporadas" es que se puede simplificar la anterior:

cache[object_to_cache_as_string] = object_to_cache

De este modo, Python se encarga del hash para que no tenga que hacerlo!

En cuanto a su problema particular, se puede hacer referencia a Python hashable predice con el fin de hacer un diccionario hashable . Entonces, todo lo que tenía que hacer para almacenar en caché el objeto es:

cache[object_to_cache] = object_to_cache

Answer 2

Tal vez una prueba ingenua ... pero parece que depende de cuánto está hash. 2 bloques de sha512 es más rápido que los 4 bloques 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