Skip to main content
 首页 » 编程设计

Python __hash__ : identity vs. 等价

2024年11月01日9xxx_UU

我有一个类,其实例要通过不同于它们携带的数据值的标识来区分。在我的代码中,我打算使用 == 来表示两个实例在它们的数据方面是等价的,并且 is 表示两个变量引用同一个实例,也就是说,他们是相同的。根据我的理解,这一切都很正常。

此外,我想在 set 中使用实例(等效或不等效),并作为 dict 中的键。这需要为类定义 __hash__ 函数。

但是在这方面我不明白__hash__的文档要求:

The only required property is that objects which compare equal have the same hash value.

这是否意味着两个不同但等价的对象不能用作 dict 中的不同键,或单独出现在 set 中? 在下面的代码中,我通过覆盖 __eq__ 和 __hash__ 来打破这一要求,以反射(reflect)我的预期用途。它在 Python 2.7 和 3.7 中按预期工作。

如我在此处所做的那样,违反 __hash__ 的要求会产生哪些负面后果?

有没有更好的方法来实现我的目标?

class A( object ): 
        def __init__( self, v1, v2 ): 
                self.v = ( v1, v2 ) 
 
        def __eq__( self, b ): 
                return self.v[0] == b.v[0] and self.v[1] == b.v[1] 
 
        def __hash__( self ): 
                return id( self ) 
 
        def __str__( self ): 
                return str( self.v ) 
 
p = A( 1, 0 ) 
q = A( 1, 0 ) 
 
print( str( p ), str( q ) ) 
print( "identical?", p is q ) 
print( "equivalent?", p == q ) 
print( "hashes", hash(p), hash(q) ) 
 
s = set( [p, q] ) 
print( "set length", len( s ) ) 
print( "both in set?", p in s, q in s ) 
 
d = { p:3, q:4 } 
print( "dict length", len( d ) ) 
print( "as distinct keys", d[p], d[q] ) 

请您参考如下方法:

The only required property is that objects which compare equal have the same hash value.

规范文本中的“比较相等”表示它们的 __eq__ 方法的结果 - 不要求它们是同一对象。

__hash__ 认为,必须基于 __eq__ 中使用的值,而不是对象的“id”——这部分在您的代码中不正确.为了让它工作,它必须是这样的:

只是做:

      ... 
      def __eq__( self, b ): 
           return self.v[0] == b.v[0] and self.v[1] == b.v[1] 
 
      def __hash__( self ): 
           return hash((self.v[0], self.v[1])) 

Does that mean that two distinct but equivalent objects cannot be used as different keys in a dict, or appear individually in a set?

是的。这就是规范的意思。

解决方法是为您的类保留默认的 __eq__ 实现以符合规则,并实现您必须在代码中使用的替代形式的比较。

最直接的方法就是保留 __eq__ 的默认实现,它按身份进行比较,并有一个任意的方法用于比较,(语言中编码的习语不支持运算符覆盖的必须无论如何使用):

class A( object ): 
    ... 
    def equals( self, b ): 
       return self.v[0] == b.v[0] and self.v[1] == b.v[1] 
 
p = A( 1, 0 ) 
q = A( 1, 0 ) 
 
print( str( p ), str( q ) ) 
print( "identical?", p is q ) 
print( "equivalent?", p.equals(q) ) 

有一些方法可以对此进行一些改进 - 但基线是:__eq__ 必须符合规则,并进行身份比较。

一种方法是使用一个内部关联对象作为“命名空间”,您可以将其用于比较:

class CompareSpace: 
    def __init__(self, parent): 
        self.parent = parent 
 
        def __eq__( self, other ): 
            other = other.parent if isinstance(other, type(self)) else other  
            return self.parent.v[0] == other.v[0] and other.v[1] == b.parent.v[1] 
 
 
    class A: 
        def __init__( self, v1, v2 ): 
            self.v = ( v1, v2 ) 
            self.comp = CompareSpace(self) 
 
        def __str__( self ): 
            return str( self.v ) 
 
p = A( 1, 0 ) 
q = A( 1, 0 ) 
 
print( str( p ), str( q ) ) 
print( "identical?", p is q ) 
print( "equivalent?", p.comp == q ) 
print( "hashes", hash(p), hash(q) ) 

splinter 的示范

现在我将插入一个例子来说明这是如何中断的——我正在故意创建一个更加中断的类,以确保在第一次尝试时出现问题。但是,即使每 200 万次出现一次问题,您的代码仍然会太破烂,无法用于任何实际应用,即使是个人代码:您将拥有一个不确定的字典:

 
class Broken: 
    def __init__(self, name): 
        self.name = name 
    def __hash__(self): 
        return id(self) % 256 
    def __eq__(self, other): 
        return True 
    def __repr__(self): 
        return self.name 
 
 
In [23]: objs = [Broken(f"{i:02d}") for i in range(64)]                                         
 
In [24]: print(objs)                                                                            
[00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63] 
 
In [25]: test = {}                                                                              
 
In [26]: for obj in objs:  
    ...:     if obj not in test:  
    ...:         test[obj] = 0  
    ...:                                                                                        
 
In [27]: print(test)                                                                            
{00: 0, 01: 0, 02: 0, 11: 0} 
 
# Or with simple, unconditional, insertion: 
In [29]: test = {obj: i for i, obj in enumerate(objs)}                                          
 
In [30]: test                                                                                   
Out[30]: {00: 57, 01: 62, 02: 63, 11: 60} 

(我重复一遍,虽然你的 has 值本身不会冲突,但内部字典代码必须将哈希中的数字减少到其哈希表中的索引 - 不一定按模块(%) - 否则每个空字典将需要 2 ** 64 个空条目,并且仅当所有哈希仅为 64 位宽时)