In Python, custom classes need to implement __eq__ and __hash__ to support instances as dictionary keys or collection elements. 1.__eq__ is used to determine whether the objects are equal, and __hash__ returns an integer hash value for the hash table structure; 2. Both must be implemented based on the same attributes to maintain consistency; 3. Use __hash__ with mutable objects to avoid the inability to locate the object after modifying the attributes; 4. When only __eq__ is implemented without __hash__ __hash__ is not defined, the instance cannot be used as a dictionary key or collection element; 5. Python 3.7's dataclass can automatically generate these two methods through @dataclass(eq=True). Correct implementation ensures that instances with the same content are judged to be equal and have the same hash value, thus working properly in sets and dictionaries.

In Python, when you customize a class and want an instance of this class to be stored as a dictionary key or in a collection, you need to consider implementing the two methods __eq__ and __hash__ . They have a close relationship, and using it incorrectly may lead to unexpected problems.

When should __eq__ and __hash__ be used

If your class instances are used to compare (such as judging whether they are equal), or if you want to put them into data structures like set or dict , you must pay attention to these two methods.

• __eq__ controls whether two objects are "equal".
• __hash__ returns an integer hash value of the object, used to quickly identify objects, especially in hash table structures (such as dictionaries and collections).

If these two methods are not overridden, the default behavior is based on the object's identity (id), that is, two different instances will not be considered the same even if the content is the same.

How to correctly implement __eq__ and __hash__

To ensure consistency, these two methods should be implemented based on the same properties. That is, if __eq__ compares a.name and a.age , then __hash__ should also use these two fields to calculate the hash value.

For example:

 class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, other):
        If not isinstance(other, Person):
            return False
        return self.name == other.name and self.age == other.age

    def __hash__(self):
        return hash((self.name, self.age))

The benefits of doing this are:

• Two Person instances with the same name and age will be considered equal;
• They also have the same hash value, so they work fine in a collection or dictionary.

Need to note:

• If your class is a mutable object (for example, properties can be modified), then be careful to implement __hash__ , because once the object is put into the set or used as a dictionary key and then modify the property will cause a change in the hash value, which will cause problems.
• If you only implement __eq__ and not __hash__ , your instance will not be used as a dictionary key or placed in a collection.

Common misunderstandings and precautions

Sometimes novices mistakenly think that just writing __eq__ is enough, but in fact this is not enough. Here are some easy places to get stuck:

• __hash__ is not implemented at the same time : this way the instance cannot be used as a dictionary key or collection element;
• The properties used by __eq__ and __hash__ are inconsistent : they will cause logical confusion, such as the two objects appear to be equal but have different hash values;
• Implement __hash__ for mutable objects : If the object changes properties after being placed in the collection, it will never be found;
• Forgot to return an integer : __hash__ must return an integer, otherwise an error will be reported.

Another small detail is: if you are using Python 3.7 and use dataclass , you can automatically generate __eq__ and __hash__ methods by setting @dataclass(eq=True) , eliminating the manual writing process.

Basically that's it. These two methods are not complicated by themselves, but it is easy to ignore some details in actual use, especially when it comes to hash structures. Just remember that equality and hash must be consistent, and most problems can be avoided.

The above is the detailed content of Python `__eq__` and `__hash__` methods. For more information, please follow other related articles on the PHP Chinese website!