Как использовать произвольный класс как элемент множества в Python?

Как использовать произвольный класс как элемент множества в Python?

В Python множество (set) требует от элементов двух свойств: hashability (хешируемость) и immutability (неизменяемость). По умолчанию пользовательские классы не хешируемы, поэтому нельзя добавить их экземпляры в set.

Проблема: Почему пользовательские классы не работают в set?

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

user1 = User("Alice", 30)
user2 = User("Alice", 30)

# Попытка добавить в set
try:
    users_set = {user1, user2}
except TypeError as e:
    print(f"Ошибка: {e}")
    # TypeError: unhashable type: 'User'

Проблема: Python не знает, как вычислить хеш для User.

Решение 1: Реализовать hash и eq

Для использования класса в set, нужно определить методы __hash__() и __eq__():

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # Определяем как вычисляется хеш
    def __hash__(self):
        return hash((self.name, self.age))
    
    # Определяем как сравниваются объекты
    def __eq__(self, other):
        if not isinstance(other, User):
            return False
        return self.name == other.name and self.age == other.age
    
    def __repr__(self):
        return f"User({self.name}, {self.age})"

# Теперь можно добавить в set
user1 = User("Alice", 30)
user2 = User("Alice", 30)  # Такой же
user3 = User("Bob", 25)

users_set = {user1, user2, user3}
print(users_set)  # {User(Alice, 30), User(Bob, 25)}
print(len(users_set))  # 2 (user1 и user2 считаются одинаковыми)

# Можно использовать в словаре как ключ
users_dict = {user1: "info1", user3: "info3"}
print(users_dict[user2])  # "info1" (user2 равен user1)

Решение 2: Использовать @dataclass с frozen=True

Dataclass автоматически генерирует __hash__ и __eq__:

from dataclasses import dataclass

@dataclass(frozen=True)  # frozen=True делает объект неизменяемым и хешируемым
class User:
    name: str
    age: int

user1 = User("Alice", 30)
user2 = User("Alice", 30)
user3 = User("Bob", 25)

users_set = {user1, user2, user3}
print(users_set)  # {User(name='Alice', age=30), User(name='Bob', age=25)}
print(len(users_set))  # 2

# Также работает как ключ словаря
users_dict = {user1: "admin", user3: "user"}

Важно: frozen=True делает объект неизменяемым, что необходимо для хешируемости.

Решение 3: Использовать UUID как идентификатор

Для больших объектов хешировать все поля неэффективно:

import uuid
from dataclasses import dataclass, field

@dataclass(frozen=True)
class User:
    id: str = field(default_factory=lambda: str(uuid.uuid4()))
    name: str = field(compare=False)  # Не используется в сравнении
    age: int = field(compare=False)   # Не используется в сравнении
    
    def __hash__(self):
        return hash(self.id)

user1 = User(id="123", name="Alice", age=30)
user2 = User(id="123", name="Alice", age=30)  # Другое имя и возраст
user3 = User(id="456", name="Bob", age=25)

users_set = {user1, user2, user3}
print(len(users_set))  # 2 (user1 и user2 имеют одинаковый id)

Важные правила для hash

Правило 1: Если a == b, то hash(a) == hash(b)

class BadUser:
    def __init__(self, name):
        self.name = name
    
    def __eq__(self, other):
        return self.name == other.name
    
    def __hash__(self):
        return hash(self.name)  # Правильно!

user1 = BadUser("Alice")
user2 = BadUser("Alice")

assert user1 == user2
assert hash(user1) == hash(user2)  # ✅ Хеши одинаковые

Правило 2: Хеш объекта НЕ должен меняться

# ❌ НЕПРАВИЛЬНО — объект мутабельный
class BadUser:
    def __init__(self, name):
        self.name = name
    
    def __hash__(self):
        return hash(self.name)

user = BadUser("Alice")
users_set = {user}
user.name = "Bob"  # Изменили объект!
print(user in users_set)  # False (хеш изменился!)

# ✅ ПРАВИЛЬНО — объект неизменяемый
@dataclass(frozen=True)
class GoodUser:
    name: str

user = GoodUser("Alice")
users_set = {user}
# user.name = "Bob"  # Ошибка! frozen=True запрещает изменения

Практический пример

from dataclasses import dataclass
from typing import Set

@dataclass(frozen=True)
class Product:
    sku: str  # Stock Keeping Unit
    name: str
    price: float

# Работает в set
products = {
    Product("SKU001", "Laptop", 1000),
    Product("SKU002", "Mouse", 25),
    Product("SKU001", "Laptop", 1000),  # Дубликат
}
print(f"Уникальные товары: {len(products)}")  # 2

# Работает как ключ словаря
stock = {
    Product("SKU001", "Laptop", 1000): 5,
    Product("SKU002", "Mouse", 25): 50,
}

# Поиск в set очень быстрый O(1)
laptop = Product("SKU001", "Laptop", 1000)
if laptop in products:
    print(f"В наличии: {stock[laptop]} шт")

# Операции над множествами
products1 = {Product("SKU001", "Laptop", 1000)}
products2 = {Product("SKU001", "Laptop", 1000), Product("SKU002", "Mouse", 25)}

intersection = products1 & products2
print(f"Пересечение: {intersection}")

union = products1 | products2
print(f"Объединение: {union}")

Альтернатива: Если объект мутабельный

Если нельзя сделать класс неизменяемым, используйте другие структуры:

class MutableUser:
    def __init__(self, name):
        self.name = name  # Может меняться

# ❌ Нельзя использовать в set
# users_set = {MutableUser("Alice")}  # TypeError

# ✅ Альтернативы:

# 1. Список (неупорядоченно, медленный поиск)
users_list = [MutableUser("Alice"), MutableUser("Bob")]
if any(u.name == "Alice" for u in users_list):
    print("Найден")

# 2. Словарь с ID как ключ
users_by_id = {
    1: MutableUser("Alice"),
    2: MutableUser("Bob"),
}

# 3. Использовать id() для идентификации
users_set = {id(user) for user in [MutableUser("Alice")]}

Итоговое резюме

Лучшая практика: Используйте @dataclass(frozen=True) — это простой и надёжный способ сделать класс элементом set.