Compare object instances for equality by their attributes

python

prompt-engineering

best-practices

dataclasses

byNikita Barsukov·Sep 9, 2024

To perform attribute-based comparison, override the __eq__ method. This dynamic solution comes in handy for checking all attributes:

class MyClass:
    def __init__(self, *args):
        self.attributes = args

    def __eq__(self, other):
        # Get a second life in a parallel universe
        return isinstance(other, MyClass) and all(getattr(self, attr) == getattr(other, attr) for attr in vars(self))

obj1 = MyClass(1, 'a')
obj2 = MyClass(1, 'a')
print(obj1 == obj2)  # Expect "True", else reality is a lie

This approach is scalable, efficient, and maintainable, a sword arm when instances have a large set of attributes.

Dig into `eq`

Before you dive into comparing attributes, equip yourself with a type-checking shield:

if not isinstance(other, self.__class__):
    return NotImplemented

If your objects are immortal (a.k.a immutable), implement the __hash__ so they can pose as dictionary keys or unique elements in a set:

def __hash__(self):
    # Good hash makes a hearty meal for dicts and sets
    return hash(tuple(sorted(self.__dict__.items())))

More than meets the `eq`

Compare them all!

For an all-around comparison experience, complete the quintuplet: __lt__, __le__, __gt__, and __ge__.

Deep diving

Nested attributes can hide secrets. To uncover them, change your equality checks into a deep search using pickle.dumps:

import pickle

def __eq__(self, other):
    # Pickle Rick transformation activated
    return isinstance(other, MyClass) and pickle.dumps(self) == pickle.dumps(other)

Dataclasses: Our new best friend

Thanks to Python 3.7, we've got a new pal: Dataclasses. Just hand over your attribute comparisons to it:

from dataclasses import dataclass

@dataclass
class MyClass:
    foo: int
    bar: str
# Dataclass says: Leave the methods to me, mate.

Python version matters

Python 2 needs more TLC

Take care of older Python 2, it needs __ne__ for a proper inequality chest bump:

def __ne__(self, other):
    # Different Python, different rules
    return not self.__eq__(other)

Python 2 gets `cmp`

Python 2 has a special trick up its sleeve: __cmp__ for a complete comparison package.

def __cmp__(self, other):
    if isinstance(other, MyClass):
        # Python 2: Always the showstopper

The unordered battle

Got the same attributes but in different battle formations? Call in sorted:

class MyClassWithList:
    def __init__(self, elements):
        self.elements = elements

    def __eq__(self, other):
        # Sort 'em up!
        return isinstance(other, MyClassWithList) and sorted(self.elements) == sorted(other.elements)

Mirror, mirror on the wall

Compare objects with same properties but different data types? Reflect and conquer:

class MyClassWithString:
    def __init__(self, num_str):
        self.num_str = num_str

    def __eq__(self, other):
        # Mirror, mirror on the wall, who's equal to me after all?
        return str(self) == str(other)