Checking Equivalence Between Objects

I have a question. If I check class instances for equality (==) it returns True when class is declared using dataclass class syntax and False if a class is declared with regular class syntax. Why is that? I had read the documentation on dataclasses, but it does not say anything about storing class instances any differently than class that is using regular class syntax. The difference in output applies only to equality comparison, every other comparison is the same between two classes. I use Python 3.11 if it matters.

@dataclass
class Point:
    dimensions = 2
    x: int
    y: int


origin = Point(0, 0)
target = Point(0, 0)

print("Comparison using dataclass class syntax:\n")
print(f"{origin == target = }") # True
print(f"{origin is target = }") # False
print(f"{isinstance(origin, Point) = }") # True
print(f"{isinstance(target, Point) = }") # True
print(f"{type(origin) == type(target) = }") # True

print("=" * 54)

class Point2:
    dimensions = 2

    def __init__(self, x, y):
        self.x = x
        self.y = y


origin2 = Point2(0, 0)
target2 = Point2(0, 0)

print("Comparison using original class syntax:\n")
print(f"{origin2 == target2 = }") # False
print(f"{origin2 is target2 = }") # False
print(f"{isinstance(origin2, Point2) = }") # True
print(f"{isinstance(target2, Point2) = }") # True
print(f"{type(origin2) == type(target2) = }") # True

@DimaG With a regular class, you have ultimate control over the comparison logic between its instances. By default, Python compares objects of your class by their identity, which is their memory address in CPython. Take a look at this example:

>>> class RegularClass:
...     pass

>>> instance1 = RegularClass()
>>> instance2 = RegularClass()

>>> instance1 == instance2
False

The two objects compare unequal because they are two separate objects, even if they happen to represent the same value conceptually. To change that, for example, by tying the result of the equality test to values stored in your objects, you can override the equality test operator (==) by implementing the special method .__eq__() in your class:

>>> class RegularClass:
...     def __init__(self, value):
...         self.value = value
...     
...     def __eq__(self, other):
...         if other is self:
...             return True
...         if type(self) is not type(other):
...             return False
...         return self.value == other.value

>>> instance1 = RegularClass(42)
>>> instance2 = RegularClass(42)
>>> instance3 = RegularClass(555)

>>> instance1 == instance2
True

>>> instance1 == instance3
False

Now, the objects of your class behave differently. The two instances that represent the same value, 42, compare equal. However, the third instance is considered unequal to the other two because, although it has the same type, it contains a different value.

Side note: If you intend to use objects of your class as dictionary keys or set members, then you should also provide the corresponding implementation of the special method .__hash__() to follow the hash-equal contract.

When you decorate your class with the @dataclass decorator, Python generates a number of special methods, including the .__eq__() and .__hash__() for you. Because data classes represent data, their comparison is assumed to work like in the second example above, where the attribute values of your data class determine equality:

>>> from dataclasses import dataclass

>>> @dataclass
... class DataClass:
...     value: int
... 
>>> DataClass(42) == DataClass(42)
True

>>> DataClass(42) == DataClass(555)
False

There’s nothing special about data classes. They’re just syntactic sugar that does some work for you under the surface.