Existe uma sobrecarga significativa usando diferentes versões de hashing sha (módulo hashlib)

Question

O hashlib Python módulo fornece os seguintes algoritmos de hash construtores: md5(), sha1(), sha224() , sha256(), sha384() e sha512().

Supondo que eu não quero usar md5, há uma grande diferença no uso, digamos, SHA1, em vez de sha512? Eu quero usar algo como hashlib.shaXXX(hashString).hexdigest(), mas como é apenas para cache, eu não tenho certeza se eu precisar do (eventual) sobrecarga extra de 512 ...

Será que isso existe em cima, e se assim for, quão grande é isso?

Answer 1

Por que não apenas referência-lo?

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

Então, na minha máquina, hash512 é duas vezes mais lento como sha1. Mas, como Gregs disse, por que você usaria de hash seguro para armazenamento em cache? Experimente os algoritmos de hash builtin que deve ser muito rápido e afinado:

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

Ou melhor ainda, usar o builtin dicionários Python. Talvez você pode nos dizer mais sobre o que você está pensando em cache.

EDIT: Eu estou pensando que você está tentando alcançar algo como isto:

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

O que eu estava refferring a por "usar o builtin dictinoaries Python" é que você pode simplificar o acima:

cache[object_to_cache_as_string] = object_to_cache

Desta forma, Python cuida do hashing para que você não precisa!

No que diz respeito o seu problema particular, você pode se referir a Python Hashable dicts , a fim de fazer uma Hashable dicionário . Então, tudo o que você precisa fazer para armazenar em cache o objeto é:

cache[object_to_cache] = object_to_cache

Answer 2

Talvez um teste ingênuo ... mas parece que isso depende de quanto você está hashing. 2 blocos de sha512 é mais rápido do que 4 blocos 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