Python字典键（类对象）与多个比较器的比较

我使用自定义对象作为python字典中的键。这些对象定义了一些默认的hash和eq方法，这些方法在默认比较中使用 但在某些函数中，我需要使用不同的方法来比较这些对象。 因此，是否有任何方法可以覆盖或传递一个新的比较器，以便仅对该特定函数的这些键进行比较

更新：我的类有以下类型的功能（这里我不能编辑散列方法，它会在其他地方影响很多）

这是正常的功能。但在一个特定的方法中，我想覆盖/或传递一个新的自定义比较器，其中新的哈希代码如下

def  __hash__(self):
    return self.name.lower().__hash__()

因此，我的字典中的

c

返回true

或者

my_dict[c]将返回“obj1”

很抱歉更新了这么多

就像在排序中一样，我们可以将自定义方法作为比较器传递，这里是否有相同的方法

查看您可以在对象中定义的属性

---

根据您想要执行的操作，这可能也很有趣。

实现此功能的唯一方法是使用新的哈希和比较函数创建字典副本。原因是字典需要使用新的散列函数重新散列每个存储的键，以使查找按您的意愿进行。由于无法向字典提供自定义哈希函数（它始终使用其中一个关键对象），因此最好将对象包装为使用自定义哈希和比较函数的类型

class WrapKey(object):
    __init__(self, wrapee):
        self._wrapee = wrapee

    __hash__(self):
        return self._wrapee.name.lower().__hash__()

    __eq__(self, other):
        return self._wrapee.name == other._wrapee.name


def func(d):
    d_copy = dict((WrapKey(key), value) for key, value in d.iteritems())
    # d_copy will now ignore case

---

针对这种情况的小技巧：

class test(object):

    def __init__(self,name,city,hash_func=None):
        self.name=name
        self.city=city
        self.hash_func = hash_func

    def __eq__(self,other):
        return self.__hash__()==other.__hash__()

    def  __hash__(self):
        if self.hash_func is None:
            return self.name.__hash__()
        else:
            return self.hash_func(self)

my_dict={}
a=test("a","city1")
my_dict[a]="obj1"
b=test("a","city2")
print b in my_dict  #prints true
c=test("A","city1")
print c in my_dict  #Prints false
c.hash_func = lambda x: x.name.lower().__hash__()
print c in my_dict #Now it prints true

您不能更改存储在dict中的哈希值，但可以更改用于查找的哈希值。当然，这会导致像这样奇怪的事情

my_dict={}
a=test("a","city1")
my_dict[a]="obj1"
a.hash_func = lambda x: 1
for key in my_dict:
    print key in my_dict # False

---

现在我使用的是以比较器为参数的自定义dict（dict的派生类），我已经覆盖了包含的和getitems（），它们基于比较器进行检查并给出值

步骤：实现自定义密钥类并重写哈希和相等函数

e、 g

主要方法

---

有关完整的详细信息，请参阅链接。

我误读了这个问题（以为是关于排序的）。不过，你能提供一些代码来说明你想要实现什么吗？我只需要在一个函数中使用一个特定的比较器方法。通过排序方式，我的意思是，在排序中，我们可以传递比较器，这可以在检查键的同时完成吗？顺便问一下，你确定要你的

\uuueq\u

-函数来比较哈希吗？散列可能有冲突，因此在某些情况下可能会出现意外行为。我想我在前面的问题中已经很清楚了。更新了代码部分。

my_dict={}
a=test("a","city1")
my_dict[a]="obj1"
a.hash_func = lambda x: 1
for key in my_dict:
    print key in my_dict # False

class CustomDictKey(object):

def __init__(self, 
             param1,
             param2):

            self._param1 = param1
            self._param2 = param2

 # overriding hash and equality function does the trick

def __hash__(self):
    return hash((self._param1,
             self._param2))

def __eq__(self, other):
    return ( ( self._param1,
             self._param2 ) == ( other._param1,
             other._param2) )

def __str__(self):
    return "param 1: {0} param 2: {1}  ".format(self._param1, self._param2)

if name == 'main':

    # create custom key
    k1  = CustomDictKey(10,5)

    k2  = CustomDictKey (2, 4)

    dictionary = {}

    #insert elements in dictionary with custom key
    dictionary[k1] = 10
    dictionary[k2] = 20

    # access dictionary values with custom keys and print values
    print "key: ", k1, "val :", dictionary[k1]
    print "key: ", k2, "val :", dictionary[k2]