Какой надежный способ узнать хешируемый ли объект?

Как проверить, хешируемый ли объект

У хешируемых объектов есть метод __hash__(), а у нехешируемых — __hash__ = None. Надежный способ проверить хешируемость — попробовать вызвать встроенную функцию hash().

Способ 1: Использование try-except (самый надежный)

def is_hashable(obj):
    try:
        hash(obj)
        return True
    except TypeError:
        return False

# Примеры
print(is_hashable(5))              # True (int хешируемый)
print(is_hashable((1, 2)))         # True (tuple хешируемый)
print(is_hashable([1, 2]))         # False (list нехешируемый)
print(is_hashable({"a": 1}))       # False (dict нехешируемый)
print(is_hashable("string"))       # True (str хешируемый)
print(is_hashable({1, 2}))         # False (set нехешируемый)

Это самый надежный подход, так как он проверяет не наличие метода, а фактическую способность объекта быть хешируемым.

Способ 2: Проверка атрибута hash

def is_hashable_v2(obj):
    return hasattr(obj, '__hash__') and obj.__hash__ is not None

print(is_hashable_v2(5))           # True
print(is_hashable_v2([1, 2]))      # False

Этот способ менее надежный, так как наличие __hash__ не гарантирует хешируемость, если объект не мутабелен. Лучше использовать hash().

Способ 3: Использование collections.abc.Hashable

from collections.abc import Hashable

def is_hashable_v3(obj):
    return isinstance(obj, Hashable)

print(is_hashable_v3(5))           # True
print(is_hashable_v3([1, 2]))      # False
print(is_hashable_v3("text"))      # True

Этот вариант более аккуратен семантически, используя абстрактный базовый класс.

Почему try-except наиболее надежен

Рассмотрим нестандартный случай:

class WeirdClass:
    __hash__ = 5  # Не метод, а атрибут со значением 5
    
obj = WeirdClass()
print(hasattr(obj, '__hash__'))    # True
print(obj.__hash__ is not None)    # True

try:
    hash(obj)  # TypeError: unhashable type: 'WeirdClass'
except TypeError:
    print("На самом деле не хешируемый!")  # Выведется

Так что try-except с вызовом hash() — самый надежный способ.

Практическое применение

def can_be_dict_key(obj):
    """Проверить, может ли объект быть ключом словаря"""
    try:
        hash(obj)
        return True
    except TypeError:
        return False

# Использование
objects = [5, "hello", [1, 2], (3, 4), {"a": 1}]
for obj in objects:
    status = "можно" if can_be_dict_key(obj) else "нельзя"
    print(f"{obj}: {status} использовать как ключ")

Вывод:

5: можно использовать как ключ
hello: можно использовать как ключ
[1, 2]: нельзя использовать как ключ
(3, 4): можно использовать как ключ
{'a': 1}: нельзя использовать как ключ

Почему это важно

Хешируемость критична при:

• Использовании как ключей словаря: my_dict[obj] = value
• Добавлении в множество: my_set.add(obj)
• Использовании в функциях с кэшированием: @cache требует хешируемых аргументов

Итог: используй try: hash(obj) except TypeError: return False — это мост между теорией (наличие метода) и практикой (фактическая хешируемость).