什么是正确和好的实施方式__hash__()？

我在谈论返回哈希码的函数,该哈希码随后用于将对象插入哈希表,即字典.

当__hash__()返回一个整数并用于将对象"分箱"为哈希表时,我假设返回的整数的值应该为公共数据均匀分布(以最小化冲突).获得这些价值观的好习惯是什么？碰撞是一个问题吗？在我的例子中,我有一个小类,它充当一个容器类,包含一些int,一些浮点数和一个字符串.

我已经在python 3.3中实现了BloomFilter,并且每次会话都得到了不同的结果.深入研究这种奇怪的行为让我进入了内部的hash()函数 - 它为每个会话返回相同字符串的不同哈希值.

例:

>>> hash("235")
-310569535015251310

-----打开一个新的python控制台-----

>>> hash("235")
-1900164331622581997

为什么会这样？为什么这有用？

我相信hash()所有python解释器中的函数都是一样的.但是当我使用python for android在我的手机上运行它时它会有所不同.我得到哈希字符串和数字的哈希值相同,但是当我对内置数据类型进行哈希时,哈希值会有所不同.

PC Python解释器(Python 2.7.3)

>>> hash(int)
31585118
>>> hash("hello sl4a")
1532079858
>>> hash(101)
101

移动Python解释器(Python 2.6.2)

>>> hash(int)
-2146549248
>>> hash("hello sl4a")
1532079858
>>> hash(101)
101

任何人都可以告诉我这是一个错误还是我误解了一些东西.

的hashlibPython模块提供了以下的散列算法的构造:md5(),sha1(),sha224(),sha256(),sha384(),和sha512().

假设我不想使用md5,那么使用sha1而不是sha512会有很大的不同吗？我想使用类似的东西hashlib.shaXXX(hashString).hexdigest(),但因为它只是用于缓存,我不确定我需要(最终)额外的512开销......

是否存在这种开销,如果存在,它有多大？

我定义了一个类:

class A:
    ''' hash test class
    >>> a = A(9, 1196833379, 1, 1773396906)
    >>> hash(a)
    -340004569

    This is weird, 12544897317L expected.
    '''
    def __init__(self, a, b, c, d):
        self.a = a
        self.b = b
        self.c = c
        self.d = d

    def __hash__(self):
        return self.a * self.b + self.c * self.d

为什么在doctest中,hash()函数给出一个负整数？

在LDA模型中，每次我在同一个语料库上进行训练时，都会生成不同的主题，通过设置np.random.seed(0)，LDA模型将始终以完全相同的方式进行初始化和训练。

来自的Word2Vec模型是否相同gensim？通过将随机种子设置为常数，在同一数据集上运行的不同样本会产生相同的模型吗？

但是奇怪的是，它已经在不同情况下为我提供了相同的矢量。

>>> from nltk.corpus import brown
>>> from gensim.models import Word2Vec
>>> sentences = brown.sents()[:100]
>>> model = Word2Vec(sentences, size=10, window=5, min_count=5, workers=4)
>>> model[word0]
array([ 0.04985042,  0.02882229, -0.03625415, -0.03165979,  0.06049283,
        0.01207791,  0.04722737,  0.01984878, -0.03026265,  0.04485954], dtype=float32)
>>> model = Word2Vec(sentences, size=10, window=5, min_count=5, workers=4)
>>> model[word0]
array([ 0.04985042,  0.02882229, -0.03625415, -0.03165979,  0.06049283,
        0.01207791,  0.04722737,  0.01984878, -0.03026265,  0.04485954], dtype=float32)
>>> model = Word2Vec(sentences, size=20, window=5, min_count=5, workers=4)
>>> model[word0]
array([ 0.02596745,  0.01475067, …

我正在编写一个持久化到磁盘的映射类。我目前只允许使用str键，但如果我可以使用更多类型，那就太好了：希望可以达到任何可散列的类型（即与 builtin 相同的要求dict），但更合理的是我会接受 string、unicode、int 和这些类型的元组。

为此，我想推导出一个确定性的序列化方案。

选项 1 - 酸洗密钥

我的第一个想法是使用 pickle（或 cPickle）模块来序列化密钥，但我注意到来自pickle和的输出cPickle彼此不匹配：

>>> import pickle
>>> import cPickle
>>> def dumps(x):
...     print repr(pickle.dumps(x))
...     print repr(cPickle.dumps(x))
... 
>>> dumps(1)
'I1\n.'
'I1\n.'
>>> dumps('hello')
"S'hello'\np0\n."
"S'hello'\np1\n."
>>> dumps((1, 2, 'hello'))
"(I1\nI2\nS'hello'\np0\ntp1\n."
"(I1\nI2\nS'hello'\np1\ntp2\n."

是否有任何实现/协议组合pickle对于某些类型集是确定性的（例如只能cPickle与协议 0 一起使用）？

选项 2 - Repr 和 ast.literal_eval

另一种选择是用于repr转储和ast.literal_eval加载。我编写了一个函数来确定给定的键是否可以在这个过程中存活（它允许的类型相当保守）：

def is_reprable_key(key):
    return type(key) in (int, str, unicode) or (type(key) == …

理想情况下,14个字符？或者,无论有效.