Điều gì làm cho lớp do người dùng định nghĩa không thể thực hiện được?

Question

docs nói rằng một lớp có thể băm miễn là nó xác định phương pháp __hash__ và phương pháp __eq__. Tuy nhiên:

class X(list): 
    # read-only interface of `tuple` and `list` should be the same, so reuse tuple.__hash__ 
    __hash__ = tuple.__hash__ 

x1 = X() 
s = {x1} # TypeError: unhashable type: 'X' 

Điều gì làm cho X không thể hoạt động?

Lưu ý rằng tôi phải có danh sách giống hệt nhau (về mặt bình đẳng) để được băm với cùng một giá trị; nếu không, tôi sẽ violate this requirement trên hàm băm:

Thuộc tính yêu cầu duy nhất là đối tượng mà so sánh tương đương có giá trị băm cùng

Các tài liệu làm cảnh báo rằng một đối tượng hashable không nên được sửa đổi trong suốt cuộc đời của nó, và tất nhiên tôi không sửa đổi các trường hợp của X sau khi tạo. Tất nhiên, thông dịch viên sẽ không kiểm tra điều đó.

Answer 1

Chỉ cần đặt phương thức __hash__ thành phương thức của lớp tuple là không đủ. Bạn đã không thực sự nói với nó làm thế nào để băm khác nhau. tuples có thể băm vì chúng không thay đổi được. Nếu bạn thực sự muốn làm cho bạn làm ví dụ cụ thể, có thể là như sau:

class X2(list): 
    def __hash__(self): 
     return hash(tuple(self)) 

Trong trường hợp này, bạn thực sự xác định cách băm lớp con danh sách tùy chỉnh của mình. Bạn chỉ cần xác định chính xác cách nó có thể tạo ra một băm. Bạn có thể băm vào bất cứ điều gì bạn muốn, như trái ngược với sử dụng phương pháp băm của tuple:

def __hash__(self): 
    return hash("foobar"*len(self)) 

Answer 2

Nếu bạn không sửa đổi các trường hợp X sau khi tạo, tại sao không phải là bạn subclassing tuple?

Nhưng tôi sẽ chỉ ra rằng điều này thực sự không gây ra lỗi, ít nhất là trong Python 2.6.

>>> class X(list): 
...  __hash__ = tuple.__hash__ 
...  __eq__ = tuple.__eq__ 
... 
>>> x = X() 
>>> s = set((x,)) 
>>> s 
set([[]]) 

Tôi ngần ngại nói "hoạt động" vì điều này không làm những gì bạn nghĩ.

>>> a = X() 
>>> b = X((5,)) 
>>> hash(a) 
4299954584 
>>> hash(b) 
4299954672 
>>> id(a) 
4299954584 
>>> id(b) 
4299954672 

Chỉ sử dụng id đối tượng làm băm. Khi bạn thực sự gọi __hash__ bạn vẫn gặp lỗi; tương tự cho __eq__.

>>> a.__hash__() 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: descriptor '__hash__' for 'tuple' objects doesn't apply to 'X' object 
>>> X().__eq__(X()) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: descriptor '__eq__' for 'tuple' objects doesn't apply to 'X' object 

Tôi tập hợp mà các internals python, đối với một số lý do, được phát hiện X có __hash__ và một phương pháp __eq__, nhưng không gọi họ.

Đạo đức của tất cả điều này là: chỉ cần viết hàm băm thực. Vì đây là một đối tượng chuỗi, chuyển đổi nó thành một tuple và băm là cách tiếp cận rõ ràng nhất.

def __hash__(self): 
    return hash(tuple(self)) 

Answer 3

gì bạn có thể và nên làm, dựa trên câu hỏi khác của bạn, là: không phân lớp bất cứ điều gì, chỉ cần gói gọn một tuple. Nó hoàn toàn tốt để làm như vậy trong init.

class X(object): 
    def __init__(self, *args): 
     self.tpl = args 
    def __hash__(self): 
     return hash(self.tpl) 
    def __eq__(self, other): 
     return self.tpl == other 
    def __repr__(self): 
     return repr(self.tpl) 

x1 = X() 
s = {x1} 

trong đó sản lượng:

>>> s 
set([()]) 
>>> x1 
() 

Answer 4

Từ các tài liệu Python3:

Nếu một lớp không định nghĩa một phương pháp __eq __() nó không nên xác định một hoạt động __hash __() hoặc ; nếu nó định nghĩa __eq __() nhưng không __hash __(), các cá thể của nó sẽ không thể sử dụng được dưới dạng các mục trong các bộ sưu tập có thể băm. Nếu một lớp xác định các đối tượng có thể thay đổi và thực hiện phương thức __eq __(), nó sẽ không triển khai __hash __(), vì việc triển khai các bộ sưu tập có thể băm yêu cầu giá trị băm của một khóa là là không thay đổi (nếu giá trị băm của đối tượng thay đổi. nhóm băm sai).

Ref: object.__hash__(self)

Mẫu mã:

class Hashable: 
    pass 

class Unhashable: 
    def __eq__(self, other): 
     return (self == other) 

class HashableAgain: 
    def __eq__(self, other): 
     return (self == other) 

    def __hash__(self): 
     return id(self) 

def main(): 
    # OK 
    print(hash(Hashable())) 
    # Throws: TypeError("unhashable type: 'X'",) 
    print(hash(Unhashable())) 
    # OK 
    print(hash(HashableAgain()))