在 Python 字典中计算碰撞

Question

我第一次在这里发帖，所以希望我以正确的方式提出了我的问题，

将元素添加到 Python 字典后，是否可以让 Python 告诉您添加该元素是否会导致冲突？ （以及在找到放置元素的位置之前，碰撞解决策略探测了多少个位置？）

我的问题是：我在一个更大的项目中使用字典，经过大量分析后，我发现代码中最慢的部分是处理使用字典实现的稀疏距离矩阵。

我使用的键是 Python 对象的 ID，它们是唯一的整数，所以我知道它们都散列到不同的值。但是原则上将它们放入字典仍然可能导致冲突。我不认为字典冲突会拖慢我的程序，但我想从查询中消除它们。

因此，例如，给定以下字典：

d = {}
for i in xrange(15000):
    d[random.randint(15000000, 18000000)] = 0

你能让 Python 告诉你在创建它时发生了多少次冲突吗？

我的实际代码与应用程序纠缠在一起，但上面的代码生成的字典看起来与我正在使用的字典非常相似。

重复一遍：我不认为碰撞会降低我的代码速度，我只是想通过证明我的字典没有太多碰撞来消除这种可能性。

感谢您的帮助。

编辑：一些代码来实现@Winston Ewert 的解决方案：

n = 1500
global collision_count
collision_count = 0

class Foo():

    def __eq__(self, other):
        global collision_count
        collision_count += 1
        return id(self) == id(other)

    def __hash__(self):
        #return id(self) # @John Machin: yes, I know!
        return 1

objects = [Foo() for i in xrange(n)]

d = {}
for o in objects:
    d[o] = 1

print collision_count

请注意，当您在类上定义 __eq__ 时，如果您没有同时定义 __hash__ 函数，Python 会为您提供 TypeError: unhashable instance。

它没有像我预期的那样运行。如果你有__hash__ 函数return 1，那么你会得到大量的冲突，正如预期的那样（在我的系统上，n=1500 有 1125560 次冲突）。但是对于return id(self)，有 0 次冲突。

有人知道为什么说 0 次碰撞吗？

编辑： 我可能已经想通了。

是不是因为 __eq__ 仅在两个对象的 __hash__ 值相同时才被调用，而不是它们的“压缩版本”（如@John Machin 所说）？

Answer 1

这个想法实际上行不通，请参阅问题中的讨论。

快速浏览一下 python 的 C 实现会发现，解决冲突的代码不会计算或存储冲突的数量。

但是，它会在键上调用PyObject_RichCompareBool 以检查它们是否匹配。这意味着每次碰撞都会调用键上的__eq__。

所以：

用定义__eq__ 的对象替换您的键，并在调用时增加一个计数器。由于跳转到 python 进行比较所涉及的开销，这会更慢。但是，它应该让您了解发生了多少次碰撞。

确保你使用不同的对象作为key，否则python会走捷径，因为一个对象总是等于它自己。此外，请确保对象散列到与原始键相同的值。

Answer 2

简答：

您不能通过使用随机整数作为字典键来模拟使用对象 ID 作为字典键。它们具有不同的哈希函数。

确实会发生碰撞。 “拥有独特的事物意味着没有冲突”对于“事物”的几个值是错误的。

您不必担心碰撞。

长答案：

一些解释，来源于reading the source code：

一个 dict 被实现为一个包含 2 ** i 个条目的表，其中 i 是一个整数。

dicts 不超过 2/3。因此，对于 15000 个键，i 必须是 15，而 2 ** i 是 32768。

当 o 是未定义 __hash__() 的类的任意实例时，hash(o) == id(o) 是不正确的。由于地址的低 3 位或 4 位可能为零，因此通过将地址右移 4 位来构造哈希；见source file Objects/object.c，函数_Py_HashPointer

如果低位中有很多零，那将是一个问题，因为要访问大小为 2 ** i（例如 32768）的表，必须对哈希值（通常远大于该值）进行处理以适应，这可以通过获取哈希值的低阶 i（例如 15）位来非常简单快速地完成。

因此碰撞是不可避免的。

不过，这不是恐慌的原因。哈希值的剩余位被考虑到下一次探测的位置的计算中。需要进行第三次等探测的可能性应该很小，特别是因为字典永远不会超过 2/3。计算第一个和后续探针的时隙的廉价成本降低了多个探针的成本。

下面的代码是一个简单的实验，说明了上述大部分讨论。它假定字典在达到其最大大小后随机访问。在 Python2.7.1 中，它显示了 15000 个对象的大约 2000 次碰撞 (13.3%)。

无论如何，底线是您应该真正将注意力转移到其他地方。碰撞不是你的问题，除非你已经为你的对象取得了一些非常不正常的获取内存的方法。你应该看看你是如何使用字典的，例如使用k in d 或try/except，而不是d.has_key(k)。考虑一个作为d[(x, y)] 访问的字典，而不是作为d[x][y] 访问的两个级别。如果您需要这方面的帮助，请提出一个单独的问题。

更新在 Python 2.6 上测试后：

直到 Python 2.7 才引入循环地址​​；请参阅this bug report 进行全面讨论和基准测试。恕我直言，基本结论仍然有效，并且可以通过“如果可以更新”来补充。

>>> n = 15000
>>> i = 0
>>> while 2 ** i / 1.5 < n:
...    i += 1
...
>>> print i, 2 ** i, int(2 ** i / 1.5)
15 32768 21845
>>> probe_mask = 2 ** i - 1
>>> print hex(probe_mask)
0x7fff
>>> class Foo(object):
...     pass
...
>>> olist = [Foo() for j in xrange(n)]
>>> hashes = [hash(o) for o in olist]
>>> print len(set(hashes))
15000
>>> probes = [h & probe_mask for h in hashes]
>>> print len(set(probes))
12997
>>>