Как отличить один экземпляр от другого в Python?

Как отличить один экземпляр от другого в Python

Этот вопрос раскрывает понимание идентичности (identity) vs равенства (equality) в Python — одну из самых важных концепций для написания надёжного кода.

1. Идентичность (identity) vs Равенство (equality)

Это два разных концепта, которых часто путают:

# Идентичность — это один и тот же объект в памяти?
a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)   # True — значения одинаковые (равенство)
print(a is b)   # False — разные объекты в памяти (идентичность)
print(a is c)   # True — один и тот же объект

print(id(a))    # Адрес в памяти a
print(id(b))    # Адрес в памяти b (другой)
print(id(c))    # Адрес в памяти c (как a)

Визуально:

# a и c — это один объект, указывающий на одно и то же место в памяти
a = [1, 2, 3]  # Объект в памяти 0x7f8b8c0d5f40
c = a           # Ещё одна переменная, указывающая на тот же объект

# b — это другой объект, но с такими же значениями
b = [1, 2, 3]  # Объект в памяти 0x7f8b8c0d5f80

2. Оператор is — проверка идентичности

is — это оператор для проверки, указывают ли два имена на один и тот же объект в памяти.

class User:
    def __init__(self, name):
        self.name = name

user1 = User('John')
user2 = User('John')
user3 = user1

print(user1 is user2)  # False — разные объекты
print(user1 is user3)  # True — один объект
print(user1 == user2)  # False по умолчанию (если не переопределить __eq__)

# Со строками и маленькими числами Python кеширует значения
a = 5
b = 5
print(a is b)  # True (Python кеширует маленькие числа)

str1 = 'hello'
str2 = 'hello'
print(str1 is str2)  # True (Python интернирует строки)

# Но с большими числами и строками это не работает
x = 256
y = 256
print(x is y)  # True

x = 257
y = 257
print(x is y)  # False! (257 больше границы кеша)

3. Оператор == — проверка равенства

== сравнивает значения объектов. Его поведение зависит от того, переопределён ли метод __eq__.

class User:
    def __init__(self, name):
        self.name = name

user1 = User('John')
user2 = User('John')

# По умолчанию __eq__ основан на идентичности
print(user1 == user2)  # False — разные объекты

# Переопределить __eq__
class User:
    def __init__(self, name):
        self.name = name
    
    def __eq__(self, other):
        """Сравнивать по значению name"""
        if not isinstance(other, User):
            return NotImplemented
        return self.name == other.name
    
    def __hash__(self):
        """Необходимо переопределить, если переопределить __eq__"""
        return hash(self.name)

user1 = User('John')
user2 = User('John')

print(user1 == user2)  # True — одинаковые значения
print(user1 is user2)  # False — разные объекты

4. Метод eq — переопределение равенства

Когда нужно кастомное сравнение, переопредели __eq__:

class Product:
    def __init__(self, id, name, price):
        self.id = id
        self.name = name
        self.price = price
    
    def __eq__(self, other):
        """Два продукта равны, если у них одинаковый ID"""
        if not isinstance(other, Product):
            return NotImplemented  # Позволить другому объекту попробовать
        return self.id == other.id
    
    def __hash__(self):
        """Обязательно, если переопределить __eq__"""
        return hash(self.id)
    
    def __repr__(self):
        return f"Product(id={self.id}, name={self.name}, price={self.price})"

product1 = Product(1, 'Laptop', 999)
product2 = Product(1, 'Laptop', 999)  # Другой объект, но тот же ID
product3 = Product(2, 'Mouse', 29)

print(product1 == product2)  # True — одинаковый ID
print(product1 is product2)  # False — разные объекты
print(product1 == product3)  # False — разный ID

# Работает в множествах и словарях
products = {product1, product2, product3}
print(len(products))  # 2 — product1 и product2 считаются одинаковыми

5. Метод ne — не равно

class User:
    def __init__(self, name):
        self.name = name
    
    def __eq__(self, other):
        if not isinstance(other, User):
            return NotImplemented
        return self.name == other.name
    
    def __ne__(self, other):
        """Не равно (по умолчанию — противоположность __eq__)"""
        result = self.__eq__(other)
        if result is NotImplemented:
            return result
        return not result

user1 = User('John')
user2 = User('Jane')

print(user1 != user2)  # True

6. Другие операторы сравнения

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __eq__(self, other):
        if not isinstance(other, Person):
            return NotImplemented
        return self.name == other.name and self.age == other.age
    
    def __lt__(self, other):
        """Меньше чем (по возрасту)"""
        if not isinstance(other, Person):
            return NotImplemented
        return self.age < other.age
    
    def __le__(self, other):
        """Меньше или равно"""
        if not isinstance(other, Person):
            return NotImplemented
        return self.age <= other.age
    
    def __gt__(self, other):
        """Больше чем"""
        if not isinstance(other, Person):
            return NotImplemented
        return self.age > other.age
    
    def __ge__(self, other):
        """Больше или равно"""
        if not isinstance(other, Person):
            return NotImplemented
        return self.age >= other.age

person1 = Person('John', 30)
person2 = Person('Jane', 25)
person3 = Person('John', 30)

print(person1 == person3)  # True
print(person1 < person2)   # False (John старше)
print(person2 < person1)   # True (Jane младше)

# Сортировка
people = [person1, person2, person3]
people.sort()  # Сортирует по возрасту
for p in people:
    print(f"{p.name}: {p.age}")

7. functools.total_ordering — автоматизация

Если переопределить __eq__ и одну из операций сравнения, total_ordering автоматизирует остальные:

from functools import total_ordering

@total_ordering
class Version:
    def __init__(self, major, minor):
        self.major = major
        self.minor = minor
    
    def __eq__(self, other):
        if not isinstance(other, Version):
            return NotImplemented
        return (self.major, self.minor) == (other.major, other.minor)
    
    def __lt__(self, other):
        if not isinstance(other, Version):
            return NotImplemented
        return (self.major, self.minor) < (other.major, other.minor)
    
    def __repr__(self):
        return f"Version({self.major}.{self.minor})"

v1 = Version(1, 0)
v2 = Version(2, 0)
v3 = Version(1, 5)

print(v1 < v2)   # True
print(v1 <= v3)  # True (автоматически определено)
print(v2 > v1)   # True (автоматически определено)
print(v1 == v3)  # False

8. Практический пример: уникальный ID

import uuid

class Entity:
    """Базовый класс с уникальным ID"""
    def __init__(self):
        self.id = uuid.uuid4()  # Уникальный идентификатор
    
    def __eq__(self, other):
        if not isinstance(other, Entity):
            return NotImplemented
        return self.id == other.id  # Сравнивать по ID
    
    def __hash__(self):
        return hash(self.id)
    
    def __repr__(self):
        return f"{self.__class__.__name__}(id={self.id})"

entity1 = Entity()
entity2 = Entity()
entity3 = entity1

print(entity1 == entity2)  # False — разные ID
print(entity1 is entity3)  # True — один объект
print(entity1 == entity3)  # True — одинаковый ID

# В наборах
entities = {entity1, entity2, entity3}
print(len(entities))  # 2 — entity1 и entity3 считаются одинаковыми по ID

Ключевые моменты

• is — проверить идентичность (один и тот же объект)
• == — проверить равенство (одинаковые значения)
• __eq__() — переопределить, как сравнивать объекты по значению
• __hash__() — необходимо переопределить, если переопределить __eq__
• __lt__, __le__, __gt__, __ge__ — для сравнения больше/меньше
• @total_ordering — автоматизировать остальные операции сравнения
• NotImplemented — возвращать, если сравнение невозможно
• ID или UUID — использовать уникальный идентификатор для различения

Понимание разницы между идентичностью и равенством критично для написания правильного и предсказуемого Python кода.